Wierzcie lub nie, Sex Bob-ombs stały się światowej sławy zespołem i są obecnie na światowej trasie koncertowej! Jako księgowy musisz nadzorować ich codzienne finanse i regularnie przedstawiać raporty.

Co kilka tygodni zestawiasz listę ich wydatków (w pełnych USD ) w kolejności, w jakiej zostały poniesione.

Na przykład lista

378
-95
2234

oznacza, że ​​378 USD zostało zdeponowane na ich rachunku, a następnie 95 USD zostało wypłacone, a następnie 2234 USD zostało zdeponowane.

Chcesz, aby upewnić się, że działa suma tych wartości, nigdy nie spada poniżej pewnej wartości progowej T . Postanawiasz napisać program, który zrobi to za Ciebie.

Wyzwanie

Napisz program lub funkcję, która przyjmuje jedną liczbę całkowitą T i listę liczb całkowitych. Jeśli bieżąca suma listy liczb całkowitych jest zawsze mniejsza niż T , wydrukuj lub zwróć wartość fałszowania , w przeciwnym razie wydrukuj lub zwróć wartość prawdy.

Możesz użyć dowolnych zwykłych metod wprowadzania danych (stdin, z pliku, wiersza poleceń, argumentów do funkcji).

• Na początku listy bieżąca suma wynosi 0. Więc dodatnia T oznacza, że ​​wynik jest zawsze fałszywy.
• + nigdy nie będzie przed dodatnimi liczbami całkowitymi.
• Lista może zawierać 0.
• Lista może być pusta.

Przypadki testowe

T wynosi w nich wszystkich -5.

Falsy:

-6

1
2
3
-20

200
-300
1000

Prawda:

[empty list]

-5

4
-3
-6

Punktacja

Zgłoszenie z najmniejszą liczbą bajtów wygrywa. Tiebreaker przechodzi do najwcześniej opublikowanego zgłoszenia.

^{Godny pożałowania komentarz, który zmusił mnie do tego.}

gs2 - 6 bajtów

Załóżmy, że lista znajduje się na górze stosu, a próg znajduje się w rejestrze A. W mnemonice:

inits
sum get-a lt filter3
not

W kodzie bajtowym:

78 64 D0 70 F2 22

Haskell, 22 bajty

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

Zastosowanie: f (-5) [4,-3,-6]które wyjścia True.

Zrób listę sum częściowych i sprawdź, czy wszystkie elementy są> = t.

Edycja: Poprawka dla pustej listy i pozytywnych ts

Python 2, 41

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

Pierwszym argumentem jest tablica; drugi to minimalna suma bieżąca.

J, 11 bajtów

   */@:<:0,+/\

Testy

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

1-bajtowa poprawa dzięki FUZxxl .

Objaśnienie oryginalnej wersji (*/@(<:0,+/\))

• +/\ tworzy sumę bieżącą (suma +/ prefiksów\ )
• 0,+/\ dodaje 0 do bieżącej sumy
• (<:0,+/\)wejście po lewej stronie mniejsze lub równe <:(elementy) wyniku0,+/\ po prawej stronie
• @ z poprzednim wynikiem
• */ iloczyn wszystkich elementów (1, jeśli wszystkie elementy mają wartość 1, 0, jeśli element ma wartość 0)

APL, 8 10

∧.≤∘(0,+\)

Jest to funkcja, która przyjmuje Tza lewy argument, a lista za prawy argument.

• 0,+\: działająca suma poprawnego argumentu, dołączona do 0
• ∧.≤: lewy argument mniejszy lub równy (≤) niż wszystkie (∧) pozycje w prawym argumencie

Mathematica, 34 bajty

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

Definiuje to nienazwaną funkcję variadic, która przyjmuje Tjako pierwszy parametr, a transakcje jako pozostałe parametry i zwraca wartość logiczną:

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

Podoba mi się to, ponieważ mogłem skorzystać z dość rzadkiej opcji, ##2która „rozdziela” wszystkie argumenty z drugiego na listę. Aby uzyskać więcej informacji, zobacz ostatnią część tego poradnika golfowego .

k, 8 znaków

Czasownik dynamiczny przyjmujący próg jako pierwszy argument, a listę jako drugi. Co zadziwiające, działa to w każdej wersji k, w tym Kona open-source.

&/~0<-\,

W k składanie funkcji odbywa się po prostu przez napisanie jednej, a potem drugiej, dzięki czemu możemy podzielić je na funkcje. Z prawej do lewej:

• -\,pobiera kolejne sumy bieżące i odejmuje je od progu. (Jeśli fjest dynamiczne, to f\ (a; b; c; ...) rozwija się do (a; a f b; (a f b) f c; ...). Po ,prostu łączy listy razem.) Łamanie występuje nawet wtedy, gdy coś jest równe 0, a przesadzanie daje wartości ściśle dodatnie.
• ~0<nie jest równy 0. k tak naprawdę nie ma wartości większej niż lub równej<= operatora , więc musimy wyrzucić wartość logiczną NIE na mniej niż, ale sprawdza to, czy wynik nie jest dodatni. Automatycznie stosuje się do każdego atomu na liście.
• &/jest foldem logicznym AND na liście. (Dla fdyadic) Więc to sprawdza, czy każdy boolean na liście ma wartość True.

Przykłady:

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

CJam, 17 bajtów

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

Pobiera dane wejściowe jako liczbę całkowitą i tablicę w stylu CJam na STDIN:

-5 [1 2 3 -20]

Sprawdź to tutaj.

Pyth 16 15

!sm>vzs+0<QdhlQ

Spróbuj online z danymi wejściowymi

-5
[4, -3, 6]

Wyjaśnienie:

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

I znowu głupi s funkcja marnuje dwa bajty. Myślę, że zgłoszę to jako błąd do repozytorium Pyth.

edycja: 13 (niepoprawna)

Dzięki isaacg za jednobajtowe zapisywanie ( >1do !) i za zmianę implementacji sw repozytorium Pyth. Teraz możliwy jest następujący kod (ale oczywiście nie jest ważny dla tego wyzwania).

!sm>vzs<QdhlQ

R, 35

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

Wypróbuj tutaj

Julia, 33 bajty

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

To tworzy nienazwaną funkcję, która akceptuje dwa parametry, T a li zwraca wartość logiczną.

Ta all()funkcja wykonuje wszystkie ciężkie podnoszenie tutaj. Wymaga dwóch argumentów: predykatu i iterowalnego. W przypadku predykatu mówimy, że ireprezentuje on bieżącą wartość iterowalności przy użyciu funkcji bez nazwy, określonej przez i->. Następnie w każdej iteracji możemy porównać idoT użycia i>=T.

Aby upewnić się, że Julia nie przestraszy się używania cumsum()na pustej liście, możemy ustawić zero przy użyciu [0, l].

Preludium , 144 136 bajtów

To było ... trudne ...

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

Myślę, że 6 głosów to dla mnie nowy rekord, chociaż jestem pewien, że istnieje sposób na zmniejszenie tego i pozbycie się wielu irytujących białych znaków. Sprawdzanie znaku wartości (a zatem sprawdzanie, czy jedna wartość jest większa od drugiej) jest dość trudne w Preludium.

Dane wejściowe i wyjściowe są podawane jako wartości bajtów.Kiedy używasz interpretera Pythona , możesz ustawić NUMERIC_OUTPUT = Truetak, aby faktycznie uzyskać ASCII 0lub1 . Aby wprowadzić dane liczbowe, musisz dodać kolejnyNUMERIC_INPUT flagę (prawdopodobnie powinienem opublikować mój ulepszony interpreter w pewnym momencie).

Zauważ też, że Preludium nie może tak naprawdę odróżnić końca listy od 0listy na liście. Aby umożliwić zerowe transakcje, czytamT , potem długość Llisty, a potem Ltransakcje.

CJam, 18 bajtów

Inne podejście w tych samych bajtach, co drugi.

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

Pobiera dane wejściowe za pośrednictwem STDIN w postaci <threshold> <array of transactions>

Wypróbuj online tutaj

JavaScript (ES6) 38 33

Edytować Naprawiono błąd początkowego salda. Thx @ Martin i @rainbolt

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

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

fałsz fałsz fałsz
prawda prawda prawda
fałsz fałsz

Python 2.7 - 55 bajtów

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

Zadzwoń jak print f(-5,[1,2,3,-20]). Sprawdź to tutaj .

Dzięki Jakube za pomoc.

> <>, 29 + 3 = 32 bajty

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

Biegnij jak

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

gdzie próg jest pierwszą liczbą.

Oktawa, 27

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

Perl 6 (21 bajtów)

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

Jest to funkcja pobierająca początkowy argument i listę elementów. Działa poprzez sprawdzenie, czy żaden ( przy użyciu skrzyżowań ) elementów nie jest poniżej progu. [\+]służy do generowania bieżącej sumy, na przykład [\+] 1, 2, 3daje 1, 3, 6. 0,dołączyć0 na początku listy jest konieczne ze względu na wymóg, aby dodatni próg zawsze zawodził.

Prawie to samo, co rozwiązanie Haskell, tylko w składni Perla 6 (Perl 6 miał tak wiele schludnych funkcji programowania od Haskella).

Perl - 20

Zapoznaj się z listą numerów na STDINoddzielone znakami nowej linii i wziąć Tz -iflagą.

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

+2 za -ii -nflagi. Wartość wyjściowa dotyczy 255awarii i0 powodzenia.

Biegnij z:

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

Clojure, 45 lat

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

Na przykład

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

Lub milej;

(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 znaków

Funkcja gry w golfa:

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

Nie golfowany:

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

Program sterownika:

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

}

Wynik:

bash-3.2$ javac A.java ; java A

false
false
false
above false, below true
true
true
true