问题：

给定一组整数，找到其中的所有正整数之和。

输入：

• t –测试用例数[ t <1000]
• 在每个下一个的吨系，整数Ñ [-1000≤ Ñ ≤1000]

输出量

程序应输出所有正整数的和。

在在线裁判中检查您的代码

得分了

分数等于程序源代码的大小，但ASCII码≤32的符号除外。

以下是最佳成绩列表：Python最佳成绩（最高成绩为29）

空格，0

我无法抗拒。S=空间，T =制表符，N=换行符，都具有ASCII码<= 32。

SSSSNSSSSNTTSSSSSTNTNTTNSSSNSSSSTNTTTNTSTNSSSSTNSSSSTNTTTSSSSTNTSSTTTSSSSSTSNTNTTSSSSTSNTTTNTTSNSSSSNSSSSTSNTTTSSSSNTTTTSSSTTSNSNSNNSSTNSSSSNTTTTNSTSSSSTSTSNTNSSNNN

Base64编码，易于复制和粘贴。

ICAgIAogICAgCgkJICAgICAJCgkKCQkKICAgCiAgICAJCgkJCQoJIAkKICAgIAkKICAgIAkKCQkJ
ICAgIAkKCSAgCQkJICAgICAJIAoJCgkJICAgIAkgCgkJCQoJCSAKICAgIAogICAgCSAKCQkJICAg
IAoJCQkJICAgCQkgCiAKIAoKICAJCiAgICAKCQkJCQogCSAgICAJIAkgCgkKICAKCgo=

元素，17个字符加1个空格

_'[_ 2:n;0>[n~+]]`

这是我的第一门建构语言。它被设计为非常紧凑且易于阅读。所有指令均为一个字符长，并且执行一个功能。

Element具有两个堆栈和一个哈希作为内存结构。这两个堆栈称为主堆栈和控制堆栈。主堆栈是进行算术，I / O和哈希操作的地方。控制堆栈是逻辑操作发生的地方，该堆栈控制while和for循环。

Element背后的基本思想是，有一个存储数字/字符串的哈希，而堆栈则用于对这些数字执行计算。然后，可以将这些计算的结果分配给哈希表中的某个位置，以备将来使用。哈希的不同内容称为元素，因此它类似于数组，但可以具有非数字名称。

编辑：您可以在这里找到Element（用Perl编写）的解释器。

这是运算符的列表：在某些示例中，m和n表示堆栈中已经存在的数字。

text  --pushes the string "text" onto the main stack
'     --pops from main stack and pushes onto control stack
"     --pops from control stack and pushes onto main stack
#     --pops from main stack and destroys
[]    --FOR statement (view the top number number from control stack and eval those many times)
{}    --WHILE (loop until top number on control stack is 0)
(     --pops from main stack, removes first character, pushes the remaining string onto stack, and pushes the removed character onto stack
)     --pops from main stack, removes last character, pushes the remaining string onto stack, and pushes the removed character onto stack
~     --pops from main stack, pushes contents of the element with that name
+-*/%^ --pops two most recently named elements, adds/negates/multiplies/divides/modulates/exponentiates them, and places the result on the stack
mn;   --pops m and n and assigns element n the value of m
mn@   --pops m and n and moves mth thing in stack to move to place n in stack
m$    --pops m and pushs size of m onto the stack
mn:   --pops m and n and pushes m onto the stack n times
mn.   --pops m and n and pushes m concatonated with n
m?    --pops m and pushes 0 onto control stack if m is '0' or and empty string, else pushes 1 
\     --escapes out of next character, so it isn't an operator and con be pushed onto the stack
><=   --pops two numbers off of stack and tests, pushes 1 onto control stack if true and 0 if false
`     --pops from main stack and prints
&|    --pops two items from control stack, performs and/or respectively, and pushes result back onto control stack
!     --pops a number off of control stack, pushes 1 if 0 or empty string, 0 otherwise
_     --inputs a word and pushes onto main stack
m,    --pops m from main stack, coverts it to char and pushes, converts to num and pushes
Newlines and spaces separate different elements to be pushed onto the stack individually, but can pushed onto the stack using \

这是该程序工作方式的演练：

_'[    --take the first line of input, transfer it to the control stack, and start a for loop
_ 2:   --take one more line of input, and duplicate it so that there are two copies
n;     --take one copy and put into element n
0>     --push a zero onto the stack, remove the zero and the other copy of the input, and compare. A 1 will be placed on the control stack if the input was greater than zero, a 0 otherwise.
[      --starts another for loop if the comparison was true. This loop will be repeated once if the comparison was true and no times if it was false, so it is the same as an IF statement.
n~     --pushes n onto the main stack, then pops it ans replaces it with the contents of n, which is the number stored earlier
+      --takes the number and adds it to the running total, which is contained as the last item on the stack
]      --ends the inner for loop
]      --ends the outer for loop
`      --print the top item (also the only item) on the stack to output

Perl，31岁

<>;$i+=$_*($_>0)while<>;print$i

Ruby 1.9.2、37

p eval [*$<].join.gsub(/\A\d+|-\d+|\n/, '+0')

像ruby脚本名file_with_ints一样调用。

露比52岁

t=gets.to_i;s=0;t.times{i=gets.to_i;s+=i if i>0};p s

哈斯克尔，58岁

仅对t整数正确地操作。尚未针对Spoj运行它，因为我只是不在乎在那儿​​注册。

f (x:l) = take x l
main = interact $ show . sum . f . map (max 0.read) . lines

C 89个字符的代码

x="%d";  main(b,a,t)  {  
  for(scanf(x,&t);t;t--)
    {  scanf(x,&a); a>0?b+=a:a; }  printf(x,b-1);
       return 0; }

我做了很多尝试，以减少我的代码少于63个字节，但是我只能将其减少到89个字节。请帮助我将其减少到63个字节或更少。

Perl，33岁

<>;while(<>){$i+=$_ if$_>0}print$i

尽管空间是必需的，但不计算它似乎很奇怪。哦，规则就是规则。

嗯 我可能会避免使用一个也不计入总数的变量名。问题是，我不确定当时如何粘贴代码。

Clojure，71岁

(reduce + (filter pos? (map #(Integer/parseInt %) (next (line-seq *in*)))))

纪念丹尼斯·里奇

UNIX 57¹ 72：

n=$(head -n1 i); echo $(($(head -n $((n+1)) i | tail -n $n | grep -v "-" | tr '\n' '+')0))

假设我是包含int的文件。

¹）是错误的，包括了行数，而又少添加了1行。

echo $（（$（cat i | head -n $（head -n1 i）| grep -v“-” | tr'\ n''+'）0））

Haskell，51岁

main = interact $ show . f . lines
f (x:l) = foldl (+) 0 $ map read l

（为清楚起见，请留出多余的空格，因为它们不算在内）

Haskell很有趣，因为您趋向于获得带有大量必要空间的程序。

C，88

x="%d";  main(b,a,t)  {  
for(scanf(x,&t);t--;)  
{  scanf(x,&a); a>0?b+=a:0; }  printf(x,b-1);
return 0; }

再接再厉，代码减少了一个字符，请帮助我减少更多字符。

Befunge-98（24）

（确保您使用的解释器可以读取负数（似乎是一个常见错误，但是RcFunge可以工作））

<;-1\+*`0:&\_\#;.@;:;#&0 

佩尔（25）

（Perl允许使用变量名称中的控制字符，我将变量命名为^ B（ASCII 2），这样它就不会计入目标。）

<>; $ ^ B + = $ _ *！/-/ for <>;打印$ ^ B

（普通变体（27个字符））：

<>;$B+=$_*!/-/for<>;print$B

杀伤人员地雷（10）

+/{0⌈⎕}¨⍳⎕

说明：

• ⍳⎕：读取一行，为用户输入N提供列表[1..N]
• ¨：对于此列表中的每个元素...（即执行N次）
• 0⌈⎕：读取一行，返回最大值0，然后输入N
• 现在，我们有了一个列表，其中用户输入的所有正数均为N，用户输入负数的则为0。
• +/ 给出此列表的总和。
• 默认情况下输出结果（因为我们不对其进行任何其他处理）。

Mathematica：18 16

Boole[#>0]&/@x.x

PowerShell，44岁

($i=$input|%{+$_})[1..$i[0]]-gt0-join'+'|iex

Q，12

{0+/x(&)x>0}

样品用量

q){0+/x(&)x>0} 1 -1 2 3 -1
6

befunge，35 24

:0`j&1-\&:0`*+\:0`3*j$.@

通过看到marinus的答案，我得到了一些启发，我还管理了24个字符。但是我有一个完全不同的方法。

PYTHON 2.x，50个字符

r=input
print sum(i for i in (r() for j in range(r())) if i>0)

C，70 72个字符

s;main(i,c){for(;c--;i>0?s+=i:0)scanf("%d",s?&i:&c);printf("%d",s-1);}

SPOJ网站上的结果绝对是不真实的-我不知道如何将其降低到63。

但是，通过滥用未定义的行为，在某些编译器上可以达到68个字符。以下内容在具有32位gcc的x86 Linux上有效，所有参数在堆栈上传递。

s;main(i,c){for(;c--;i>0?s+=i:0)scanf("%d",&i+!s);printf("%d",s-1);}

优秀，27

=SUM(INDIRECT("A2:A"&1+A1))

在A1中计数t，其余数据在a2中向下计数

Clojure，108岁

(let [[n & m] (->> *in* java.io.BufferedReader. line-seq (map read-string))]
  (->> m (take n) (filter pos?) (apply +) println))

我真的希望我能避免该java.io.BufferedReader.部分，因为它本身要花费24个字符。但是AFAIK没有它就无法从STDIN读取行。

Perl，20岁

I know it is old and trivial, but the Perl answer can be still improved:

#!perl -p
$.<2or$\+=$_*!/-/}{

C++:

#include<iostream>
using namespace std;
int main()
{
    int c,n,s=0;cin>>c;
    while(c--)
    {
        cin>>n;s+=n*(n>0);
    }
cout<<s;return 0;
}

115 characters long. Need to optimize it to 90. Any suggestions ?

PHP, 71

<?for($s=0,$t=fgets(STDIN)+0;$t--;$s+=($n=fgets(STDIN))>0?$n:0);echo$s;

Python: (92 characters)

t = int(raw_input())
n = [int(raw_input()) for i in range(t)]
print(sum([n[i] for i in range(t) if n[i]>0]))

scala 55 54:

println ((for (r <- 1 to readInt;
  i=readInt;
    if i>0) yield i)sum)

C

void main()
{
int n;
scanf("%d",&n);
for(int i=0;i<n;i++)
     {
     if(i>0)
     sum=sum+i;
     }
printf("sum of positive numbers is %d",sum);
}

Ruby, 42

s=0
gets.to_i.times { 
    i=gets.to_i
    s+=i if i>0
}
p s

(based on david4dev's answer)

Best score for Ruby on spoj: http://www.spoj.com/ranks/SIZECON/lang=RUBY

45 chars in python

c=0
j=input
for i in j()*[0]:
    b=j()
    c+=b*(b>0)
print c