Problem:

Ermitteln Sie bei einer gegebenen Anzahl von Ganzzahlen die Summe aller positiven Ganzzahlen.

Eingang:

• t - Anzahl der Testfälle [ t <1000]
• In jeder der nächsten t Zeilen eine ganze Zahl N [-1000 ≤ N ≤ 1000]

Ausgabe

Das Programm sollte die Summe aller positiven ganzen Zahlen ausgeben.

Überprüfen Sie Ihren Code in Online-Richter

Ergebnis

Die Punktzahl entspricht der Größe des Quellcodes Ihres Programms, mit Ausnahme von Symbolen mit ASCII-Code ≤ 32.

Hier ist die Liste der besten Punkte: Python- Bestnoten ( Bestnote: 29)

Leerzeichen, 0

Ich konnte nicht widerstehen. S= Leerzeichen, T= Tabulator, N= Zeilenvorschub, alle haben ASCII-Codes <= 32.

SSSSNSSSSNTTSSSSSTNTNTTNSSSNSSSSTNTTTNTSTNSSSSTNSSSSTNTTTSSSSTNTSSTTTSSSSSTSNTNTTSSSSTSNTTTNTTSNSSSSNSSSSTSNTTTSSSSNTTTTSSSTTSNSNSNNSSTNSSSSNTTTTNSTSSSSTSTSNTNSSNNN

Base64-codiert für einfaches Kopieren und Einfügen.

ICAgIAogICAgCgkJICAgICAJCgkKCQkKICAgCiAgICAJCgkJCQoJIAkKICAgIAkKICAgIAkKCQkJ
ICAgIAkKCSAgCQkJICAgICAJIAoJCgkJICAgIAkgCgkJCQoJCSAKICAgIAogICAgCSAKCQkJICAg
IAoJCQkJICAgCQkgCiAKIAoKICAJCiAgICAKCQkJCQogCSAgICAJIAkgCgkKICAKCgo=

Element, 17 Zeichen plus 1 Leerzeichen

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

Dies ist meine erste konstruierte Sprache. Es ist sehr kompakt und für den Menschen lesbar. Alle Anweisungen sind ein Zeichen lang und führen eine einzelne Funktion aus.

Element hat zwei Stapel und einen Hash als Speicherstrukturen. Die beiden Stapel werden als Hauptstapel und Kontrollstapel bezeichnet. Im Hauptstapel werden Arithmetik, E / A und Hash-Manipulationen ausgeführt. Der Steuerungsstapel ist der Ort, an dem Logikoperationen stattfinden, und dieser Stapel steuert die while- und for-Schleifen.

Die Grundidee hinter Element ist, dass es einen Hash gibt, der Zahlen / Strings speichert, während der Stack verwendet wird, um Berechnungen mit diesen Zahlen durchzuführen. Die Ergebnisse dieser Berechnung können dann für die zukünftige Verwendung einer bestimmten Stelle im Hash zugewiesen werden. Die verschiedenen Inhalte des Hashs werden als Elemente bezeichnet. Sie ähneln also einem Array, können jedoch nicht numerische Namen haben.

EDIT: Einen Interpreter für Element (geschrieben in Perl) finden Sie hier .

Hier ist die Liste der Operatoren: In einigen dieser Beispiele stehen m und n für Zahlen, die sich bereits auf dem Stapel befinden.

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 \

Hier ist eine exemplarische Vorgehensweise, wie das Programm funktioniert:

_'[    --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')

Rufe wie ruby ​​scriptname file_with_ints auf.

Rubin, 52

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

Haskell, 58

Funktioniert nur ordnungsgemäß t ganzen Zahlen. Ich habe es nicht gegen Spoj laufen lassen, weil ich es einfach nicht mag, mich dort zu registrieren.

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

Code ein C 89 Zeichen

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

Ich habe viel versucht, meinen Code auf weniger als 63 Bytes zu reduzieren, aber ich kann ihn nur auf 89 Bytes reduzieren. Bitte helfen Sie mir, es auf 63 Bytes oder noch weniger zu reduzieren.

Perl, 33

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

Obwohl der Raum notwendig ist, scheint es seltsam, ihn nicht zu zählen. Na ja, die Regeln sind die Regeln.

Hmm. Ich könnte wahrscheinlich mit einem Variablennamen davonkommen, der auch nicht zur Gesamtsumme zählt. Die Sache ist, ich bin nicht sicher, wie ich den Code dann einfügen würde.

Clojure, 71

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

In memoriam Dennis M. Ritchie

Unix 57¹ 72:

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

Angenommen, i ist die Datei, die die Ints enthält.

¹) war falsch, enthielt die Anzahl der Zeilen und fügte 1 Zeile zu wenig hinzu.

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

(zusätzliche Leerzeichen für Klarheit, da sie nicht zählen)

Haskell ist ... interessant, da Sie in der Regel Programme mit einer erheblichen Anzahl von erforderlichen Leerzeichen erhalten.

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

Nach einer weiteren großen Anstrengung ist der Code ein Zeichen weniger. Bitte helfen Sie mir, ihn weiter zu reduzieren.

Befunge-98 (24)

(Stellen Sie sicher, dass Sie einen Interpreter verwenden, der negative Zahlen lesen kann (scheint ein etwas häufiger Fehler zu sein, aber RcFunge funktioniert).)

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

Perl (25)

(Perl erlaubt Steuerzeichen in Variablennamen, ich habe meine Variable ^ B (ASCII 2) so benannt, dass sie nicht zum Ziel zählt.)

<>; $ ^ B + = $ _ *! / - / für <>; $ ^ B drucken

(Normale Variante (27 Zeichen)):

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

APL (10)

+/{0⌈⎕}¨⍳⎕

Erläuterung:

• ⍳⎕: Liest eine Zeile und gibt eine Liste [1..N] für die Benutzereingabe N aus
• ¨: für jedes Element in dieser Liste ... (dh N-mal)
• 0⌈⎕: Lies eine Zeile, gib das Maximum von 0 und das eingegebene N zurück
• Wir haben jetzt eine Liste mit allen positiven Ns, die der Benutzer eingegeben hat, und 0s, bei denen der Benutzer etwas Negatives eingegeben hat.
• +/ gibt die Summe dieser Liste an.
• Das Ergebnis wird standardmäßig ausgegeben (da wir nichts anderes damit machen).

Mathematica: 18 16

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

PowerShell, 44

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

Q, 12

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

Probennutzung

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

befunge, 35 24

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

Mit ein wenig Inspiration durch die Antwort von Marinus habe ich auch 24 Charaktere verwaltet. aber ich habe einen ganz anderen ansatz.

PYTHON 2.x, 50 Zeichen

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

C, 70 bis 72 Zeichen

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

Die Ergebnisse auf der SPOJ-Website scheinen definitiv unwirklich - ich habe keine Ahnung, wie ich das auf 63 reduzieren kann.

Einige Compiler erreichen jedoch 68 Zeichen, wenn sie undefiniertes Verhalten missbrauchen. Das Folgende funktioniert unter x86-Linux mit 32-Bit-GCC, auf dem alle Argumente auf dem Stapel übergeben werden.

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

übertreffen, 27

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

Zählen Sie t in A1, Restdaten a2 und abwärts

Clojure, 108

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

Ich wünschte wirklich, ich könnte das java.io.BufferedReader.Teil vermeiden , da es 24 Zeichen selbst kostet. Aber AFAIK gibt es keine Möglichkeit, Zeilen von STDIN ohne es zu lesen.

Perl, 20

Ich weiß, dass es alt und trivial ist, aber die Perl-Antwort kann noch verbessert werden:

#!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 Zeichen lang. Müssen Sie es auf 90 optimieren. Irgendwelche Vorschläge?

PHP, 71

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

Python: (92 Zeichen)

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

Rubin, 42

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

(basierend auf der Antwort von david4dev)

Bestes Ergebnis für Ruby auf spoj: http://www.spoj.com/ranks/SIZECON/lang=RUBY

45 Zeichen in Python

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