Prendi in considerazione un flusso / file con un numero intero per riga. Per esempio:

123
5
99

Il tuo codice dovrebbe generare la somma di questi numeri, cioè 227.

Il formato di input è rigorosamente un numero intero per riga. Ad esempio, non si può supporre che l'input sia su una riga come un array di numeri interi.

Puoi prendere input da STDIN, sotto forma di un nome file, o un file con un nome a tua scelta; puoi scegliere quale. Non sono consentiti altri modi per ottenere input.

L'input conterrà almeno un numero intero. Puoi presumere che tutti i numeri interi siano non negativi e che la loro somma totale sia inferiore a .232

05AB1E , 2 byte

|O

Spiegazione:

|   Get input as array
 O  Sum

Provalo online!

Bash + coreutils, 16 byte

xargs|tr \  +|bc

Provalo online!

Ci sono due spazi dopo il \. Questo funziona anche per numeri negativi.

Spiegazione:

xargs             # known trick to turn newlines into spaces, while adding a
                  #trailing newline when printing the result (needed for bc)
|tr \  +          # turn spaces into '+'s
|bc               # calculates the sum

Potresti chiederti perché tr \\n +|bcnon è meglio, poiché trasforma le nuove righe direttamente in "+". Bene, questo ha 2 errori imprevisti:

• se l'input ha una nuova riga finale, viene convertito in un '+' finale, quindi non c'è nessun numero dopo di esso per eseguire l'aggiunta
• e il problema più strano è che bc richiede una nuova riga finale dopo l'input, ma hai appena sostituito tutte le nuove righe di input con '+'.

MATL , 2 byte

Us

Ciò prevede l'input in un file di testo chiamato defin.

GIF o non è successo :

Oppure provalo online! ( grazie a Dennis per l'allestimento! )

Spiegazione

Quando viene eseguito un programma MATL, se definviene trovato un file chiamato (il nome si riferisce a "input predefinito"), il suo contenuto viene automaticamente caricato come testo e inserito nello stack come stringa prima di eseguire il codice.

La funzione Uvaluta la stringa per convertirla in un vettore di numeri di colonna e scalcola la somma, che viene implicitamente visualizzata.

Japt , 2 byte

Nx

Spiegazione

     Implicit: parse STDIN into array of numbers, strings, and arrays
N    Get the resulting parsed array.
 x   Sum.
     Implicit: output result of last expression

Provalo online!

Incolla + bc, 13 byte

paste -sd+|bc

Spiegazione:

paste -s        Take one line at a time from input
        d+      Joining by '+'
          |bc   Pass as expression to bc

Un'altra risposta da shell!

Perl 6 , 13 byte

say sum lines

Provalo

Spiegazione

• lines()restituisce un elenco di righe da $*INo $*ARGFILESun handle di input della riga di comando "magico".
• sum(…)è stato aggiunto a Perl 6 per consentire [+] Listdi essere ottimizzato per i posizionali che possono calcolare la loro somma senza generare tutti i loro valori come 1..100000
  (pensavo che sumfosse troppo carino qui per usarlo [+]come farei normalmente)
• say(…)chiama il .gistmetodo sul suo input e lo stampa con una nuova riga aggiuntiva.

C, 53 byte

r;main(i){for(;~scanf("%d",&i);r+=i);printf("%d",r);}

Python 3 , 28 byte

print(sum(map(int,open(0))))

Tratto da questo suggerimento . Mi è stato detto che non funzionerà su Windows.

Provalo online!

Retina , 11 7 byte

-4 grazie a Martin Ender

.*
$*
1

Provalo online!

Converti in unario:

.*
$*

Conta il numero di 1s:

1

Brain-Flak , 20 byte

(([]){[{}]{}([])}{})

Provalo online!

Spiegazione

Questo è il golf di una soluzione fatta da Riley in chat . La sua soluzione era:

([])({<{}>{}<([])>}{})

Se hai familiarità con Brain-Flak questo è abbastanza autoesplicativo. Spinge l'altezza dello stack e apre un valore mentre conta alla rovescia, alla fine spinge la somma di tutte le corse.

È un golf abbastanza buono ma ha entrambi zeri {}e ([])comunque questi avranno valori che differiscono solo per uno, quindi se invece rimuoviamo le maschere e rendiamo uno dei due negativi, dovrebbero quasi annullarsi.

([])({[{}]{}([])}{})

Dato che differiscono sempre per uno, abbiamo la sfortunata circostanza in cui la nostra risposta è sempre fuori dall'altezza della pila. Per ovviare a questo, spostiamo semplicemente l'inizio della spinta per includere l'altezza del primo stack.

(([]){[{}]{}([])}{})

Python 2, 40 byte

import sys;print sum(map(int,sys.stdin))

R, 11 byte

sum(scan())

scanaccetta l'input, un numero per riga. E sum, beh, somme.

Perl 5 , 9 byte

8 byte di codice + -pflag.

$\+=$_}{

Provalo online!

Con -p, l'ingresso viene letto una riga alla volta, memorizzato in $_ogni volta. Usiamo $\come accumulatore, perché grazie alla -pbandiera, è implicitamente stampato alla fine. Gli ineguagliati }{vengono utilizzati in modo che la -pbandiera venga $\stampata una sola volta alla fine invece di essere stampata $_e $\su ogni riga si legge normalmente.

Pure Bash, 37 36 byte

Grazie a @KevinCruijssen per un byte!

while read a;do((b+=a));done;echo $b

Provalo online!

Haskell, 32 byte

interact$show.sum.map read.lines

Provalo online! .

interactraccoglie l'intero input dallo stdin, lo passa alla funzione fornita come argomento e stampa la stringa che ottiene da questa funzione. La funzione è:

            lines   -- split input into list of lines at nl
      map read      -- convert every line to a number (read is polymorphic,
                    -- but as want to sum it later, the type checker knows
                    -- it has to be numbers)
    sum             -- sum the list of numbers
show                -- convert back to string

PHP, 22 byte

<?=array_sum(file(t));

Ciò presuppone l'esistenza di un file denominato "t" con un elenco di numeri interi.

file()apre un file e restituisce un array con ogni riga memorizzata un elemento separato nell'array. array_sum()somma tutti gli elementi in un array.

Awk, 19 byte

{s+=$1}END{print s}

Spiegazione:

{s+=$1}                For all lines in the input, add to s
        END             End loop
           {print s}    Print s

dc , 14 byte

0[+?z2=a]dsaxp

Provalo online!

Spiegazione:

 [      ] sa   # recursive macro stored in register a, does the following:
  +            # - sum both numbers on stack
               #   (prints to stderr 1st time since there's only 1)
   ?           # - read next line, push to stack as number
    z          # - push size of stack
     2         # - push 2
      =a       # - if stack size = 2, ? yielded something, so recurse
               # - otherwise end macro (implicit)
0              # push 0 (accumulator)
         d     # duplicate macro before storing it
            x  # Call macro
             p # The sum should be on the stack now, so print it

CJam , 5 byte

q~]1b

Provalo online!

Come funziona

q     e# Read all input from STDIN.
 ~    e# Evaluate that input, pushing several integers.
  ]   e# Wrap the entire stack in an array.
   1b e# Convert from base 1 to integer.
      e# :+ (reduce by sum) would work as well, but 1b handles empty arrays.

Python, 38 30 byte

lambda n:sum(map(int,open(n)))

In Python, i file vengono aperti da open('filename')(ovviamente). Sono, tuttavia, iterabili. Ogni volta che si scorre il file, si ottiene la riga successiva. Quindi la mappa scorre su ogni elenco, chiamandolo inte quindi somma l'elenco risultante.

Chiama con il nome file come input. (ie f('numbers.txt'))

8 byte salvati utilizzando map(int, open(n))anziché una comprensione dell'elenco. Codice originale:

lambda n:sum([int(i)for i in open(n)]) 

Mathematica, 19 byte

Presuppone l'ambiente notebook di Mathematica.

Tr[#&@@@Import@"a"]

Si aspetta che l'input sia in un file a.

Gelatina , 9 8 byte

ƈFпFỴVS

STDIN non è davvero una cosa di Jelly ...

Provalo online!

Come funziona

ƈFпFỴVS  Main link. No arguments. Implicit argument: 0

  п      While loop; while the condition returns a truthy value, execute the body
          and set the return value to the result. Collect all results (including 0,
          the initial return value) in an array and return that array.
ƈ           Body: Yield a character from STDIN or [] if the input is exhausted.
 F          Condition: Flatten, mapping 0 to [], '0' to "0", and [] to [] (falsy).
    F     Flatten the result.
     Ỵ    Split at newlines.
      V   Evaluate the resulting strings.
       S  Take the sum.

Brachylog , 4 byte

ṇịᵐ+

Provalo online!

Spiegazione

ṇ         Split the Input on linebreaks
 ịᵐ       Map: String to Integer
   +      Sum

Bash puro, 30

read -d_ b
echo $[${b//'
'/+}]

Provalo online.

• reads il file di input in una volta entra nella variabile b. -d_indica readche il delimitatore di riga è _invece dinewline
• ${b//'newline'/+}sostituisce le nuove righe bcon+
• echo $[ ... ] valuta aritmeticamente l'espressione risultante e la genera.

Vim, 16 byte / sequenze di tasti

:%s/\n/+
C<C-r>=<C-r>"<C-h>

Poiché V è retrocompatibile, puoi provarlo online!

Pyth , 3 byte

s.Q

Provalo online!

 .Q  Read all of standard input, evaluating each line.
s    Take the sum.

jq , 5 byte

add, oltre al flag della riga di comando -s.

Per esempio:

% echo "1\n2\n3\n4\n5" | jq -s add
15

In realtà , 2 byte

kΣ

Provalo online!

Spiegazione:

kΣ
    (implicit input - read each line, evaluate it, and push it to the stack)
k   pop all stack elements and push them as a list
 Σ  sum
    (implicit output)

dc, 22

[pq]sq0[?z2>q+lmx]dsmx

Questo sembra piuttosto più lungo di quanto dovrebbe essere, ma è difficile decidere quando viene raggiunta la fine del file. L'unico modo in cui mi viene in mente di farlo è controllare la lunghezza dello stack dopo il ?comando.

Provalo online .

[pq]                    # macro to `p`rint top-of-stack, then `q`uit the program
    sq                  # save the above macro in the `q` register
      0                 # push `0` to the stack.  Each input number is added to this (stack accumulator)
       [         ]      # macro to:
        ?               # - read line of input
         z              # - push stack length to stack
          2             # - push 2 to the stack
           >q           # - if 2 > stack length then invoke macro stored in `q` register
             +          # - add input to stack accumulator
              lmx       # - load macro stored in `m` register and execute it
                  d     # duplicate macro
                   sm   # store in register `m`
                     x  # execute macro

Nota la macro msi chiama ricorsivamente. Il moderno dcimplementa la ricorsione della coda per questo genere di cose, quindi non dovresti preoccuparti di traboccare lo stack.

Pyke , 4 byte

zbrs

Provalo online!

z    -   input()
 b   -  int(^)
  r  - if no errors: goto start
   s - sum(stack)