Croyez-le ou non, les Sex Bob-ombs sont devenus un groupe de renommée mondiale et sont actuellement en tournée mondiale! En tant que comptable, vous devez superviser leurs finances quotidiennes et fournir des rapports réguliers.

Toutes les quelques semaines, vous compilez une liste de leurs dépenses (en USD ) dans l'ordre où elles ont été engagées.

Par exemple, la liste

378
-95
2234

signifie que 378 $ ont été déposés sur leur compte et qu'ensuite 95 $ ont été retirés, puis que 2234 $ ont été déposés.

Vous voulez vous assurer que la somme en cours d' exécution de ces valeurs va jamais au- dessous une valeur de seuil T . Vous décidez d'écrire un programme pour le faire pour vous.

Défi

Écrivez un programme ou une fonction qui prend un seul entier T et une liste d'entiers. Si la somme cumulée de la liste des nombres entiers est toujours inférieure à T , imprimez ou renvoyez une valeur fausse , sinon imprimez ou renvoyez une valeur véridique.

Vous pouvez utiliser toutes les méthodes d'entrée habituelles (stdin, à partir d'un fichier, de la ligne de commande, des arguments pour fonctionner).

• Au début de la liste, la somme cumulée est de 0. Un T positif signifie donc que le résultat est toujours faux.
• + ne sera jamais devant des nombres entiers positifs.
• La liste peut contenir 0.
• La liste est peut-être vide.

Cas de test

T est -5 dans tous ces cas.

Falsy:

-6

1
2
3
-20

200
-300
1000

Vérité:

[empty list]

-5

4
-3
-6

Notation

La soumission avec le moins d'octets est gagnante. Tiebreaker passe à la première soumission publiée.

^{Le commentaire regrettable qui m'a forcé à le faire.}

gs2 - 6 octets

Supposons que la liste se trouve en haut de la pile et que le seuil se trouve dans le registre A. En mnémoniques:

inits
sum get-a lt filter3
not

En bytecode:

78 64 D0 70 F2 22

Haskell, 22 octets

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

Utilisation: f (-5) [4,-3,-6]quelles sorties True.

Faites une liste de sous-totaux et vérifiez si tous les éléments sont> = t.

Edit: Bugfix pour la liste vide et ts positifs

Python 2, 41

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

Le premier argument est le tableau; le second est le total cumulé minimum.

J, 11 octets

   */@:<:0,+/\

Les tests

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

Amélioration d'un octet grâce à FUZxxl .

Explication pour la version originale (*/@(<:0,+/\))

• +/\crée une somme cumulée (somme +/des préfixes \)
• 0,+/\ ajoute un 0 à la somme cumulée
• (<:0,+/\)entrée côté gauche plus petite ou égale <:à (éléments de) résultat de 0,+/\l'entrée côté droit
• @ avec le résultat précédent
• */ produit de tous les éléments (1 si tous les éléments sont 1, 0 si un élément est 0)

APL, 8 10

∧.≤∘(0,+\)

Il s'agit d'une fonction qui prend Tcomme argument de gauche et la liste comme argument de droite.

• 0,+\: somme cumulée de l'argument de droite, ajoutée à un 0
• ∧.≤: argument de gauche plus petit ou égal (≤) à tous les éléments (∧) de l'argument de droite

Mathematica, 34 octets

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

Ceci définit une fonction variadic sans nom qui prend Tcomme premier paramètre et les transactions comme paramètres restants, et retourne un booléen:

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

J'aime ça parce que je pourrais utiliser le plutôt rare ##2qui "répartit" tous les arguments du second dans la liste. Pour plus de détails, voir la dernière section de cette astuce golf .

k, 8 caractères

Un verbe dyadique prenant le seuil comme premier argument et la liste comme deuxième. Remarquablement, cela fonctionne dans toutes les versions de k, y compris le Kona open-source.

&/~0<-\,

En k, la composition des fonctions se fait simplement en écrivant l'une puis l'autre, nous pouvons donc la décomposer par fonctions. De droite à gauche:

• -\,prend des sommes courantes successives et les soustrait du seuil. (Si fest dyadique, puis se f\ (a; b; c; ...) développe en (a; a f b; (a f b) f c; ...). ,Joint simplement les listes.) La rupture se produit même lorsque quelque chose est égal à 0, et le surdénombrement donne des valeurs strictement positives.
• ~0<n'est pas inférieur à 0. k n'a pas vraiment d' <=opérateur supérieur ou égal à , nous devons donc lancer booléen NOT sur un nombre inférieur à, mais cela vérifie si le résultat est non positif. Il s'applique automatiquement à chaque atome de la liste.
• &/est le pli de ET logique sur une liste. (Pour fdyadique) Donc, cela teste si chaque booléen dans la liste est vrai.

Exemples:

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

CJam, 17 octets

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

Prend l'entrée comme un entier et un tableau de style CJam sur STDIN:

-5 [1 2 3 -20]

Testez-le ici.

Pyth, 16 15

!sm>vzs+0<QdhlQ

Essayez-le en ligne avec l'entrée

-5
[4, -3, 6]

Explication:

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

Et encore une fois, la sfonction stupide gaspille deux octets. Je pense que je vais signaler cela comme un bug au dépôt Pyth.

modifier: 13 (non valide)

Merci à isaacg pour un octet de sauvegarde ( >1to !) et pour avoir changé l'implémentation de sdans le repo Pyth. Maintenant, le code suivant est possible (mais bien sûr non valable pour ce défi).

!sm>vzs<QdhlQ

R, 35

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

Essayez-le ici

Julia, 33 octets

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

Cela crée une fonction sans nom qui accepte deux paramètres, Tetl , et renvoie un booléen.

La all()fonction fait tout le gros du travail ici. Il prend deux arguments: un prédicat et un itérable. Pour le prédicat, nous lui disons qu'il ireprésente la valeur actuelle de l'itérable en utilisant une fonction sans nom, spécifiée par i->. Ensuite, à chaque itération, nous comparons ià l' Tutilisation i>=T.

Pour vous assurer que Julia ne panique pas d'utiliser cumsum()sur une liste vide, nous pouvons y mettre un zéro en utilisant [0, l].

Prelude , 144 136 bytes

C'était ... dur ...

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

Je pense que 6 voix est un nouveau record pour moi, même si je suis sûr qu'il existe un moyen de réduire cela et de se débarrasser de beaucoup de ces espaces ennuyeux. Vérifier le signe d'une valeur (et donc vérifier si une valeur est supérieure à une autre) est assez délicat dans Prelude.

L'entrée et la sortie sont données sous forme de valeurs d'octets. Lorsque vous utilisez l'interpréteur Python , vous pouvez définir NUMERIC_OUTPUT = True, de sorte que vous obtenez réellement un ASCII 0ou 1. Pour la saisie numérique, vous devez ajouter un autre NUMERIC_INPUTindicateur (je devrais probablement publier mon interprète modifié à un moment donné).

Notez également que Prelude ne peut pas vraiment distinguer la fin d'une liste d'un 0dans la liste. Donc, pour autoriser zéro transaction, je lis T, puis la longueur Lde la liste, puis les Ltransactions.

CJam, 18 octets

Une autre approche dans les mêmes octets que l'autre.

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

Prend entrée via STDIN sous la forme de <threshold> <array of transactions>

Essayez-le en ligne ici

JavaScript (ES6) 38 33

Modifier le bug d'équilibre initial fixe. Thx @martin & @rainbolt

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

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

faux faux faux
vrai vrai vrai
faux faux

Python 2,7 - 55 octets

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

Appelez comme print f(-5,[1,2,3,-20]). Testez-le ici .

Merci à Jakube pour son aide.

> <>, 29 + 3 = 32 octets

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

Courir comme

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

où le seuil est le premier nombre.

Octave, 27

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

Perl 6 (21 octets)

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

C'est une fonction qui prend l'argument initial et la liste des éléments. Il fonctionne en vérifiant si aucun ( en utilisant des jonctions ) d'éléments n'est en dessous du seuil. [\+]est utilisé pour générer une somme cumulée, par exemple [\+] 1, 2, 3donne 1, 3, 6. 0,ajouter 0au début de la liste est nécessaire en raison de l'exigence selon laquelle le seuil positif doit toujours échouer.

À peu près la même chose que la solution Haskell, juste dans la syntaxe Perl 6 (Perl 6 a pris tellement de fonctionnalités de programmation soignées de Haskell).

Perl - 20

Prenez la liste des numéros STDINséparés par des sauts de ligne et prenez Tle -idrapeau.

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

+2 pour -iet -ndrapeaux. La valeur de sortie correspond 255aux échecs et0 au succès.

Courir avec:

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

Clojure, 45

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

Par exemple

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

Ou un peu plus agréable;

(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 caractères

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

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

Programme pilote:

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

}

Production:

bash-3.2$ javac A.java ; java A

false
false
false
above false, below true
true
true
true