信不信由你，塞伯鲍勃炸弹已成为一支世界闻名的乐队，目前正在世界巡演中！作为他们的簿记员，您必须监督他们的日常财务状况并提供定期报告。

您每隔几周会按照产生的顺序编制一份支出清单（以美元为单位）。

例如清单

378
-95
2234

表示将$ 378存入他们的帐户，并在提取$ 95和存入$ 2234之后。

你要确保这些值的运行总和从未低于某一阈值牛逼。您决定编写一个程序来为您执行此操作。

挑战

编写一个包含单个整数T和一个整数列表的程序或函数。如果整数列表的运行总和小于T，则打印或返回假值，否则打印或返回真值。

您可以使用任何常用的输入法（stdin，从文件，命令行，函数的参数）。

• 在列表的开头，运行总和为0。因此，正T表示结果始终是虚假的。
• + 永远不会在正整数前面。
• 该列表可能包含0。
• 该列表可能为空。

测试用例

牛逼是-5在所有这些。

虚假：

-6

1
2
3
-20

200
-300
1000

真相：

[empty list]

-5

4
-3
-6

计分

字节最少的提交将获胜。Tiebreaker最早发布。

^{令人遗憾的评论迫使我不得不这样做。}

gs2-6个字节

假定列表在堆栈的顶部，并且阈值在寄存器A中。在助记符中：

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。

编辑：错误列表为空列表和正数ts

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

得益于FUZxxl改进了1字节。

原始版本的说明 (*/@(<:0,+/\))

• +/\创建运行总和（+/前缀总和\）
• 0,+/\ 在运行总和后附加0
• (<:0,+/\)左侧输入小于或等于右侧输入的<:结果（的个）0,+/\
• @ 与先前的结果
• */ 所有元素的乘积（如果所有元素均为1，则为1；如果元素为0，则为0）

杀伤人员地雷，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，将第二个参数从列表中“散布”到列表中。有关更多详细信息，请参阅本高尔夫球技巧的最后一部分。

k，8个字符

一个以阈值为第一个参数，以列表为第二个的二元动词。值得注意的是，这适用于k的每个版本，包括开源Kona。

&/~0<-\,

在k中，仅通过编写一个函数然后编写另一个函数来完成函数的组合，因此我们可以按函数将其分解。从右到左：

• -\,获取连续的运行总和并从阈值中减去它们。（如果f为dyadic，则f\ (a; b; c; ...) 扩展为(a; a f b; (a f b) f c; ...)。，,只是将列表连接在一起。）当某项等于0时，收支平衡，并且透支给出严格的正值。
• ~0<不小于0。k确实没有大于或等于<=运算符，因此我们必须将布尔型NOT小于一个运算符，但这将测试结果是否为正。它会自动应用于列表中的每个原子。
• &/是列表中逻辑AND的折叠。（对于f二进位）因此这将测试列表中的每个布尔值是否为True。

例子：

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

在STDIN上将输入作为整数和CJam样式的数组：

-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节省了一个字节（>1to !），并更改s了Pyth repo中的实现。现在可以使用以下代码（但对于此挑战当然无效）。

!sm>vzs<QdhlQ

R，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。

为了确保Julia不会对使用cumsum()空列表感到迷惑，我们可以在上使用零添加[0, l]。

前奏，144136字节

很难...

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

编辑固定的初始余额错误。Thx @马丁＆@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])。在这里测试。

感谢Jakube的帮助。

> <>，​​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在列表的开头追加，因为要求正阈值始终应该失败。

仅在Perl 6语法中，它与Haskell解决方案几乎相同（Perl 6继承了Haskell的许多巧妙的编程功能）。

Perl-20

STDIN用换行符分隔的数字列表并T带有-i标志。

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

-i和-n标志为+2 。退出值为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;} 

取消高尔夫：

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