Acredite ou não, os Sex Bob-ombs se tornaram uma banda mundialmente famosa e estão atualmente em turnê mundial! Como contador, você deve supervisionar as finanças do dia a dia e fornecer relatórios regulares.

A cada poucas semanas, você compila uma lista de suas despesas (em dólares inteiros ) na ordem em que foram incorridas.

Por exemplo, a lista

378
-95
2234

significa que $ 378 foram depositados em sua conta e, depois disso, $ 95 foram retirados e, em seguida, $ 2234 foram depositados.

Você quer ter certeza de que a soma parcial destes valores nunca cai abaixo de algum valor limiar T . Você decide escrever um programa para fazer isso por você.

Desafio

Escreva um programa ou função que obtenha um único número inteiro T e uma lista de números inteiros. Se a soma da lista de números inteiros for menor que T , imprima ou retorne um valor falso , caso contrário, imprima ou retorne um valor verdadeiro.

Você pode usar qualquer método de entrada usual (stdin, do arquivo, linha de comando, argumentos para funcionar).

• No início da lista, a soma corrente é 0. Portanto, um T positivo significa que o resultado é sempre falso.
• + nunca estará na frente de números inteiros positivos.
• A lista pode conter 0.
• A lista pode estar vazia.

Casos de teste

T é -5 em todos estes.

Falsy:

-6

1
2
3
-20

200
-300
1000

Verdade:

[empty list]

-5

4
-3
-6

Pontuação

O envio com o menor número de bytes vence. O desempatador vai para a primeira submissão postada.

^{O comentário lamentável que me forçou a fazer isso.}

gs2 - 6 bytes

Suponha que a lista esteja no topo da pilha e o limite esteja no registro A. Nos mnemônicos:

inits
sum get-a lt filter3
not

No bytecode:

78 64 D0 70 F2 22

Haskell, 22 bytes

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

Uso: f (-5) [4,-3,-6]quais saídas True.

Faça uma lista de subtotais e verifique se todos os elementos são> = t.

Edit: Bugfix para lista vazia tes positivo

Python 2, 41

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

O primeiro argumento é a matriz; o segundo é o total mínimo de rodadas.

J, 11 bytes

   */@:<:0,+/\

Testes

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

Aprimoramento de 1 byte graças ao FUZxxl .

Explicação para a versão original (*/@(<:0,+/\))

• +/\cria uma soma em execução (soma +/de prefixos \)
• 0,+/\ anexa um 0 à soma corrente
• (<:0,+/\)entrada do lado esquerdo menor ou igual <:a (elementos do) resultado da 0,+/\entrada do lado direito
• @ com o resultado anterior
• */ produto de todos os elementos (1 se todos os elementos forem 1, 0 se um elemento for 0)

APL, 8 10

∧.≤∘(0,+\)

Esta é uma função que assume Tcomo argumento à esquerda e a lista como argumento à direita.

• 0,+\: executando a soma do argumento correto, anexado a um 0
• ∧.≤: argumento esquerdo menor ou igual (≤) a todos os itens (∧) no argumento direito

Mathematica, 34 bytes

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

Isso define uma função variadic sem nome que assume Tcomo o primeiro parâmetro e as transações como os parâmetros restantes, e retorna um booleano:

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

Eu gosto disso porque eu poderia usar o bastante raro ##2que "divide" todos os argumentos do segundo para a lista. Para mais detalhes, consulte a última seção nesta dica de golfe .

k, 8 caracteres

Um verbo diádico assumindo o limite como o primeiro argumento e a lista como o segundo. Notavelmente, isso funciona em todas as versões do k, incluindo o Kona de código aberto.

&/~0<-\,

Em k, a composição das funções é feita apenas escrevendo uma e depois a outra, para que possamos dividir isso por funções. Da direita para esquerda:

• -\,toma somas de execução sucessivas e as subtrai do limite. (Se ffor diádico, então se f\ (a; b; c; ...) expande para (a; a f b; (a f b) f c; ...). ,Apenas junta listas.) A quebra ocorre mesmo quando algo é igual a 0, e o excesso de valor fornece valores estritamente positivos.
• ~0<não é 0 menor que. k realmente não tem um <=operador maior que ou igual a , então temos que jogar o booleano NOT em um menor que, mas isso testa se o resultado é não positivo. Aplica-se automaticamente a cada átomo da lista.
• &/é a dobra lógica E sobre uma lista. (Para fdiádico) Portanto, isso testa se todos os booleanos da lista são True.

Exemplos:

  (&/~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<:+!

Recebe a entrada como um número inteiro e uma matriz no estilo CJam em STDIN:

-5 [1 2 3 -20]

Teste aqui.

Pitão, 16 15

!sm>vzs+0<QdhlQ

Experimente online com a entrada

-5
[4, -3, 6]

Explicação:

                   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(...)

E novamente o estúpido s função desperdiça dois bytes. Acho que vou relatar isso como um bug no repositório Pyth.

editar: 13 (não válido)

Agradecemos a isaacg por salvar um byte ( >1em !) e por alterar a implementação sno repositório Pyth. Agora, o código a seguir é possível (mas é claro que não é válido para esse desafio).

!sm>vzs<QdhlQ

R, 35

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

Experimente aqui

Julia, 33 bytes

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

Isso cria uma função sem nome que aceita dois parâmetros, Te l, e retorna um booleano.

A all()função faz todo o trabalho pesado aqui. São necessários dois argumentos: um predicado e um iterável. Para o predicado, dizemos que irepresenta o valor atual do iterável usando uma função sem nome, especificada por i->. Em cada iteração, comparamos icom o Tuso i>=T.

Para garantir que Julia não fique surtada com o uso cumsum()de uma lista vazia, podemos usar zero [0, l].

Prelúdio , 144 136 bytes

Isso foi ... difícil ...

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

Eu acho que 6 vozes é um novo recorde para mim, embora eu tenha certeza de que há uma maneira de reduzir isso e livrar-se de muitos espaços em branco irritantes. Verificar o sinal de um valor (e, portanto, verificar se um valor é maior que outro) é bastante complicado no Prelude.

Entrada e saída são fornecidas como valores de bytes. Quando você usa o interpretador Python , pode definir NUMERIC_OUTPUT = True, para obter um ASCII 0ou 1. Para entrada numérica, você teria que adicionar outro NUMERIC_INPUTsinalizador (eu provavelmente publicaria meu intérprete ajustado em algum momento).

Observe também que o Prelude não pode realmente distinguir o final de uma lista de um 0dentro da lista. Então, para permitir zero transações, estou lendo T, depois o comprimento Lda lista e depois as Ltransações.

CJam, 18 bytes

Outra abordagem nos mesmos bytes que a outra.

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

Recebe entrada via STDIN na forma de <threshold> <array of transactions>

Experimente online aqui

JavaScript (ES6) 38 33

Editar Corrigido o erro de saldo inicial. Thx @martin & @rainbolt

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

Teste no console 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
verdadeiro verdadeiro verdadeiro
falso falso

Python 2.7 - 55 bytes

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

Call like print f(-5,[1,2,3,-20]). Test it here.

Thanks to Jakube for helping.

><>, 29 + 3 = 32 bytes

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

Run like

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

where the threshold is the first number.

Octave, 27

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

Perl 6 (21 bytes)

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

It's a function taking initial argument, and list of elements. It works by checking if none (by using junctions) of elements are below the threshold. [\+] is used for generating running sum, for example [\+] 1, 2, 3 gives 1, 3, 6. 0, to append 0 at beginning of list is needed because of requirement that positive threshold always should fail.

Pretty much the same thing as Haskell solution, just in Perl 6 syntax (Perl 6 took so many neat programming features from Haskell).

Perl - 20

Pegue a lista de números STDINseparados por novas linhas e leve Tcom a -ibandeira.

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

+2 para -ie -nsinalizadores. O valor de saída é 255para falhas e 0com êxito.

Correr com:

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

Clojure, 45

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

Por exemplo

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

Ou um lil 'mais agradável;

(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

Função Golfed:

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;} 

Ungolfed:

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 de driver:

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));
}

}

Resultado:

bash-3.2$ javac A.java ; java A

false
false
false
above false, below true
true
true
true