Che ci crediate o no, i Sex Bob-ombs sono diventati una band di fama mondiale e sono attualmente in tournée mondiale! Come loro contabile devi controllare le loro finanze quotidiane e fornire rapporti periodici.

Ogni poche settimane compili un elenco delle loro spese (in dollari USA ) nell'ordine in cui sono state sostenute.

Ad esempio, l'elenco

378
-95
2234

significa che $ 378 sono stati depositati sul loro conto e dopo che $ 95 sono stati ritirati, e dopo che $ 2234 sono stati depositati.

Si vuole fare in modo che la somma parziale di questi valori non scende mai sotto un certo valore di soglia T . Decidi di scrivere un programma per farlo per te.

Sfida

Scrivi un programma o una funzione che accetta un singolo numero intero T e un elenco di numeri interi. Se la somma corrente dell'elenco di numeri interi è sempre inferiore a T , quindi stampare o restituire un valore errato , altrimenti stampare o restituire un valore veritiero.

È possibile utilizzare qualsiasi metodo di input usuale (stdin, da file, riga di comando, argomenti per funzionare).

• All'inizio dell'elenco la somma corrente è 0. Quindi una T positiva indica che il risultato è sempre falso.
• + non sarà mai di fronte a numeri interi positivi.
• L'elenco può contenere 0.
• L'elenco potrebbe essere vuoto.

Casi test

T è -5 in tutti questi.

Falsy:

-6

1
2
3
-20

200
-300
1000

Truthy:

[empty list]

-5

4
-3
-6

punteggio

Vince l'invio con il minor numero di byte . Tiebreaker arriva al primo invio pubblicato.

^{Il commento deplorevole che mi ha costretto a farlo.}

gs2 - 6 byte

Supponiamo che l'elenco sia in cima allo stack e che la soglia sia nel registro A. In mnemonici:

inits
sum get-a lt filter3
not

Nel bytecode:

78 64 D0 70 F2 22

Haskell, 22 byte

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

Utilizzo: f (-5) [4,-3,-6]quali outputTrue .

Crea un elenco di totali parziali e controlla se tutti gli elementi sono> = t.

Edit: Bugfix per la lista vuota e positivi ts

Python 2, 41

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

Il primo argomento è l'array; il secondo è il totale parziale minimo.

J, 11 byte

   */@:<:0,+/\

test

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

Miglioramento di 1 byte grazie a FUZxxl .

Spiegazione per la versione originale (*/@(<:0,+/\))

• +/\crea una somma parziale (somma +/dei prefissi \)
• 0,+/\ aggiunge uno 0 alla somma corrente
• (<:0,+/\)input sul lato sinistro più piccolo o uguale <:a (elementi di del) risultato 0,+/\dell'ingresso sul lato destro
• @ con il risultato precedente
• */ prodotto di tutti gli elementi (1 se tutti gli elementi sono 1, 0 se un elemento è 0)

APL, 8 10

∧.≤∘(0,+\)

Questa è una funzione che assume Tcome argomento di sinistra e l'elenco come argomento di destra.

• 0,+\: somma corrente dell'argomento giusto, aggiunta a uno 0
• ∧.≤: argomento sinistro più piccolo o uguale (≤) di tutti gli elementi (∧) nell'argomento destro

Mathematica, 34 byte

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

Questo definisce una funzione variadica senza nome che accetta Tcome primo parametro e le transazioni come parametri rimanenti e restituisce un valore booleano:

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

Mi piace perché potrei usare ##2l'elenco piuttosto raro che "splats" tutti gli argomenti dal secondo nell'elenco. Per maggiori dettagli, vedere l'ultima sezione di questo consiglio sul golf .

k, 8 caratteri

Un verbo diadico che prende la soglia come primo argomento e l'elenco come secondo. Sorprendentemente, questo funziona in ogni versione di k, incluso Kona open-source.

&/~0<-\,

In k, la composizione delle funzioni è fatta semplicemente scrivendo l'una e poi l'altra, quindi possiamo dividerla per funzioni. Da destra a sinistra:

• -\,prende le somme consecutive e le sottrae dalla soglia. (Se fè diadico, quindi si f\ (a; b; c; ...) espande a (a; a f b; (a f b) f c; ...). ,Unisce solo gli elenchi.) La rottura si verifica anche quando qualcosa è uguale a 0 e il superamento dà valori strettamente positivi.
• ~0<non è 0 minore di. k non ha realmente un <=operatore maggiore o uguale a , quindi dobbiamo lanciare il valore booleano NOT su un valore minore di, ma questo verifica se il risultato non è positivo. Si applica automaticamente a ciascun atomo nell'elenco.
• &/è la piega dell'AND logico su un elenco. (Per fdiadico) Quindi questo verifica se ogni valore booleano nell'elenco è True.

Esempi:

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

CJam, 17 byte

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

Accetta input come numero intero e un array in stile CJam su STDIN:

-5 [1 2 3 -20]

Provalo qui.

Pyth, 16 15

!sm>vzs+0<QdhlQ

Provalo online con l'input

-5
[4, -3, 6]

Spiegazione:

                   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 ancora una volta la stupida sfunzione spreca due byte. Penso che lo segnalerò come un bug al repository Pyth.

modifica: 13 (non valido)

Grazie a isaacg per un byte save ( >1to !) e per aver modificato l'implementazione snel repository Pyth. Ora è possibile il seguente codice (ma ovviamente non valido per questa sfida).

!sm>vzs<QdhlQ

R, 35

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

Provalo qui

Julia, 33 byte

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

Questo crea una funzione senza nome che accetta due parametri, Te l, e restituisce un valore booleano.

La all()funzione fa tutto il sollevamento pesante qui. Ci vogliono due argomenti: un predicato e un iterabile. Per il predicato, diciamo che irappresenta il valore corrente dell'iterabile usando una funzione senza nome, specificata da i->. Quindi ad ogni iterazione confrontiamo icon l' Tutilizzo i>=T.

Per assicurarci che Julia non impazzisca sull'uso cumsum()in una lista vuota, possiamo virare su uno zero usando [0, l].

Preludio , 144 136 byte

Questo è stato ... difficile ...

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

Penso che 6 voci sia un nuovo record per me, anche se sono sicuro che c'è un modo per ridurlo e sbarazzarsi di quel fastidioso spazio bianco. Controllare il segno di un valore (e quindi verificare se un valore è maggiore di un altro) è abbastanza complicato in Prelude.

Input e output sono dati come valori byte. Quando si utilizza l'interprete Python , è possibile impostare NUMERIC_OUTPUT = True, in modo da ottenere effettivamente un ASCII 0o 1. Per un input numerico, dovresti aggiungere un altro NUMERIC_INPUTflag (probabilmente dovrei pubblicare il mio interprete ottimizzato ad un certo punto).

Si noti inoltre che Prelude non può davvero distinguere la fine di un elenco da un 0all'interno dell'elenco. Quindi, per consentire zero transazioni, sto leggendo T, quindi la lunghezza Ldell'elenco e quindi le Ltransazioni.

CJam, 18 byte

Un altro approccio negli stessi byte dell'altro.

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

Riceve input tramite STDIN sotto forma di <threshold> <array of transactions>

Provalo online qui

JavaScript (ES6) 38 33

Modifica Corretto errore del saldo iniziale. Thx @martin & @rainbolt

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

Test nella 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
vero vero vero
falso falso

Python 2.7 - 55 byte

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

Chiama come print f(-5,[1,2,3,-20]) . Provatelo qui .

Grazie a Jakube per l'aiuto.

> <>, 29 + 3 = 32 byte

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

Corri come

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

dove la soglia è il primo numero.

Ottava, 27

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

Perl 6 (21 byte)

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

È una funzione che prende l'argomento iniziale e un elenco di elementi. Funziona verificando che nessuno ( utilizzando le giunzioni ) di elementi sia inferiore alla soglia. [\+]viene utilizzato per generare la somma corrente, ad esempio [\+] 1, 2, 3dà 1, 3, 6. 0,da aggiungere 0all'inizio dell'elenco è necessario a causa del requisito che la soglia positiva dovrebbe sempre fallire.

Praticamente la stessa cosa della soluzione Haskell, proprio nella sintassi di Perl 6 (Perl 6 ha preso così tante funzioni di programmazione pulite da Haskell).

Perl - 20

Prendi l'elenco dei numeri STDINseparati da newline e prendi Tcon la -ibandiera.

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

+2 per -ie -nbandiere. Il valore di uscita è255 per guasti e 0successo.

Corri con:

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

Clojure, 45

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

Per esempio

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

O un po 'più bello;

(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 caratteri

Funzione golfizzata:

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

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

}

Produzione:

bash-3.2$ javac A.java ; java A

false
false
false
above false, below true
true
true
true