Betrachten Sie einen Stream / eine Datei mit einer Ganzzahl pro Zeile. Beispielsweise:

123
5
99

Ihr Code sollte also die Summe dieser Zahlen ausgeben 227.

Das Eingabeformat ist nur eine Ganzzahl pro Zeile. Sie können beispielsweise nicht davon ausgehen, dass sich die Eingabe in einer Zeile als Array von Ganzzahlen befindet.

Sie können entweder eine Eingabe von STDIN in Form eines Dateinamens oder einer Datei mit einem Namen Ihrer Wahl vornehmen. Sie können wählen, welche. Andere Eingabemethoden sind nicht zulässig.

Die Eingabe enthält mindestens eine Ganzzahl. Sie können davon ausgehen, dass alle Ganzzahlen nicht negativ sind und dass ihre Gesamtsumme kleiner als ist .232

05AB1E , 2 Bytes

|O

Erläuterung:

|   Get input as array
 O  Sum

Probieren Sie es online!

Bash + Coreutils, 16 Bytes

xargs|tr \  +|bc

Probieren Sie es online!

Nach dem stehen zwei Leerzeichen \. Dies funktioniert auch für negative Zahlen.

Erläuterung:

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

Sie fragen sich vielleicht, warum tr \\n +|bces nicht besser ist, da es Zeilenumbrüche direkt in '+' umwandelt. Nun, das hat 2 unvorhergesehene Fehler:

• Wenn die Eingabe eine abschließende Newline enthält, wird sie in ein abschließendes '+' konvertiert, sodass nach ihr keine Nummer für die Addition vorhanden ist
• und das seltsamste Problem ist, dass bc nach der Eingabe einen abschließenden Zeilenumbruch benötigt, aber Sie haben gerade alle Zeilenumbrüche durch '+' ersetzt.

MATL , 2 Bytes

Us

Dies erwartet die Eingabe in eine aufgerufene Textdatei defin.

Gif oder es ist nicht passiert :

Oder versuchen Sie es online! ( Danke an Dennis für das Setup! )

Erläuterung

Wenn ein MATL-Programm ausgeführt wird und eine aufgerufene Datei defingefunden wird (der Name bezieht sich auf "Standardeingabe"), wird der Inhalt automatisch als Text geladen und als Zeichenfolge in den Stapel geschrieben, bevor der Code ausgeführt wird.

Die Funktion Uwertet den String aus, um ihn in einen Spaltenvektor aus Zahlen zu konvertieren, und sberechnet die implizit angezeigte Summe.

Japt , 2 Bytes

Nx

Erläuterung

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

Probieren Sie es online!

Einfügen + Bc, 13 Bytes

paste -sd+|bc

Erläuterung:

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

Noch eine Shell-Antwort!

Perl 6 , 13 Bytes

say sum lines

Versuch es

Erläuterung

• lines()Gibt eine Liste von Zeilen $*INoder $*ARGFILESein "magisches" Befehlszeilen-Eingabehandle zurück.
• sum(…)wurde 6 bis Perl hinzugefügt , damit [+] Listfür Positionals optimiert werden , die wie ihre Summe ohne alle ihre Werte zu erzeugen berechnen kann 1..100000
  (ich dachte nur sumeinfach zu nett hier war Gebrauch , [+]wie ich normalerweise tun würde)
• say(…)Rufen Sie die .gistMethode für ihre Eingabe auf und drucken Sie sie mit einer zusätzlichen Newline.

C 53 Bytes

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

Python 3 , 28 Bytes

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

Aus diesem Tipp entnommen . Mir wurde gesagt, dass dies unter Windows nicht funktioniert.

Probieren Sie es online!

Retina , 11 7 Bytes

-4 Danke an Martin Ender

.*
$*
1

Probieren Sie es online!

In Unary konvertieren:

.*
$*

Zähle die Anzahl der 1s:

1

Brain-Flak , 20 Bytes

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

Probieren Sie es online!

Erläuterung

Dies ist ein Golf aus einer Lösung von Riley im Chat . Seine Lösung war:

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

Wenn Sie mit Brain-Flak vertraut sind, ist dies ziemlich selbsterklärend. Die Stapelhöhe wird verschoben und beim Herunterzählen wird ein Wert eingefügt. Am Ende wird die Summe aller Läufe verschoben.

Es ist ein ziemlich guter Golf, aber er setzt beide Nullen {}und ([])diese Werte unterscheiden sich nur um eins. Wenn wir stattdessen die Masken entfernen und eines der beiden Negative machen, sollten sie sich fast aufheben.

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

Da sie sich immer um eins unterscheiden, haben wir den unglücklichen Umstand, dass unsere Antwort immer von der Stapelhöhe abweicht. Um dem abzuhelfen, verschieben wir einfach den Beginn des Schiebevorgangs, um die erste Stapelhöhe zu erfassen.

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

Python 2, 40 Bytes

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

R, 11 Bytes

sum(scan())

scanNimmt die Eingabe, eine Nummer pro Zeile. Und sumnaja, Summen.

Perl 5 , 9 Bytes

8 Byte Code + -pFlag.

$\+=$_}{

Probieren Sie es online!

Mit -pwird der Eingang zeilenweise gelesen und jeweils gespeichert $_. Wir verwenden es $\als Akkumulator, weil es dank der -pFlagge implizit am Ende gedruckt wird. Die nicht übereinstimmenden }{werden verwendet, so dass das -pFlag nur $\einmal am Ende gedruckt wird, anstatt zu drucken, $_und $\an jeder Zeile wird es so gelesen, wie es normalerweise der Fall ist.

Pure Bash, 37 36 Bytes

Danke an @KevinCruijssen für ein Byte!

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

Probieren Sie es online!

Haskell, 32 Bytes

interact$show.sum.map read.lines

Probieren Sie es online! .

interactsammelt die gesamte Eingabe von stdin, übergibt sie an die als Argument angegebene Funktion und gibt die Zeichenfolge aus, die sie von dieser Funktion zurückerhält. Die Funktion ist:

            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 Bytes

<?=array_sum(file(t));

Dies setzt voraus, dass es eine Datei mit dem Namen "t" mit einer Liste von ganzen Zahlen gibt.

file()öffnet eine Datei und gibt ein Array zurück, wobei jede Zeile ein separates Element im Array enthält. array_sum()summiert alle Elemente in einem Array.

Awk, 19 Bytes

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

Erläuterung:

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

Gleichstrom , 14 Bytes

0[+?z2=a]dsaxp

Probieren Sie es online!

Erläuterung:

 [      ] 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 Bytes

q~]1b

Probieren Sie es online!

Wie es funktioniert

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 Bytes

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

In Python werden Dateien open('filename')(offensichtlich) von geöffnet . Sie sind jedoch iterables. Jedes Mal, wenn Sie die Datei durchlaufen, wird die nächste Zeile angezeigt. Also iteriert Map über jede Liste, ruft sie intauf und summiert dann die resultierende Liste.

Rufen Sie mit dem Dateinamen als Eingabe auf. (dhf('numbers.txt') )

8 Bytes gespart durch Verwendung map(int, open(n))eines Listenverständnisses. Originalcode:

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

Mathematica, 19 Bytes

Übernimmt die Notebook-Umgebung von Mathematica.

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

Erwartet, dass sich die Eingabe in einer Datei befindet a.

Gelee , 9 8 Bytes

ƈFпFỴVS

STDIN ist nicht wirklich Jellys Sache ...

Probieren Sie es online!

Wie es funktioniert

ƈ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 Bytes

ṇịᵐ+

Probieren Sie es online!

Erläuterung

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

Pure Bash, 30

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

Probieren Sie es online aus.

• reads die Eingabedatei auf einmal in die Variable b. -d_sagt, readdass der Zeilenbegrenzer _statt istnewline
• ${b//'newline'/+}ersetzt die Zeilenumbrüche bdurch+
• echo $[ ... ] wertet den resultierenden Ausdruck arithmetisch aus und gibt ihn aus.

Vim, 16 Bytes / Tastenanschläge

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

Da V abwärtskompatibel ist, können Sie es online ausprobieren!

Pyth , 3 Bytes

s.Q

Probieren Sie es online!

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

jq , 5 Bytes

add, sowie das Kommandozeilen-Flag -s.

Beispielsweise:

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

Eigentlich 2 Bytes

kΣ

Probieren Sie es online!

Erläuterung:

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

Dies scheint etwas länger zu dauern, aber es ist schwierig zu entscheiden, wann das Ende der Datei erreicht ist. Die einzige Möglichkeit, die ich mir vorstellen kann, besteht darin, die Stack-Länge nach dem ?Befehl zu überprüfen .

Probieren Sie es online aus .

[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

Beachten Sie, dass das Makro mrekursiv aufgerufen wird. Modern dcimplementiert die Schwanzrekursion für diese Art von Dingen, daher sollte es keine Sorgen geben, dass der Stapel überfüllt wird.

Pyke , 4 Bytes

zbrs

Probieren Sie es online!

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