Suma los números en estándar en

32

Considere una secuencia / archivo con un entero por línea. Por ejemplo:

123
5
99

Su código debería generar la suma de estos números, es decir 227.

El formato de entrada es estrictamente un entero por línea. No puede, por ejemplo, asumir que la entrada está en una línea como una matriz de enteros.

Puede recibir información de STDIN, en forma de un nombre de archivo o un archivo con el nombre que elija; Puedes elegir cuál. No se permiten otras formas de obtener información.

La entrada contendrá al menos un número entero. Puede suponer que todos los enteros no son negativos y que su suma total es menor que .232

Dennis
fuente
2
¿Hay una nueva línea final? ¿Esa línea nueva es opcional?
Por favor, deja de ser malvado
99
¡Hola! Desestimé este desafío porque va en contra de los estándares de nuestra comunidad para formatos de entrada / salida aceptables al tener un formato de entrada restrictivo.
AdmBorkBork
1
@AdmBorkBork y yo discutimos esto extensamente en la sala de chat. Hemos acordado estar en desacuerdo :)
22
Como autor de las cosas que deben evitarse de la complicada E / S y de omitir arbitrariamente los valores predeterminados , quiero defender este desafío por esos motivos. Aquí, la entrada de procesamiento es la carne del desafío, no un trabajo extra que distrae del desafío principal. No es "agregar números" con requisitos de E / S extraños, es "hacer esta E / S" con agregar como un paso. La anulación de la E / S estándar es necesaria para que las respuestas no sean un atajo en la tarea principal.
xnor
2
¿Por qué no se puede utilizar la entrada de función?
CalculatorFeline

Respuestas:

15

05AB1E , 2 bytes

|O

Explicación:

|   Get input as array
 O  Sum

Pruébalo en línea!

Okx
fuente
77
Eso es ridículo :)
¿Esto se lee desde el estándar en?
1
@Lembik lo hace.
Okx
Creo que su respuesta de 2 bytes fue la primera. ¡Eres el ganador! (A menos que alguien encuentre una respuesta de 1 byte)
44
@Lembik O una respuesta de 0 bytes ...
Camarada SparklePony
21

Bash + coreutils, 16 bytes

xargs|tr \  +|bc

Pruébalo en línea!

Hay dos espacios después del \. Esto también funciona para números negativos.

Explicación:

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

Quizás se pregunte por qué tr \\n +|bcno es mejor, ya que convierte las nuevas líneas directamente en '+'. Bueno, eso tiene 2 errores imprevistos:

  • si la entrada tiene una nueva línea final, entonces se convierte en un '+' final, por lo tanto, no hay ningún número después para realizar la suma
  • y el problema más extraño es que bc requiere una nueva línea final después de la entrada, pero simplemente reemplazó todas las nuevas líneas de entrada con '+'.
seshoumara
fuente
1
Me gusta esto. Es agradable e inteligente.
¿Podrías usar tr \\ n + en su lugar sin xargs?
1
@Lembik ¿Quieres decir tr \\n +|bc? Si es así, consulte la explicación actualizada. Buena pregunta.
seshoumara
paste -s -d+|bces de 15 bytes
David Conrad
1
@Lembik no consideró ese caso, pero afortunadamente el script aún funciona. xargs|tr \ +en este caso no hace nada, y bc recibe el número y lo imprime de nuevo.
seshoumara
14

MATL , 2 bytes

Us

Esto espera la entrada en un archivo de texto llamado defin.

Gif o no sucedió :

ingrese la descripción de la imagen aquí

O pruébalo en línea! Gracias a Dennis por la configuración! )

Explicación

Cuando se ejecuta un programa MATL, si se encuentra un archivo llamado defin(el nombre se refiere a "entrada predeterminada"), su contenido se carga automáticamente como texto y se envía a la pila como una cadena antes de ejecutar el código.

La función Uevalúa la cadena para convertirla en un vector de columna de números y scalcula la suma, que se muestra implícitamente.

Luis Mendo
fuente
13

Japt , 2 bytes

Nx

Explicación

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

Pruébalo en línea!

ETHproducciones
fuente
12

Pegar + aC, 13 bytes

paste -sd+|bc

Explicación:

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

Otra respuesta de shell!

Okx
fuente
1
Muy limpio y ordenado.
Ooh, tenía paste -s -d+|bcy no me di cuenta de que podía consolidar los interruptores. ¡Ordenado!
David Conrad
12

Perl 6 , 13 bytes

say sum lines

Intentalo

Explicación

  • lines()devuelve una lista de líneas desde $*INo$*ARGFILES un identificador de entrada de línea de comando "mágico".
  • sum(…)se agregó a Perl 6 para permitir [+] Listque se optimice para Posicionales que pueden calcular su suma sin generar todos sus valores como 1..100000
    (solo pensé que sumera demasiado lindo aquí para usar[+] como lo haría normalmente)
  • say(…)llama al .gistmétodo en su entrada y lo imprime con una nueva línea adicional.
Brad Gilbert b2gills
fuente
¿Qué es perl 5?
15
esto se lee como lolcode
Bryan Boettcher
@Lembik está claramente etiquetado como Perl 6 , que es un idioma hermano de Perl 5 .
Brad Gilbert b2gills
Hubo un error tipográfico. Quise decir, ¿qué es en Perl 5?
1
Bien $a+=$_ for <>;print $afunciona en Perl 5, pero puede haber un camino más corto.
Brad Gilbert b2gills
10

C, 53 bytes

r;main(i){for(;~scanf("%d",&i);r+=i);printf("%d",r);}
orlp
fuente
C mostrando sus credenciales de nuevo :)
2
Siento que debería haber un camino más corto, pero no lo veo :)
Digital Trauma
9

Retina , 11 7 bytes

-4 gracias a Martin Ender

.*
$*
1

Pruébalo en línea!


Convertir a unario:

.*
$*

Cuenta el número de 1s:

1
Riley
fuente
1
Interesting how Retina, as a regex based language, can do the sum in fewer bytes than the shortest bash answer posted so far. +1
seshoumara
Is this reading from standard in?
2
@Lembik Yes it is.
Riley
If input in unary was allowed, it'd be only one byte.
mbomb007
@mbomb007 I already tried that in sed.
Riley
8

Brain-Flak, 20 bytes

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

Try it online!

Explanation

This is a golf off of a solution made by Riley in chat. His solution was:

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

If your familiar with Brain-Flak this is pretty self-explanatory. It pushes the stack height and pops one value as it counts down, at the end it pushes the sum of all the runs.

It is a pretty good golf but he zeros both {} and ([]) however these will have a values that only differ by one so if instead we remove the masks and make one of the two negative they should nearly cancel out.

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

Since they always differ by one we have the unfortunate circumstance where our answer is always off by the stack height. In order to remedy this we simply move the beginning of the push to encompass the first stack height.

(([]){[{}]{}([])}{})
Wheat Wizard
fuente
1
I thought of it as the negative pop cancels the previous height pushed (from before the loop, or the end of the previous time through), and the last height is 0 so it can be ignored.
Riley
8

Python 2, 40 bytes

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

R,11 bytes

sum(scan())

scan takes the input, one number per line. And sum, well, sums.

Frédéric
fuente
7

Perl 5, 9 bytes

8 bytes of code + -p flag.

$\+=$_}{

Try it online!

With -p, the input is read one line at a time, stored in $_ each time. We use $\ as accumulator, because thanks to -p flag, it's implicitly printed at the end. The unmatched }{ are used so -p flag only prints $\ once at the end instead of printing $_ and $\ at each line it reads like it normally does.

Dada
fuente
I can't even parse it! :) Explanation please.
@Lembik Here you go.
Dada
¡La parte de paréntesis sin igual es muy oscura!
@Lembik Those aren't parenthesizes... They're either French or Curly Braces depends on who you ask, but they definitely are not )(
CraigR8806
1
@Lembik accolades, apparently.
Michael Vehrs
7

Pure Bash, 37 36 bytes

Thanks to @KevinCruijssen for a byte!

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

Try it online!

betseg
fuente
3
Very nice and clean.
I never program in Bash, but isn't it possible to remove the space between do ((? The TIO seems to work.
Kevin Cruijssen
@KevinCruijssen Yeah, it seems like it works. I use zsh as my daily shell and it doesn't work in zsh without a space, I just assumed it wouldn't work in Bash but apparently it does.
betseg
6

Haskell, 32 bytes

interact$show.sum.map read.lines

Try it online!.

interact collects the whole input from stdin, passes it to the function given as its argument and prints the string it gets back from this function. The function is:

            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
nimi
fuente
1
This makes me really like Haskell. In Scala, I have to do lines.map(_.toInt) because sum expects some sort of numeric implicit conversion from String or in this case an explicit one.
Stefan Aleksić
6

PHP, 22 bytes

<?=array_sum(file(t));

This assumes there is a file named "t" with a list of integers.

file() opens a file and returns an array with each line stored a separate element in the array. array_sum() sums all the elements in an array.

Kodos Johnson
fuente
5

Awk, 19 bytes

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

Explanation:

{s+=$1}                For all lines in the input, add to s
        END             End loop
           {print s}    Print s
Okx
fuente
1
"Explanation coming soon™" That'd be my new catchphrase if it weren't trademarked...
ETHproductions
2
In the language of awk, your answer is actually only 19 bytes: {s+=$1}END{print s} :)
Digital Trauma
5

dc, 14 bytes

0[+?z2=a]dsaxp

Try it online!

Explanation:

 [      ] 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
Brian McCutchon
fuente
4

CJam, 5 bytes

q~]1b

Try it online!

How it works

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.
Dennis
fuente
How does 1b sum numbers?
Esolanging Fruit
CJam doesn't require a canonical representation for digits-to-integer conversion; [<x> <y> <z> <w>]<b>b simply computes b³x + b²y + bz + w. When b = 1, this gives x + y + z + w.
Dennis
4

Python, 38 30 bytes

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

In python, files are opened by open('filename') (obviously). They are, however, iterables. Each time you iterate through the file, you get the next line. So map iterates over each list, calling int on it, and then sums the resulting list.

Call with the filename as input. (i.e. f('numbers.txt'))

8 bytes saved by using map(int, open(n)) instead of a list comprehension. Original code:

lambda n:sum([int(i)for i in open(n)]) 
Rɪᴋᴇʀ
fuente
1
I believe that you can also do this with standard input by calling 'open(0)'. Not sure if that can be used to shorten your answer.
cole
@Cole dennis already has that solution, so I'll leave my answer like this.
Rɪᴋᴇʀ
My mistake, sorry about that; I didn't read all the way through before coming to your answer.
cole
@Cole it's okay, I don't mind.
Rɪᴋᴇʀ
4

Mathematica, 19 bytes

Assumes Mathematica's notebook environment.

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

Expects the input to be in a file a.

Martin Ender
fuente
It's a crazy language :)
4
@Lembik normal people would write this very readably as Total @ Flatten @ Import @ "a" or even "a" // Import // Flatten // Total. ;)
Martin Ender
Wouldn't Tr[#&@@@Import@#]& also be allowed?
ngenisis
4

Jelly, 9 8 bytes

ƈFпFỴVS

STDIN isn't really Jelly's thing...

Try it online!

How it works

ƈ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.
Dennis
fuente
1
The second F could be a as well, for clarity.
Erik the Outgolfer
4

Brachylog, 4 bytes

ṇịᵐ+

Try it online!

Explanation

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

Pure bash, 30

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

Try it online.

  • reads the input file in one go into the variable b. -d_ tells read that the line delimiter is _ instead of newline
  • ${b//'newline'/+} replaces the newlines in b with +
  • echo $[ ... ] arithmetically evaluates the resulting expression and outputs it.
Digital Trauma
fuente
+1 Muy bien. ¿También se lee la nueva línea final de un archivo de entrada? Pregunto porque si se reemplaza por '+', la $[]sección generará un error debido a un '+' final.
seshoumara
@seshoumara Parece que readdescarta las nuevas líneas finales, a pesar de que el delimitador de línea se reemplaza por _. Esta es quizás una advertencia read, pero funciona bien para esta situación.
Digital Trauma
Siempre estoy feliz de ver una solución de bash puro.
3

Vim, 16 bytes / pulsaciones de teclas

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

Como V es compatible con versiones anteriores, ¡puede probarlo en línea!

DJMcMayhem
fuente
¿Se trata de una lectura estándar o de un archivo?
Sí, Vim podría no estar permitido ... :(
CalculatorFeline
3

jq , 5 bytes

add, más el indicador de línea de comando -s.

Por ejemplo:

% echo "1\n2\n3\n4\n5" | jq -s add
15
Lynn
fuente
6 bytes . Como -saddno funcionará, cuente el espacio.
agc
@agc Corrígeme si me equivoco pero el código en sí es add(3 bytes) y tienes que agregar 2 bytes para la -sbandera. El espacio no cuenta como el código o la bandera: es el separador de línea de comando utilizado por el idioma.
caird coinheringaahing
1
@ThisGuy, Bueno, el -sindicador es la abreviatura de " --slurp ", (lea toda la secuencia de entrada en una matriz grande y ejecute el filtro solo una vez), lo que cambia la forma en que jqinterpreta los datos de entrada y cómo ejecuta el código. No es como -een el sedque simplemente dice sedque la cadena posterior es código. El -ses más como una parte del jqlenguaje en sí, y por lo tanto ese espacio de 6to byte también lo sería.
agc
3

En realidad , 2 bytes

Pruébalo en línea!

Explicación:

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)
Mego
fuente
3

dc, 22

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

Esto parece más largo de lo que debería ser, pero es difícil decidir cuándo se alcanza el final del archivo. La única forma en que se me ocurre hacer esto es verificar la longitud de la pila después del ?comando.

Pruébalo en línea .

[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

Tenga en cuenta que la macro mse llama recursivamente. Modern dcimplementa la recursión de cola para este tipo de cosas, por lo que no debería preocuparse por desbordar la pila.

Trauma digital
fuente
Bienvenido a PPCG! Tenga en cuenta que si no hay suficientes explicaciones, pasará por el filtro de publicaciones de baja calidad .
Matthew Roh
@SIGSEGV no es necesario, he estado aquí un tiempo ;-). Sí, estaba escribiendo mi explicación mientras comentabas. Ver editar.
Trauma digital
1
Te debo un byte por el truco de duplicar la macro antes de almacenarla.
Brian McCutchon