Хотите верьте, хотите нет, но Sex Bob-омбы стали всемирно известной группой и в настоящее время находятся в мировом турне! Как их бухгалтер, вы должны следить за их повседневным финансированием и предоставлять регулярные отчеты.

Каждые несколько недель вы составляете список их расходов (в долларах США ) в порядке их возникновения.

Например, список

378
-95
2234

означает, что 378 долл. США были зачислены на их счет, а после этого было снято 95 долл. США, а после этого было внесено 2234 долл. США.

Вы хотите , чтобы убедиться , что текущая сумма этих значений не опускается ниже некоторого порогового значения Т . Вы решили написать программу, которая сделает это для вас.

Вызов

Напишите программу или функцию, которая принимает одно целое число T и список целых чисел. Если текущая сумма списка целых чисел когда-либо меньше T , выведите или верните ложное значение , в противном случае выведите или верните истинное значение.

Вы можете использовать любые обычные методы ввода (stdin, из файла, командной строки, аргументы для функции).

• В начале списка промежуточная сумма равна 0. Таким образом, положительный T означает, что результат всегда ложный.
• + никогда не будет перед положительными целыми числами.
• Список может содержать 0.
• Список может быть пустым.

Тестовые случаи

Т -5 во всех этих.

Falsy:

-6

1
2
3
-20

200
-300
1000

Truthy:

[empty list]

-5

4
-3
-6

счет

Представление с наименьшим количеством байтов выигрывает. Tiebreaker отправляется в самое раннее опубликованное представление.

^{Прискорбный комментарий, который заставил меня сделать это.}

gs2 - 6 байт

Предположим, что список находится на вершине стека, а порог находится в регистре А. В мнемонике:

inits
sum get-a lt filter3
not

В байт-коде:

78 64 D0 70 F2 22

Haskell, 22 байта

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

Использование: f (-5) [4,-3,-6] какие выходы True.

Составьте список промежуточных итогов и проверьте, все ли элементы> = t.

Редактировать: Исправление для пустого списка и положительных tзначений

Python 2, 41

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

Первый аргумент - это массив; вторая минимальная промежуточная сумма.

J 11 байт

   */@:<:0,+/\

тесты

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

1-байтовое улучшение благодаря FUZxxl .

Пояснение к оригинальной версии (*/@(<:0,+/\))

• +/\создает текущую сумму (сумму +/префиксов \)
• 0,+/\ добавляет 0 к текущей сумме
• (<:0,+/\)ввод с левой стороны меньше или равен результату <:(элементам) 0,+/\на входе с правой стороны
• @ с предыдущим результатом
• */ произведение всех элементов (1, если все элементы 1, 0, если элемент 0)

APL, 8 10

∧.≤∘(0,+\)

Эта функция принимает Tлевый аргумент, а список - правый аргумент.

• 0,+\: текущая сумма правильного аргумента, добавленная к 0
• ∧.≤: левый аргумент меньше или равен (≤), чем все (∧) элементы в правом аргументе

Mathematica, 34 байта

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

Это определяет безымянную переменную функцию, которая принимает Tв качестве первого параметра транзакции, а оставшиеся параметры возвращает логическое значение:

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

Мне это нравится, потому что я мог бы использовать довольно редкое, ##2которое «разбивает» все аргументы со второго в список. Для более подробной информации смотрите последний раздел в этом совете по игре в гольф .

к, 8 знаков

Диадический глагол, принимающий порог в качестве первого аргумента и список в качестве второго. Примечательно, что это работает во всех версиях k, включая Kona с открытым исходным кодом.

&/~0<-\,

В k составление функций просто выполняется путем написания одной, а затем другой, поэтому мы можем разбить это по функциям. Справа налево:

• -\,принимает последовательные текущие суммы и вычитает их из порога. (Если fявляется двоичным, то f\ (a; b; c; ...) расширяется до (a; a f b; (a f b) f c; ...). ,Просто объединяет списки.) Безубыточность происходит, когда что-то равно 0, а переопределение дает строго положительные значения.
• ~0<не меньше, чем 0 На самом деле k не имеет оператора больше-или-равно-равному <=, поэтому мы должны бросить логическое НЕ на меньше, но это проверяет, является ли результат неположительным. Это автоматически применяется к каждому атому в списке.
• &/это складка логического И над списком. (Для fдвоичного числа). Таким образом, проверяется, является ли каждый логический элемент в списке истинным.

Примеры:

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

CJam, 17 байт

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

Принимает ввод как целое число и массив в стиле CJam в STDIN:

-5 [1 2 3 -20]

Проверьте это здесь.

Пиф, 16 15

!sm>vzs+0<QdhlQ

Попробуйте онлайн с вводом

-5
[4, -3, 6]

Объяснение:

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

И снова глупый s функция тратит два байта. Я думаю, что сообщу об этом как об ошибке в репозиторий Pyth.

изменить: 13 (недействительно)

Спасибо isaacg за сохранение одного байта ( >1в !) и за изменение реализации в репозитории Pyth s. Теперь возможен следующий код (но, конечно, он не подходит для этой задачи).

!sm>vzs<QdhlQ

Р, 35

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

Попробуй здесь

Юлия, 33 байта

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

Это создает безымянную функцию, которая принимает два параметра, Tиl , и возвращает логическое значение.

all()Функция делает все тяжелое здесь. Он принимает два аргумента: предикат и итеративный. Для предиката мы сообщаем ему, что он iпредставляет текущее значение итерируемой функции без имени, указанной с помощью i->. Затем на каждой итерации мы сравниваем iс Tиспользованием i>=T.

Чтобы убедиться, что Джулия не волнуется об использовании cumsum()пустого списка, мы можем добавить ноль, используя [0, l].

Прелюдия , 144 136 байт

Это было ... сложно ...

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

Я думаю, что 6 голосов - новая запись для меня, хотя я уверен, что есть способ уменьшить это и избавиться от многих этих раздражающих пробелов. Проверка знака значения (и, следовательно, проверка, является ли одно значение больше другого), довольно сложна в Prelude.

Вход и выход задаются как байтовые значения. Когда вы используете интерпретатор Python , вы можете установить NUMERIC_OUTPUT = True, чтобы вы действительно получили ASCII 0или 1. Для числового ввода вам нужно будет добавить еще один NUMERIC_INPUTфлаг (я, вероятно, должен был бы опубликовать мой измененный интерпретатор в какой-то момент).

Также обратите внимание, что Prelude не может действительно отличить конец списка от 0списка. Итак, чтобы разрешить нулевые транзакции, я читаю T, затем длину Lсписка, а затем Lтранзакции.

CJam, 18 байт

Другой подход в тех же байтах, что и другой.

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

Принимает ввод через STDIN в виде <threshold> <array of transactions>

Попробуйте онлайн здесь

JavaScript (ES6) 38 33

Редактировать Исправлена ​​ошибка начального баланса. Спасибо @martin & @rainbolt

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

Тест в консоли 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,[]))

ложный ложный ложный
истинный истинный истинный
ложный ложный

Python 2,7 - 55 байт

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

Звоните как print f(-5,[1,2,3,-20]). Проверьте это здесь .

Спасибо Якубе за помощь.

> <>, 29 + 3 = 32 байта

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

Беги как

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

где порог является первым числом.

Октава, 27

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

Perl 6 (21 байт)

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

Это функция, принимающая начальный аргумент и список элементов. Это работает путем проверки, если ни один ( с помощью соединений ) элементов ниже порога. [\+]используется для генерации промежуточной суммы, например, [\+] 1, 2, 3дает 1, 3, 6. 0,добавление 0в начале списка необходимо из-за требования, что положительный порог всегда должен потерпеть неудачу.

Практически то же самое, что и решение на Haskell, только в синтаксисе Perl 6 (Perl 6 использовал множество полезных функций программирования от Haskell).

Perl - 20

Возьми список чисел на STDINразделенных переводами и возьми Tс -iфлагом.

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

+2 за -iи -nфлаги. Выходное значение 255для сбоев и 0при успехе.

Бежать с:

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

Clojure, 45

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

Например

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

Или немного лучше;

(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 символа

Гольф-функция:

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

Программа для водителя:

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

}

Выход:

bash-3.2$ javac A.java ; java A

false
false
false
above false, below true
true
true
true