¡Lo creas o no, los Sex Bob-ombs se han convertido en una banda mundialmente famosa y actualmente están de gira mundial! Como contable , debe supervisar sus finanzas diarias y proporcionar informes periódicos.

Cada pocas semanas compila una lista de sus gastos (en USD completos ) en el orden en que se incurrieron.

Por ejemplo, la lista

378
-95
2234

significa que se depositaron $ 378 en su cuenta, y luego se retiraron $ 95, y luego se depositaron $ 2234.

Usted quiere asegurarse de que la suma acumulada de estos valores nunca pasa por debajo de un valor umbral T . Decide escribir un programa para hacer esto por usted.

Desafío

Escriba un programa o función que tome un solo entero T y una lista de enteros. Si la suma de la lista de enteros es menor que T , imprima o devuelva un valor falso , de lo contrario imprima o devuelva un valor verdadero.

Puede usar cualquier método de entrada habitual (stdin, desde archivo, línea de comando, argumentos para funcionar).

• Al comienzo de la lista, la suma acumulada es 0. Entonces, una T positiva significa que el resultado siempre es falso.
• + nunca estará frente a enteros positivos.
• La lista puede contener 0.
• La lista puede estar vacía.

Casos de prueba

T es -5 en todos estos.

Falsy

-6

1
2
3
-20

200
-300
1000

Verdad:

[empty list]

-5

4
-3
-6

Puntuación

El envío con la menor cantidad de bytes gana. Tiebreaker va a la primera publicación publicada.

^{El lamentable comentario que me obligó a hacer esto.}

gs2 - 6 bytes

Suponga que la lista está en la parte superior de la pila y el umbral está en el registro A. En mnemónicos:

inits
sum get-a lt filter3
not

En bytecode:

78 64 D0 70 F2 22

Haskell, 22 bytes

f t=all(>=t).scanl(+)0

Uso: f (-5) [4,-3,-6]que salidas True.

Haga una lista de subtotales y verifique si todos los elementos son> = t.

Editar: corrección de errores para la lista vacía y ts positivo

Pitón 2, 41

f=lambda a,t:t<=0<(a and f(a[1:],t-a[0]))

El primer argumento es la matriz; el segundo es el total mínimo acumulado.

J, 11 bytes

   */@:<:0,+/\

Pruebas

   _5 (*/@:<:0,+/\)  1 2 3 _20
0
   _5 (*/@:<:0,+/\)  >a: NB. empty list
1

Mejora de 1 byte gracias a FUZxxl .

Explicación de la versión original. (*/@(<:0,+/\))

• +/\crea una suma continua (suma +/de prefijos \)
• 0,+/\ agrega un 0 a la suma acumulada
• (<:0,+/\)entrada del lado izquierdo menor o igual <:que (elementos de) resultado de 0,+/\la entrada del lado derecho
• @ con el resultado anterior
• */ producto de todos los elementos (1 si todos los elementos son 1, 0 si un elemento es 0)

APL, 8 10

∧.≤∘(0,+\)

Esta es una función que toma Tcomo argumento izquierdo y la lista como argumento derecho.

• 0,+\: suma de ejecución del argumento correcto, agregado a un 0
• ∧.≤: argumento izquierdo menor o igual (≤) que todos los elementos (∧) en el argumento derecho

Mathematica, 34 bytes

FreeQ[Accumulate@{0,##2},n_/;n<#]&

Esto define una función variable sin nombre que toma Tcomo primer parámetro y las transacciones como los parámetros restantes, y devuelve un valor booleano:

FreeQ[Accumulate@{0,##2},n_/;n<#]&[-5, 1, 2, 3, -20]
(* False *)

Me gusta esto porque podría hacer uso de lo bastante raro ##2que "salpica" todos los argumentos del segundo en la lista. Para más detalles vea la última sección en este consejo de golf .

k, 8 caracteres

Un verbo diádico que toma el umbral como primer argumento y la lista como el segundo. Sorprendentemente, esto funciona en todas las versiones de k, incluida la fuente abierta Kona.

&/~0<-\,

En k, la composición de funciones solo se realiza escribiendo una y luego la otra, por lo que podemos dividir esto por funciones. De derecha a izquierda:

• -\,toma sumas sucesivas y las resta del umbral. (Si fes diádico, entonces se f\ (a; b; c; ...) expande a (a; a f b; (a f b) f c; ...). ,Solo une listas juntas). La ruptura ocurre incluso cuando algo es igual a 0, y el sobregiro da valores estrictamente positivos.
• ~0<no es 0 menor que. k realmente no tiene un <=operador mayor que o igual a , por lo que tenemos que arrojar un valor booleano NOT en un valor menor que, pero esto comprueba si el resultado no es positivo. Se aplica automáticamente a cada átomo en la lista.
• &/es el pliegue de AND lógico sobre una lista. (Para fdiádico) Entonces esto prueba si cada booleano en la lista es Verdadero.

Ejemplos:

  (&/~0<-\,)[-5; 1 2 3 -20]
0
  f:&/~0<-\,  /assign to a name
  f[-5; 4 -3 -6]
1

CJam, 17 bytes

l~0\{1$+}%+\f<:+!

Toma la entrada como un entero y una matriz de estilo CJam en STDIN:

-5 [1 2 3 -20]

Pruébalo aquí.

Pyth, 16 15

!sm>vzs+0<QdhlQ

Pruébelo en línea con la entrada

-5
[4, -3, 6]

Explicación:

                   Implicit: z and Q read 2 line from input
                   z = "-5" (this is not evaluated, it's a string)
                   Q = [4, -3, 6] (this is a list though)
 m         hlQ     map each number d in [0, 1, 2, ..., len(Q)] to:
  >vz                 the boolean value of: evaluated z > 
     s+0<Qd                                 the sum of the first d elements in Q 
!s                  print the boolen value of: 1 > sum(...)

Y nuevamente la estúpida sfunción desperdicia dos bytes. Creo que reportaré esto como un error al repositorio de Pyth.

editar: 13 (no válido)

Gracias a isaacg por guardar un byte ( >1a !) y por cambiar la implementación de sen el repositorio de Pyth. Ahora es posible el siguiente código (pero, por supuesto, no es válido para este desafío).

!sm>vzs<QdhlQ

R, 35

function(t,l)all(cumsum(c(0,l))>=t)

Pruébalo aquí

Julia, 33 bytes

(T,l)->all(i->i>=T,cumsum([0,l]))

Esto crea una función sin nombre que acepta dos parámetros, Ty l, y devuelve un valor lógico.

La all()función hace todo el trabajo pesado aquí. Se necesitan dos argumentos: un predicado y un iterable. Para el predicado, le decimos que irepresenta el valor actual del iterable usando una función sin nombre, especificada por i->. Luego, en cada iteración, lo comparamos icon el Tuso i>=T.

Para asegurarnos de que Julia no se asuste por usarla cumsum()en una lista vacía, podemos agregar un cero allí usando [0, l].

Preludio , 144 136 bytes

Esto fue ... difícil ...

?
?(1- )v1+(1-
 ^    #       1) v #  -)1+(#
  v#         vv (##^v^+
   ^?+     v-(0## ^ #   01 #)(#)#
1         v#                  # )!

Creo que 6 voces es un nuevo récord para mí, aunque estoy seguro de que hay una manera de reducir eso y eliminar muchos de esos molestos espacios en blanco. Verificar el signo de un valor (y, por lo tanto, verificar si un valor es mayor que otro) es bastante complicado en Prelude.

La entrada y la salida se dan como valores de byte.Cuando usa el intérprete de Python , puede configurarlo NUMERIC_OUTPUT = True, de modo que realmente obtenga un ASCII 0o 1. Para la entrada numérica, tendría que agregar otro NUMERIC_INPUTindicador (probablemente debería publicar mi intérprete ajustado en algún momento).

También tenga en cuenta que Prelude realmente no puede distinguir el final de una lista de 0dentro de la lista. Entonces, para permitir cero transacciones, estoy leyendoT , luego la longitud Lde la lista y luego las Ltransacciones.

CJam, 18 bytes

Otro enfoque en los mismos bytes que el otro.

q~_,),\f<1fb:)f<:&

Toma entrada a través de STDIN en forma de <threshold> <array of transactions>

Pruébalo en línea aquí

JavaScript (ES6) 38 33

Editar error de saldo inicial fijo. Thx @martin y @rainbolt

F=(t,l)=>![r=0,...l].some(v=>(r+=v)<t)

Prueba en la consola Firefox / FireBug

console.log(F(-5,[-6]),F(-5,[1,2,3,-20]),F(-5,[200,-300,1000]))
console.log(F(-5,[]),F(-5,[-5]),F(-5,[4,-3,-6]))
console.log(F(5,[10]),F(5,[]))

falso falso falso
verdadero verdadero verdadero
falso falso

Python 2.7 - 55 bytes

f=lambda T,l:all(T<=sum(l[:i])for i in range(len(l)+1))

Llama como print f(-5,[1,2,3,-20]). Pruébalo aquí .

Gracias a Jakube por ayudar.

> <>, 29 + 3 = 32 bytes

r0}&v >1n;n0<
&:&:<+^?=1l ^?(

Corre como

py -3 fish.py bookkeep.fish -v -5 4 3 -6

donde el umbral es el primer número.

Octava, 27

@(t,l)all(cumsum([0,l])>=t)

Perl 6 (21 bytes)

{$^a>none [\+] 0,@^b}

Es una función que toma un argumento inicial y una lista de elementos. Funciona comprobando si ninguno ( mediante uniones ) de elementos está por debajo del umbral. [\+]se utiliza para generar suma continua, por ejemplo, [\+] 1, 2, 3da 1, 3, 6. 0,para anexar0 al comienzo de la lista es necesario debido al requisito de que el umbral positivo siempre debe fallar.

Más o menos lo mismo que la solución de Haskell, solo en la sintaxis de Perl 6 (Perl 6 tomó muchas características de programación ordenadas de Haskell).

Perl - 20

Tome la lista de números STDINseparados por nuevas líneas y tome Tcon la -ibandera.

die if$^I>($i+=$_)

+2 para -iy -nbanderas. El valor de salida es 255para fallas y 0en caso de éxito.

Corre con:

echo -e "4\n3\n-6" | perl -i0 -ne'die if$^I>($i+=$_)'

Clojure, 45

(fn[T t](every? #(<= T %)(reductions + 0 t)))

P.ej

((fn[T t](every? #(<= T %)(reductions + 0 t))) -5 [1 2 3 -20])
;; =>false

O un poco más agradable;

(defn f[T t](every? #(<= T %)(reductions + 0 t)))

(testing
  (testing "tests from question"
    (is (false? (f -5 [-6])))
    (is (false? (f -5 [1 2 3 -20])))
    (is (false? (f -5 [200 -300 1000])))
    (is (true? (f -5 [-5])))
    (is (true? (f -5 [4 -3 -6])))
    (is (true? (f -5 []))))
  (testing "the start of the list the running sum is 0. So a positive T means the result is always falsy"
    (is (false? (f 5 [5])))
    (is (false? (f 5 [10])))
    (is (false? (f 5 [])))))

Java 8 - 153 caracteres

Función de golf:

import java.util.stream.*;
boolean f(int t, IntStream s){int r=1;try{s.reduce(0,(a,b)->(a+b>=t)?(a+b):(a/(a-a)));}catch(Exception e){r=0;}return r==1;} 

Sin golf:

import java.util.stream.*;

boolean f(int t, IntStream s) {
    int r=1;
    try {
        s.reduce(0,(a,b) -> (a+b>=t) ? (a+b) : (a/(a-a)));
    } catch(Exception e) {
        r=0;
    }

    return r==1;
} 

Programa del conductor:

import java.util.stream.*;
import java.util.*;

public class A {
    // function f as above

    public static void main(String... args) {
        int t = -5;
        IntStream s = null;

        s = Arrays.asList(-6).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        s = Arrays.asList(1,2,3,-20).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        s = Arrays.asList(200,-300,1000).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        System.out.println("above false, below true");

        s = IntStream.empty();
        System.out.println(new A().f(t,s));

        s = Arrays.asList(4,-3,-6).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        s = Arrays.asList(-5).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));
}

}

Salida:

bash-3.2$ javac A.java ; java A

false
false
false
above false, below true
true
true
true