Considérez un flux / fichier avec un entier par ligne. Par exemple:

123
5
99

Votre code doit afficher la somme de ces nombres, c'est-à-dire 227.

Le format d'entrée est strictement un entier par ligne. Vous ne pouvez pas, par exemple, supposer que l'entrée se trouve sur une seule ligne sous la forme d'un tableau d'entiers.

Vous pouvez saisir des données soit de STDIN, sous la forme d'un nom de fichier, soit d'un fichier avec un nom de votre choix; vous pouvez choisir lequel. Aucun autre moyen d'obtenir des entrées n'est autorisé.

L'entrée contiendra au moins un entier. Vous pouvez supposer que tous les entiers sont non négatifs et que leur somme totale est inférieure à .232

05AB1E , 2 octets

|O

Explication:

|   Get input as array
 O  Sum

Essayez-le en ligne!

Bash + coreutils, 16 octets

xargs|tr \  +|bc

Essayez-le en ligne!

Il y a deux espaces après le \. Cela fonctionne également pour les nombres négatifs.

Explication:

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

Vous vous demandez peut-être pourquoi ce tr \\n +|bcn'est pas mieux, car il transforme directement les sauts de ligne en «+». Eh bien, cela a 2 erreurs imprévues:

• si l'entrée a un retour à la ligne final, alors il est converti en un «+» final, donc il n'y a pas de numéro après pour effectuer l'addition
• et le problème le plus étrange est que bc nécessite un retour à la ligne après l'entrée, mais vous venez de remplacer tous les retours à la ligne d'entrée par des «+».

MATL , 2 octets

Us

Cela attend l'entrée dans un fichier texte appelé defin.

Gif ou ce n'est pas arrivé :

Ou essayez-le en ligne! ( merci à Dennis pour la mise en place! )

Explication

Lorsqu'un programme MATL est exécuté, si un fichier appelé definest trouvé (le nom fait référence à "entrée par défaut"), son contenu est automatiquement chargé sous forme de texte et poussé vers la pile sous forme de chaîne avant d'exécuter le code.

La fonction Uévalue la chaîne pour la convertir en un vecteur de colonne de nombres et scalcule la somme, qui est implicitement affichée.

Japt , 2 octets

Nx

Explication

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

Essayez-le en ligne!

Coller + bc, 13 octets

paste -sd+|bc

Explication:

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

Une autre réponse shell!

Perl 6 , 13 octets

say sum lines

L'essayer

Explication

• lines()renvoie une liste de lignes $*INou $*ARGFILESun descripteur de ligne de commande «magique».
• sum(…)a été ajouté à Perl 6 pour permettre [+] Listd'être optimisé pour les positionnels qui peuvent calculer leur somme sans générer toutes leurs valeurs comme 1..100000
  (je pensais juste que sumc'était trop mignon ici pour l'utiliser [+]comme je le ferais normalement)
• say(…)appeler la .gistméthode sur son entrée et l'imprimer avec une nouvelle ligne supplémentaire.

C, 53 octets

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

Python 3 , 28 octets

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

Tiré de cette astuce . On m'a dit que cela ne fonctionnerait pas sous Windows.

Essayez-le en ligne!

Rétine , 11 7 octets

-4 merci à Martin Ender

.*
$*
1

Essayez-le en ligne!

Convertir en unaire:

.*
$*

Comptez le nombre de 1s:

1

Brain-Flak , 20 octets

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

Essayez-le en ligne!

Explication

Ceci est un golf hors d' une solution faite par Riley dans le chat . Sa solution était:

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

Si vous êtes familier avec Brain-Flak, cela va de soi. Il pousse la hauteur de la pile et affiche une valeur pendant le décompte, à la fin, il pousse la somme de tous les passages.

C'est un très bon golf mais il met les deux à zéro {}et ([])cependant ceux-ci auront des valeurs qui ne diffèrent que par un, donc si à la place nous retirons les masques et rendons l'un des deux négatifs, ils devraient presque annuler.

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

Puisqu'ils diffèrent toujours par un, nous avons la malheureuse circonstance où notre réponse est toujours décalée par la hauteur de la pile. Pour y remédier, il suffit de déplacer le début de la poussée pour englober la première hauteur de pile.

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

Python 2, 40 octets

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

R, 11 octets

sum(scan())

scanprend l'entrée, un nombre par ligne. Et sumbien, des sommes.

Perl 5 , 9 octets

8 octets de code + -pindicateur.

$\+=$_}{

Essayez-le en ligne!

Avec -p, l'entrée est lue une ligne à la fois, stockée à $_chaque fois. Nous utilisons $\comme accumulateur, car grâce au -pdrapeau, il est implicitement imprimé à la fin. Les éléments inégalés }{sont utilisés de sorte que le -pdrapeau ne s'imprime qu'une $\fois à la fin au lieu d'imprimer $_et $\à chaque ligne, il se lit comme d' habitude .

Pure Bash, 37 36 octets

Merci à @KevinCruijssen pour un octet!

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

Essayez-le en ligne!

Haskell, 32 octets

interact$show.sum.map read.lines

Essayez-le en ligne! .

interactcollecte l'intégralité de l'entrée de stdin, la transmet à la fonction donnée comme argument et affiche la chaîne qu'il récupère de cette fonction. La fonction est:

            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 octets

<?=array_sum(file(t));

Cela suppose qu'il existe un fichier nommé "t" avec une liste d'entiers.

file()ouvre un fichier et renvoie un tableau avec chaque ligne stockée un élément séparé dans le tableau. array_sum()additionne tous les éléments d'un tableau.

Awk, 19 octets

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

Explication:

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

dc , 14 octets

0[+?z2=a]dsaxp

Essayez-le en ligne!

Explication:

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

q~]1b

Essayez-le en ligne!

Comment ça marche

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 octets

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

En python, les fichiers sont ouverts par open('filename')(évidemment). Ce sont cependant des itérables. Chaque fois que vous parcourez le fichier, vous obtenez la ligne suivante. La carte itère donc sur chaque liste, l'appelle int, puis additionne la liste résultante.

Appelez avec le nom de fichier en entrée. (ie f('numbers.txt'))

8 octets enregistrés en utilisant map(int, open(n))au lieu d'une compréhension de liste. Code d'origine:

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

Mathematica, 19 octets

Suppose l'environnement de bloc-notes de Mathematica.

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

Attend que l'entrée soit dans un fichier a.

Gelée , 9 8 octets

ƈFпFỴVS

STDIN n'est pas vraiment le truc de Jelly ...

Essayez-le en ligne!

Comment ça marche

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

ṇịᵐ+

Essayez-le en ligne!

Explication

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

Pure bash, 30

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

Essayez-le en ligne.

• reads le fichier d'entrée en une seule fois dans la variable b. -d_indique readque le délimiteur de ligne est _au lieu denewline
• ${b//'newline'/+}remplace les sauts de ligne bavec+
• echo $[ ... ] évalue arithmétiquement l'expression résultante et la renvoie.

Vim, 16 octets / touches

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

Étant donné que V est rétrocompatible, vous pouvez l' essayer en ligne!

Pyth , 3 octets

s.Q

Essayez-le en ligne!

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

jq , 5 octets

add, plus l'indicateur de ligne de commande -s.

Par exemple:

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

En fait , 2 octets

kΣ

Essayez-le en ligne!

Explication:

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

Cela semble plus long qu'il ne devrait l'être, mais il est difficile de décider quand la fin du fichier est atteinte. La seule façon de penser à cela est de vérifier la longueur de la pile après la ?commande.

Essayez-le en ligne .

[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

Notez que la macro mest appelée récursivement. Modern dcimplémente la récursivité de queue pour ce genre de chose, donc il ne devrait pas y avoir de soucis pour déborder la pile.

Pyke , 4 octets

zbrs

Essayez-le en ligne!

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