Ob Sie es glauben oder nicht, die Sex Bob-Ombs sind zu einer weltberühmten Band geworden und befinden sich derzeit auf Welttournee! Als ihr Buchhalter müssen Sie ihre täglichen Finanzen überwachen und regelmäßige Berichte vorlegen.

Alle paar Wochen erstellen Sie eine Liste ihrer Ausgaben (in ganzen USD ) in der Reihenfolge, in der sie angefallen sind.

Zum Beispiel die Liste

378
-95
2234

bedeutet, dass 378 $ auf ihr Konto eingezahlt wurden und danach 95 $ abgehoben wurden und danach 2234 $ eingezahlt wurden.

Sie möchten sicherstellen, dass die laufende Summe dieser Werte niemals einen Schwellenwert T unterschreitet . Sie beschließen, ein Programm zu schreiben, das dies für Sie erledigt.

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine einzelne Ganzzahl T und eine Liste von Ganzzahlen enthält. Wenn die laufende Summe der Liste der ganzen Zahlen immer kleiner als T ist , dann drucken Sie einen falschen Wert oder geben Sie ihn zurück , andernfalls drucken Sie einen wahren Wert oder geben Sie ihn zurück.

Sie können alle üblichen Eingabemethoden verwenden (stdin, from file, command line, arguments to function).

• Am Anfang der Liste ist die laufende Summe 0. Ein positives T bedeutet also, dass das Ergebnis immer falsch ist.
• + wird niemals vor positiven ganzen Zahlen stehen.
• Die Liste kann 0 enthalten.
• Die Liste ist möglicherweise leer.

Testfälle

T ist in all diesen -5.

Falsch:

-6

1
2
3
-20

200
-300
1000

Wahrheit:

[empty list]

-5

4
-3
-6

Wertung

Die Einsendung mit den wenigsten Bytes gewinnt. Tiebreaker geht zum frühesten geposteten Beitrag.

^{Der bedauerliche Kommentar, der mich dazu gezwungen hat.}

gs2 - 6 bytes

Angenommen, die Liste befindet sich oben auf dem Stapel und der Schwellenwert befindet sich in Register A. In mnemonics:

inits
sum get-a lt filter3
not

In Bytecode:

78 64 D0 70 F2 22

Haskell, 22 Bytes

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

Verwendung: f (-5) [4,-3,-6]welche Ausgänge True.

Machen Sie eine Liste von Zwischensummen und prüfen Sie, ob alle Elemente> = t sind.

Edit: Bugfix für leere Liste und positive ts

Python 2, 41

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

Das erste Argument ist das Array; Die zweite ist die minimale laufende Summe.

J, 11 Bytes

   */@:<:0,+/\

Tests

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

1-Byte-Verbesserung dank FUZxxl .

Erklärung zur Originalversion (*/@(<:0,+/\))

• +/\erstellt eine laufende Summe (Summe +/der Präfixe \)
• 0,+/\ hängt eine 0 an die laufende Summe an
• (<:0,+/\)linksseitige Eingabe kleiner oder gleich <:(Elemente des) Ergebnisses von 0,+/\rechtsseitige Eingabe
• @ mit dem vorherigen Ergebnis
• */ Produkt aller Elemente (1, wenn alle Elemente 1 sind, 0, wenn ein Element 0 ist)

APL, 8 10

∧.≤∘(0,+\)

Dies ist eine Funktion, die Tals linkes Argument und die Liste als rechtes Argument verwendet.

• 0,+\: laufende Summe des rechten Arguments, angehängt an eine 0
• ∧.≤: linkes Argument kleiner oder gleich (≤) als alle (∧) Elemente im rechten Argument

Mathematica, 34 Bytes

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

Dies definiert eine unbenannte variadische Funktion, die Tals ersten Parameter und die Transaktionen als verbleibende Parameter verwendet und einen Booleschen Wert zurückgibt:

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

Mir gefällt das, weil ich das eher seltene nutzen konnte, das ##2alle Argumente von der zweiten in die Liste "splattet". Weitere Details finden Sie im letzten Abschnitt dieses Golftipps .

k, 8 Zeichen

Ein dyadisches Verb, bei dem der Schwellenwert als erstes Argument und die Liste als zweites Argument verwendet wird. Bemerkenswerterweise funktioniert dies in jeder Version von k, einschließlich der Open-Source-Version von Kona.

&/~0<-\,

In k wird die Komposition von Funktionen nur durch Schreiben der einen und der anderen ausgeführt, sodass wir diese nach Funktionen aufteilen können. Von rechts nach links:

• -\,Nimmt aufeinanderfolgende laufende Summen und subtrahiert sie von der Schwelle. (Wenn fdyadisch ist, dann f\ (a; b; c; ...) erweitert sich zu (a; a f b; (a f b) f c; ...). Verbindet ,nur Listen.) Breaking Even tritt auf, wenn etwas gleich 0 ist, und Overdrawing ergibt streng positive Werte.
• ~0<ist nicht 0 kleiner als. k hat nicht wirklich einen Größer-als-oder-Gleich- <=Operator, also müssen wir Boolesche NICHT auf ein Kleiner-als werfen, aber dies prüft, ob das Ergebnis nicht positiv ist. Es gilt automatisch für jedes Atom in der Liste.
• &/ist die Falte des logischen UND über einer Liste. (Für fdyadisch) Damit wird geprüft, ob jeder Boolesche Wert in der Liste wahr ist.

Beispiele:

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

Übernimmt die Eingabe als Ganzzahl und als Array im CJam-Stil in STDIN:

-5 [1 2 3 -20]

Teste es hier.

Pyth, 16 15

!sm>vzs+0<QdhlQ

Probieren Sie es online mit der Eingabe

-5
[4, -3, 6]

Erläuterung:

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

Und wieder sverschwendet die dumme Funktion zwei Bytes. Ich glaube, ich melde das dem Pyth-Repo als Bug.

Bearbeiten: 13 (ungültig)

Dank an isaacg für das Speichern ( >1bis !) eines Bytes und für das Ändern der Implementierung sim Pyth-Repo. Jetzt ist der folgende Code möglich (aber natürlich nicht gültig für diese Herausforderung).

!sm>vzs<QdhlQ

R 35

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

Probieren Sie es hier aus

Julia, 33 Bytes

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

Dadurch wird eine unbenannte Funktion erstellt, die zwei Parameter Tund akzeptiert lund einen Booleschen Wert zurückgibt.

Die all()Funktion erledigt hier das ganze schwere Heben. Es sind zwei Argumente erforderlich: ein Prädikat und ein iterierbares. Für das Prädikat teilen wir ihm mit, dass es iden aktuellen Wert der Iteration darstellt, indem eine unbenannte Funktion verwendet wird, die durch angegeben wird i->. Dann vergleichen wir bei jeder Iteration imit Tusing i>=T.

Um sicherzustellen, dass Julia nicht davon ausgeht, cumsum()eine leere Liste zu verwenden, können wir dort eine Null setzen [0, l].

Vorspiel , 144 136 Bytes

Das war ... schwer ...

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

Ich denke, 6 Stimmen sind ein neuer Rekord für mich, obwohl ich mir sicher bin, dass es einen Weg gibt, das zu reduzieren und viele dieser nervigen Leerzeichen loszuwerden. Das Überprüfen des Vorzeichens eines Werts (und daher das Überprüfen, ob ein Wert größer als ein anderer ist) ist im Prelude recht schwierig.

Ein- und Ausgabe erfolgt als Bytewert. Wenn Sie verwenden den Python-Interpreter verwenden , können Sie festlegen NUMERIC_OUTPUT = True, dass Sie tatsächlich ein ASCII- 0oder ein 1. Für die numerische Eingabe NUMERIC_INPUTmüssten Sie ein weiteres Flag hinzufügen (ich sollte wahrscheinlich irgendwann meinen optimierten Interpreter veröffentlichen).

Beachten Sie auch, dass Prelude das Ende einer Liste nicht wirklich von einem 0innerhalb der Liste unterscheiden kann. Um also keine Transaktionen zuzulassen, lese ich T, dann die Länge Lder Liste und dannL Transaktionen.

CJam, 18 Bytes

Ein anderer Ansatz in den gleichen Bytes wie der andere.

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

Übernimmt die Eingabe über STDIN in Form von <threshold> <array of transactions>

Probieren Sie es hier online aus

JavaScript (ES6) 38 33

Bearbeiten Feste Anfangssaldo Fehler. Danke @martin & @rainbolt

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

Test In der Firefox / FireBug-Konsole

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,[]))

falsch falsch falsch
wahr wahr wahr
falsch falsch

Python 2.7 - 55 Bytes

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

Rufen Sie gerne an print f(-5,[1,2,3,-20]). Teste es hier .

Vielen Dank an Jakube für die Hilfe.

> <>, 29 + 3 = 32 Bytes

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

Laufen wie

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

wobei der Schwellenwert die erste Zahl ist.

Oktave, 27

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

Perl 6 (21 Bytes)

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

Es ist eine Funktion, die ein erstes Argument und eine Liste von Elementen verwendet. Es funktioniert, indem überprüft wird, ob keine ( mithilfe von Übergängen ) der Elemente unter dem Schwellenwert liegen. [\+]wird zum Erzeugen einer laufenden Summe verwendet, beispielsweise [\+] 1, 2, 3gibt 1, 3, 6. 0,Anhängen0 am Anfang der Liste ist erforderlich, da der positive Schwellenwert immer ausfallen muss.

Ziemlich dasselbe wie die Haskell-Lösung, nur in Perl 6-Syntax (Perl 6 hat so viele nette Programmierfunktionen von Haskell übernommen).

Perl - 20

Nehmen Sie die Nummernliste STDINdurch Zeilenumbrüche getrennt auf und nehmen Sie Tmit der -iFahne.

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

+2 für -iund -nFlags. Der Ausgangswert gilt 255für Fehler und0 bei Erfolg.

Laufen mit:

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

Clojure, 45

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

Z.B

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

Oder ein bisschen netter;

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

Golf Funktion:

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

Treiberprogramm:

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

}

Ausgabe:

bash-3.2$ javac A.java ; java A

false
false
false
above false, below true
true
true
true