Problema:

Dato un insieme di numeri interi, trova la somma di tutti i numeri interi positivi in ​​essa.

Ingresso:

• t - numero di casi di test [ t <1000]
• Su ciascuna delle successive linee t , un numero intero N [-1000 ≤ N ≤ 1000]

Produzione

Il programma dovrebbe generare la somma di tutti gli interi positivi.

Controlla il tuo codice nel giudice online

Punto

Il punteggio è uguale alla dimensione del codice sorgente del programma ad eccezione dei simboli con codice ASCII ≤ 32.

Ecco la lista dei migliori punteggi: Python punteggi migliori (il punteggio migliore è 29)

Spazio bianco, 0

Non ho resistito. S= spazio, T= tab, N= newline, tutti hanno codici ASCII <= 32.

SSSSNSSSSNTTSSSSSTNTNTTNSSSNSSSSTNTTTNTSTNSSSSTNSSSSTNTTTSSSSTNTSSTTTSSSSSTSNTNTTSSSSTSNTTTNTTSNSSSSNSSSSTSNTTTSSSSNTTTTSSSTTSNSNSNNSSTNSSSSNTTTTNSTSSSSTSTSNTNSSNNN

Base64 codificato per un facile copia e incolla.

ICAgIAogICAgCgkJICAgICAJCgkKCQkKICAgCiAgICAJCgkJCQoJIAkKICAgIAkKICAgIAkKCQkJ
ICAgIAkKCSAgCQkJICAgICAJIAoJCgkJICAgIAkgCgkJCQoJCSAKICAgIAogICAgCSAKCQkJICAg
IAoJCQkJICAgCQkgCiAKIAoKICAJCiAgICAKCQkJCQogCSAgICAJIAkgCgkKICAKCgo=

Elemento, 17 caratteri più 1 spazio

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

Questo è il mio primo linguaggio costruito. È progettato per essere molto compatto e leggibile dall'uomo. Tutte le istruzioni sono lunghe un carattere e svolgono un'unica funzione.

L'elemento ha due pile e un hash come strutture di memoria. Le due pile sono chiamate la pila principale e la pila di controllo. Lo stack principale è dove si verificano la manipolazione aritmetica, I / O e hash. Lo stack di controllo è dove si verificano le operazioni logiche e questo stack controlla i cicli while e for.

L'idea di base dietro Element è che esiste un hash che memorizza numeri / stringhe, mentre lo stack viene utilizzato per eseguire calcoli su questi numeri. I risultati di questi calcoli possono quindi assegnare un determinato posto nell'hash per uso futuro. I diversi contenuti dell'hash sono chiamati elementi, quindi è simile a un array ma può avere nomi non numerici.

EDIT: Puoi trovare un interprete per Element (scritto in Perl) qui .

Ecco l'elenco degli operatori: In alcuni di questi esempi, m e n rappresentano numeri già presenti nello stack.

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 \

Ecco una panoramica di come funziona il programma:

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

Chiama come il nome dello script ruby ​​file_with_ints.

Ruby, 52

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

Haskell, 58 anni

Funziona correttamente solo t numeri interi. Non l'ho mai fatto contro Spoj perché non mi interessa registrarmi lì.

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

inserire il codice C 89 caratteri

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

Ho provato molto a ridurre il mio codice a meno di 63 byte, ma posso ridurlo solo a 89 byte. Aiutatemi a ridurlo a 63 byte o anche meno.

Perl, 33

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

Sebbene lo spazio sia necessario, quindi sembra strano non contarlo. Oh bene, le regole sono le regole.

Hmm. Probabilmente potrei cavarmela usando un nome variabile che non conta neanche per il totale. Il fatto è che non sono sicuro di come incollerei il codice allora.

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

supponendo che i sia il file, contenente gli ints.

¹) era errato, includeva il numero di righe e ne aggiungeva 1 in meno.

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

(spazi extra per chiarezza, dal momento che non contano)

Haskell è ... interessante, poiché si tende ad ottenere programmi con un numero significativo di spazi necessari.

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

Dopo un altro grande sforzo, il codice ha un carattere in meno, per favore aiutatemi a ridurlo di più.

Befunge-98 (24)

(Assicurati di usare un interprete in grado di leggere numeri negativi (sembra essere un bug piuttosto comune, ma RcFunge funziona))

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

Perl (25)

(Perl consente i caratteri di controllo nei nomi delle variabili, ho chiamato la mia variabile ^ B (ASCII 2) in modo che non conti ai fini dell'obiettivo.)

<>; $ ^ B + = $ _ *! / - / per <>; stampa $ ^ B

(Variante normale (27 caratteri)):

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

APL (10)

+/{0⌈⎕}¨⍳⎕

Spiegazione:

• ⍳⎕: legge una riga, fornisce un elenco [1..N] per l'input dell'utente N
• ¨: per ogni elemento in questo elenco ... (cioè fare N volte)
• 0⌈⎕: legge una riga, restituisce il massimo di 0 e la N immessa
• Ora abbiamo un elenco con tutte le N positive che l'utente ha inserito e 0 dove l'utente ha inserito qualcosa di negativo.
• +/ dà la somma di questo elenco.
• Il risultato viene generato per impostazione predefinita (perché non stiamo facendo nient'altro con esso).

Mathematica: 18 16

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

PowerShell, 44

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

Q, 12

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

utilizzo del campione

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

befunge, 35 24

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

con un po 'di ispirazione vedendo la risposta di Marin, ho gestito anche 24 personaggi. ma ho un approccio completamente diverso.

PYTHON 2.x, 50 caratteri

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

C, 70 72 caratteri

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

I risultati sul sito SPOJ sembrano decisamente irreali - non ho idea di come arrivare a 63.

Tuttavia, in alcuni compilatori è possibile raggiungere 68 caratteri abusando di comportamenti indefiniti. Quanto segue funziona su Linux x86 con gcc a 32 bit, su cui vengono passati tutti gli argomenti nello stack.

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

eccellente, 27

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

contare t in A1, resto dei dati a2 e giù

Clojure, 108

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

Vorrei davvero poter evitare la java.io.BufferedReader.parte, poiché costa 24 caratteri in sé. Ma AFAIK non ha alcuna possibilità di leggere righe da STDIN senza di essa.

Perl, 20 anni

So che è vecchio e banale, ma la risposta Perl può ancora essere migliorata:

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

Lunga 115 caratteri. Devi ottimizzarlo a 90. Qualche suggerimento?

PHP, 71

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

Python: (92 caratteri)

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

(basato sulla risposta di david4dev)

Miglior punteggio per Ruby su spoj: http://www.spoj.com/ranks/SIZECON/lang=RUBY

45 caratteri in pitone

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