Agrega dos números

44

Entrada: dos enteros. Preferiblemente enteros decimales, pero se pueden usar otras formas de números. Estos pueden darse al código en la entrada estándar, como argumentos para el programa o función, o como una lista.

Salida: Su suma. Use el mismo formato para los enteros de salida que los enteros de entrada. Por ejemplo, la entrada 5 16conduciría a la salida 21.

Restricciones: No hay lagunas estándar, por favor. Este es el , la respuesta en la menor cantidad de bytes gana.

Notas: Esto debería ser bastante trivial, sin embargo, estoy interesado en ver cómo se puede implementar. La respuesta puede ser un programa completo o una función, pero identifique cuál es.

Casos de prueba:

1 2 -> 3
14 15 -> 29
7 9 -> 16
-1 8 -> 7
8 -9 -> -1
-8 -9 -> -17

O como CSV:

a,b,c
1,2,3
14,15,29
7,9,16
-1,8,7
8,-9,-1
-8,-9,-17

Tabla de clasificación

dkudriavtsev
fuente
26
Esto es bastante trivial, pero no es realmente más simple que, por ejemplo, el catálogo Hello World. Dado que la capacidad de agregar enteros es uno de nuestros dos requisitos para los lenguajes de programación, diría que vale la pena tenerlo si se especifica correctamente.
Dennis
1
¿Puede la respuesta tomar entrada con ceros anteriores como predeterminada? por ejemplo, 5 16se 005 016
ingresa
@FinW Claro. Mientras no se interpreten como octal.
dkudriavtsev

Respuestas:

38

Gelatina , 1 byte

+

Pruébalo en línea!

También funciona en 05AB1E, Actually, APL, Braingolf, ,,, (Commata), Factor, Forth, Implicit, J, Julia, K, kdb +, Keg, Ly, MATL, Pyke, Deorst y Q.

Dennis
fuente
3
También funciona en Swift.
Zacharý
3
Pyth también @ Zacharý
Stan Strum
66

Minecraft 1.10, 221 caracteres (no competitivos)

Mira, esto es con lo que tenemos que lidiar cuando hacemos mapas de Minecraft.

Aparte: no hay forma de tomar una entrada de cadena en Minecraft, así que estoy engañando un poco al hacer que ingreses los números en el programa. (Es algo justificable porque bastantes mapas, como Minecraft Bingo de Lorgon111, requieren que copie y pegue comandos en el chat para ingresar un número).

Gracias abrightmoore por el filtro Block Labels MCEdit.

una

scoreboard objectives add a dummy
scoreboard players set m a 6
scoreboard players set n a 8
scoreboard players operation r a += m a
scoreboard players operation r a += n a
tellraw @a {"score":{"name":"r","objective":"a"}}

No compite debido a dificultades en la entrada, y no tengo idea de cómo contar bytes en esto (el sistema blytes tiene fallas para los bloques de comandos).

quat
fuente
44
Este es, de lejos, el mejor. Asombroso.
dkudriavtsev
No creo que la codificación rígida de las entradas sea válida, pero no sé lo suficiente sobre los bloques de comandos en Minecraft para poder juzgar si hay una manera de tomar una entrada que no sea la codificación rígida. Tal vez uno de nuestros expertos residentes de Minecraft podría opinar.
Mego
3
Sí, no hay entrada de texto en MC, además de "copie y pegue este comando". Un teclado numérico es posible con un / tellraw, pero será apenas utilizable en todos los campos de golf, sin mencionar 500kb gracias a la sintaxis estrictamente obscena de / tellraw. Supongo que una alternativa sería contar algo en el mundo, como cerdos + vacas, o lana roja + lana azul.
cuatr
1
@quat Como usualmente usamos la tolva para contar cosas en Minecraft, supongo que sería el camino a seguir. Otra forma de lidiar con esto también sería factible en piedra roja pura usando palancas. Como no tenemos ninguna restricción, y el bit es el mayor valor natural alcanzable en Minecraft, eso daría como resultado simplemente agregar dos bits con una salida de dos bits (posibilidad: 0,1,2otra solución sería tomar 2 bytes y salida en 9 hilos, pero sería mucho menos golfista.
Katenkyo
39

Cálculo binario lambda , 4.125 bytes

Entrada y salida como números de iglesia .

00000000 01011111 01100101 11101101 0

En el cálculo lambda , es λ m . λ n . λ f . λ x . m f ( n f x ).

Índice de Bruijn : λ λ λ λ 4 2 (3 2 1)


El cálculo de Lambda es una forma concisa de describir un mapeo (función).

Por ejemplo, esta tarea se puede escribir como λ x . λ y . x + y

Lo que hay que tener en cuenta es que esta no es una lambda (función) que toma dos argumentos. Esto es en realidad una lambda anidada. Sin embargo, se comporta como una lambda que toma dos argumentos, por lo que puede describirse informalmente como tal. Cada lambda formalmente solo toma un argumento.

Por ejemplo, si aplicamos este lambda a 3 y 4:

x . λ y . x + y ) 3 4 ≡ (λ y . 3 + y ) 4 ≡ 3 + 4 = 7

Entonces, la primera lambda en realidad devuelve otra lambda.


Los números de la iglesia son una forma de eliminar los signos adicionales, dejando solo los símbolos y variables lambda.

Cada número en el sistema de la Iglesia es en realidad una lambda que especifica cuántas veces se aplica la función a un elemento.

Deje que la función sea fy el elemento sea x .

Entonces, el número 1 correspondería a λ f . λ x . f x , lo que significa aplicar f a x exactamente una vez.

El número 3, por ejemplo, sería λ f . λ x . f ( f ( f x )), lo que significa aplicar f a x exactamente tres veces.


Por lo tanto, añadir dos números Church (digamos, m y n ) juntos, es lo mismo que aplicar f a x , m + n veces.

Podemos observar que esto es lo mismo que aplicar primero f a x , n veces, y luego aplicar f al elemento resultante m veces.

Por ejemplo, 2 significaría f(f(x))y 3 significaría f(f(f(x))), entonces 2 + 3 sería f(f(f(f(f(x))))).

Para aplicar f a x , n veces, tenemos n f x .

Puede ver m y n como funciones tomar dos argumentos, de manera informal.

Luego, aplicamos f nuevamente a este elemento resultante, m veces: m f ( n f x ).

Luego, volvemos a agregar el repetitivo para obtener λ m . λ n . λ f . λ x . m f ( n f x ).


Ahora, tenemos que convertirlo al índice De Bruijn .

En primer lugar, contamos la "distancia relativa" entre cada variable y la declaración lambda. Por ejemplo, la m tendría una distancia de 4, porque se declara 4 lambdas "ago". Del mismo modo, la n tendría una distancia de 3, la f tendría una distancia de 2 y la x tendría una distancia de 1.

Entonces, lo escribimos como esta forma intermedia: λ m . λ n . λ f . λ x . 4 2 (3 2 1)

Luego, eliminamos las declaraciones de variables, dejándonos con: λ λ λ λ 4 2 (3 2 1)


Ahora, lo convertimos en cálculo lambda binario .

Las reglas son:

  • λ se convierte 00.
  • m n (agrupación) se convierte en 01 m n.
  • números i se convierte en 1 i multiplicado por + 0, por ejemplo, 4 se convierte en 11110.

λ λ λ λ 4 2 (3 2 1)

≡ λ λ λ λ 11110 110( 1110 110 10)

≡ λ λ λ λ 11110 110 0101 111011010

≡ λ λ λ λ 0101 111101100101111011010

00 00 00 00 0101 111101100101 111011010

000000000101111101100101111011010

Monja permeable
fuente
18
Me gustaría ver el archivo fuente de 4.125 bytes que pasa al intérprete / compilador.
Martin Ender
8
@MartinEnder Di eso a cada respuesta aquí .
Leaky Nun
55
Me gustaría ver una solución de 0,875 bytes por favor.
Sr. Lister el
3
Por meta consenso , a menos que pueda almacenar el programa como un archivo con una cantidad fraccional de bytes, debe redondear.
Pavel
24

Lisp común, 15 bytes

(+(read)(read))
Byeonggon Lee
fuente
2
¡Bienvenido a Programming Puzzles & Code Golf!
Dennis
No estoy familiarizado con CLisp, pero ¿sería posible eliminar los espacios? (+(read)(read))
Mego
@Mego Tienes razón, es posible. No lo sabía porque también soy nuevo en Common Lisp, ¡gracias por la información! Edité la fuente
Byeonggon Lee
3
¡Supongo que los dos aprendimos algo aquí! ¡Bienvenido a bordo a PPCG!
Mego
21

Apilar gatos , 8 + 4 = 12 bytes

]_:]_!<X

Corre con las -mnbanderas. Pruébalo en línea!

Jugar al golf en Stack Cats es altamente contradictorio, por lo que este programa anterior se encontró con unos días de fuerza bruta. A modo de comparación, una solución más intuitiva escrita por humanos que usa la *(...)>plantilla es dos bytes más larga

*(>-_:[:)>

con las -lnbanderas en su lugar (vea la parte inferior de esta publicación para obtener una explicación).

Explicación

Aquí hay un manual sobre Stack Cats:

  • Stack Cats es un lenguaje esotérico reversible donde el espejo de un fragmento deshace el efecto del fragmento original. Los programas también deben ser imágenes especulares de sí mismo; necesariamente, esto significa que los programas de longitud par son no-ops o bucles infinitos, y todos los programas de terminación no triviales son de longitud impar (y son esencialmente una conjugación del operador central).
  • Dado que la mitad del programa siempre está implícito, la mitad se puede omitir con el indicador -mo -l. Aquí -mse usa la bandera, por lo que el medio programa anterior se expande realmente a ]_:]_!<X>!_[:_[.
  • Como su nombre lo indica, Stack Cats está basado en la pila, con las pilas sin fondo con ceros (es decir, las operaciones en una pila vacía devuelven 0). Stack Cats en realidad usa una cinta de pilas, por ejemplo, <y >mueve una pila hacia la izquierda y una pila hacia la derecha respectivamente.
  • Los ceros en la parte inferior de la pila se tragan / eliminan.
  • Todas las entradas se envían a una pila de entrada inicial, con la primera entrada en la parte superior y un -1 adicional debajo de la última entrada. La salida se realiza al final, utilizando el contenido de la pila actual (con un -1 opcional en la parte inferior que se ignora). -ndenota E / S numérica.

Y aquí hay un rastro del programa completo expandido ]_:]_!<X>!_[:_[:

    Initial state (* denotes current stack):
      ... [] [-1 b a]* [] [] ...
]   Move one stack right, taking the top element with you
      ... [] [-1 b] [a]* [] ...
_   Reversible subtraction, performing [x y] -> [x x-y] (uses an implicit zero here)
      ... [] [-1 b] [-a]* [] ...
:   Swap top two
      ... [] [-1 b] [-a 0]* [] ...
]   Move one stack right, taking the top element with you
      ... [] [-1 b] [-a] []* ...
_   Reversible subtraction (0-0, so no-op here)
!   Bit flip top element, x -> -x-1
      ... [] [-1 b] [-a] [-1]* ...
<   Move one stack left
      ... [] [-1 b] [-a]* [-1] ...
X   Swap the stack to the left and right
      ... [] [-1] [-a]* [-1 b] ...
>   Move one stack right
      ... [] [-1] [-a] [-1 b]* ...
!   Bit flip
      ... [] [-1] [-a] [-1 -b-1]* ...
_   Reversible subtraction
      ... [] [-1] [-a] [-1 b]* ...
[   Move one stack left, taking the top element with you
      ... [] [-1] [-a b]* [-1] ...
:   Swap top two
      ... [] [-1] [b -a]* [-1] ...
_   Reversible subtraction
      ... [] [-1] [b a+b]* [-1] ...
[   Move one stack left, taking the top element with you
      ... [] [-1 a+b]* [b] [-1] ...

a+bluego se emite, con la base -1 ignorada. Tenga en cuenta que la parte más complicada de esta solución es que la pila de salida debe tener una -1en la parte inferior; de lo contrario, una pila de salida simplemente [-1]ignoraría la base -1, y una pila de salida [0]provocaría que se tragara la base cero (pero una salida pila de [2], por ejemplo, saldría 2bien).


Solo por diversión, aquí está la lista completa de soluciones relacionadas de la misma longitud encontrada (la lista puede no estar completa):

]_:]^!<X
]_:]_!<X
]_:]!^<X
]_:!]^<X
[_:[^!>X
[_:[_!>X
[_:[!^>X
[_:![^>X

La *(>-_:[:)>solución es más larga, pero es más intuitiva de escribir ya que usa la *(...)>plantilla. Esta plantilla se expande <(...)*(...)>cuando se usa con la -lbandera, lo que significa:

<       Move one stack left
(...)   Loop - enter if the top is positive and exit when the top is next positive again
        Since the stack to the left is initially empty, this is a no-op (top is 0)
*       XOR with 1 - top of stack is now 1
(...)   Another loop, this time actually run
>       Move one stack right

Como tal, la *(...)>plantilla significa que se omite el primer bucle pero se ejecuta el segundo. Esto permite que tenga lugar una programación más sencilla, ya que no tenemos que preocuparnos por los efectos del bucle en la otra mitad del programa.

En este caso, el interior del bucle es:

>       Move one stack right, to the input stack
-       Negate top, [-1 b a] -> [-1 b -a]
_       Reversible subtraction, [-1 b -a] -> [-1 b a+b]
:       Swap top two, [-1 b a+b] -> [-1 a+b b]
[       Move one stack left, taking top of stack with you (removing the top b)
:       Swap top two, putting the 1 on this stack on top again

El final >en la plantilla luego nos mueve de regreso a la pila de entrada, donde a+bse emite.

Sp3000
fuente
19

Brain-flak , 6 bytes

({}{})

Pruébalo en línea!

Brain-flak es un lenguaje realmente interesante con dos restricciones importantes.

  1. Los únicos caracteres válidos son corchetes, es decir, cualquiera de estos caracteres:

    (){}[]<>
    
  2. Cada conjunto de paréntesis debe coincidir por completo, de lo contrario, el programa no es válido.

Un conjunto de paréntesis sin nada entre ellos se llama "nilad". Una nilad crea un cierto valor numérico, y se suman todas estas nilads una al lado de la otra. Un conjunto de paréntesis con algo entre ellos se llama "mónada". Una mónada es una función que toma un argumento numérico. Entonces se evalúan los corchetes dentro de una mónada, y ese es el argumento para la mónada. Aquí hay un ejemplo más concreto.

El () nilad es igual a 1. Entonces, el siguiente código de cerebro-flak:

()()()

Se evalúa como 3. La () mónada empuja el valor dentro de ella en la pila global. Entonces lo siguiente

(()()())

empuja un 3. El {}nilad muestra el valor en la parte superior de la pila. Dado que siempre se agregan nilads consecutivos, una cadena de {}sumas de todos los elementos superiores de la pila. Entonces mi código es esencialmente:

push(pop() + pop())
DJMcMayhem
fuente
15

Minecraft 1.10.x, 924 512 bytes

Gracias a @ quat por reducir el blytecount en 48 puntos y el bytecount en 412.

Muy bien, entonces, tomé algunas de las ideas de esta respuesta e hice una versión propia, excepto que esta es capaz de aceptar aportes no negativos. Puede encontrar una versión aquí en formato de bloque de estructura.

grupo

(la nueva versión se ve un poco aburrida por cierto)

Comandos similares a la otra respuesta:

scoreboard objectives add a dummy
execute @e[type=Pig] ~ ~ ~ scoreboard players add m a 1
execute @e[type=Cow] ~ ~ ~ scoreboard players add n a 1
scoreboard players operation n a += m a
tellraw @a {"score":{"name":"n","objective":"a"}}

Para ingresar números, genera una cantidad de vacas y cerdos. Las vacas representarán el valor "n" y los cerdos representarán el valor "m". El sistema de bloques de comando matará progresivamente a las vacas y los cerdos y asignará valores según sea necesario.

Esta respuesta asume que usted está en un mundo sin vacas o cerdos naturales y que los valores almacenados en "n" y "m" se borran en cada corrida.

Addison Crump
fuente
Para enteros negativos, podría usar otros 2 tipos de animales como "neganimals" - 5 caballos podrían representar -5, por ejemplo.
Mego
@Mego Entonces serían cuatro entradas, no 2.
Addison Crump
Seguiría siendo dos entradas: es el equivalente a usar el complemento de dos para números negativos. Formato ligeramente diferente, pero aún una entrada. Al menos, esos son mis dos centavos.
Mego
Es posible que pueda ahorrar en bloques mediante el uso execute @e[type=Pig] ~ ~ ~ scoreboard players add m a 1, por lo que no necesita ninguna forma de reloj.
quat
@quat Ooh. Agradable.
Addison Crump
14

Retina , 42 bytes

\d+
$*
T`1p`-_` |-1+
+`.\b.

^(-)?.*
$1$.&

Pruébalo en línea!

Explicación

Agregar números en unario es la cosa más fácil del mundo, pero una vez que introduce números negativos, las cosas se ponen complicadas ...

\d+
$*

Comenzamos por convertir los números a unarios. Esto se hace haciendo coincidir cada número con \d+y reemplazándolo por $*. Esta es una característica de sustitución específica de Retina. La sintaxis completa es count$*charactere inserta countcopias de character. Ambos pueden omitirse donde está countpredeterminado $&(es decir, la coincidencia misma) y characterpredeterminado 1. Entonces, para cada entrada nobtenemos nunos, y todavía tenemos signos negativos potenciales allí, así como el separador de espacio. Por ejemplo, la entrada 8 -5da:

11111111 -11111

Ahora, para tratar con números negativos, es más fácil usar un -1dígito separado . Lo usaremos -para ese propósito.

T`1p`-_` |-1+

Esta etapa hace dos cosas. Se deshace del espacio, los signos negativos principales, y convierte los 1s después de un signo negativo en -sí mismos. Esto se hace combinando |-1+(es decir, un espacio o un número negativo) y realizando una transliteración en él. La transliteración va de 1pa -_, pero aquí, se pexpande a todos los caracteres ASCII imprimibles y _significa eliminar. Entonces, 1s en esos partidos se convierten en -sy desventajas y espacios se eliminan. Nuestro ejemplo ahora se ve así:

11111111-----
+`.\b.

Esta etapa maneja el caso donde hay un número positivo y uno negativo en la entrada. Si es así, habrá 1s y -s en la cadena y queremos que se cancelen. Esto se hace combinando dos caracteres con un límite de palabras entre ellos (ya que 1s se considera un carácter de palabra y -no lo es), y reemplazando la coincidencia con nada. El le +indica a Retina que haga esto repetidamente hasta que la cadena deje de cambiar.

Ahora nos quedan solo 1 so s o solo - s.

^(-)?.*
$1$.&

Para convertir esto de nuevo a decimal, hacemos coincidir toda la entrada, pero si es posible capturamos un -en grupo 1. 1Reescribimos el grupo (para anteponer a -a números negativos) y luego reescribimos la duración de la coincidencia con $.&(también una función de sustitución específica de Retina).

Martin Ender
fuente
2
Esto es muy inteligente.
Mego
Ahora, si solo hubiera una manera fácil de implementar rangeen Retina. Lo he intentado algunas veces, pero los negativos son un dolor.
mbomb007
¿Se necesitan más de 40 bytes para agregar dos números en este idioma?
dkudriavtsev
2
@DmitryKudriavtsev bien, Retina no tiene concepto de números ...
Martin Ender
@DmitryKudriavtsev, y eso es solo números enteros ...
msh210
14

Dominó , 38,000 bytes o 37 fichas

Esto se crea en Tabletop Simulator . Aquí hay un video y aquí está el archivo . Es un medio sumador estándar, compuesto por una andpuerta para el 2^1valor posicional y una xorpuerta para el 2^0valor posicional.

ingrese la descripción de la imagen aquí

Detalles

  • I / O
    • Inicio : se incluye para mayor claridad (no se cuenta para el total) y es lo que "llama" o "ejecuta" la función. Debe "presionarse" después de que se ingrese la entrada [Amarillo] .
    • Entrada A : se incluye para mayor claridad (no se cuenta para el total) y se 'presiona' para indicar 1ay no se presiona para 0 [Verde] .
    • Entrada B : se incluye para mayor claridad (no se cuenta hacia el total) y se 'presiona' para indicar 1ay no se presiona para 0 [Azul] .
    • Salida : se cuenta en el total. Estas fichas de dominó declaran la suma. La izquierda es 2^1y la derecha es 2^0 [Negro] .
  • Prensado
    • Para dar entrada o iniciar la cadena, genera la canica de metal
    • Establezca la fuerza de elevación en 100%
    • Levanta la canica por encima del dominó deseado
    • Deja caer la canica
Fruta no lineal
fuente
1
... ¿cómo?
dkudriavtsev
44
@Mendeleev Una vez que tenga todas las puertas lógicas binarias , todo lo demás se ubica en su lugar xD.
NonlinearFruit
10

Haskell, 3 bytes

(+)

Los paréntesis están aquí porque debe ser una función de prefijo. Esto es lo mismo que tomar una sección de la función +, pero no se aplican argumentos. También funciona en una amplia gama de tipos, como vectores, matrices, números complejos, flotantes, dobles, racionales y, por supuesto, enteros implementados correctamente.

Como se trata de Haskell, aquí se explica cómo hacerlo a nivel de tipo. Esto se hará en tiempo de compilación en lugar de tiempo de ejecución:

-- This *type* represents Zero
data Zero
-- This *type* represents any other number by saying what number it is a successor to.
-- For example: One is (Succ Zero) and Two is (Succ (Succ Zero))
data Succ a

-- a + b = c, if you have a and b, you can find c, and if you have a and c you can find b (This gives subtraction automatically!)
class Add a b c | a b -> c, a c -> b

-- 0 + n = n 
instance Add Zero n n
-- If (a + b = c) then ((a + 1) + b = (c + 1))
instance (Add a b c) => Add (Succ a) b (Succ c)

Código adaptado de Haskell Wiki

Lazersmoke
fuente
3
Dato
curioso
10

Mathematica, 4 2 bytes

Tr

Tachado 4 sigue siendo regular 4 ... Tr aplicado a una lista unidimensional toma la suma de los elementos de dicha lista.

LegionMammal978
fuente
9

dc, 2 bytes

+f

Agrega los dos primeros elementos en la pila (previamente extraídos de stdin), luego volca el contenido de la pila stdout.

EDITAR: Tras una consideración adicional, parece que hay varias formas en que esto podría implementarse, dependiendo del comportamiento de E / S deseado.

+        # adds top two items and pushes on stack
+n       # adds top two and prints it, no newline, popping it from stack
+dn      # ditto, except leaves result on stack
??+      # takes two inputs from stdin before adding, leaving sum on stack

Supongo que la forma más completa para la suma sería esta:

??+p     # takes two inputs, adds, 'peeks'
         #  (prints top value with newline and leaves result on stack)

¡Espere! ¡Se pueden tomar dos números en la misma línea, separados por un espacio! Esto nos da:

?+p
Joe
fuente
No puedo ver cómo usar el primer ejemplo +f, dc -e "?+p"funciona bien aquí.
Jasen
1
@Jasen La +fversión funciona si ya ha puesto (exactamente dos) números en la pila. Realmente no sabía si dcse suponía que era std(in|out)la E / S o la pila. En retrospectiva, esa fue la opción menos sensata para colocar en la parte superior de la publicación. : /
Joe
las reglas dicen que stack está bien hasta donde puedo decir,
Jasen
9

Lenguaje de programación Shakespeare , 155 152 bytes

.
Ajax,.
Ford,.
Act I:.
Scene I:.
[Enter Ajax and Ford]
Ajax:
Listen to thy heart
Ford:
Listen to THY heart!You is sum you and I.Open thy heart
[Exeunt]

Sin golf:

Summing Two Numbers in Verona.

Romeo, a numerical man.
Juliet, his lover and numerical counterpart.

Act I: In which Italian addition is performed.

Scene I: In which our two young lovers have a short chat.

[Enter Romeo and Juliet]

Romeo:
  Listen to thy heart.

Juliet:
  Listen to THY heart! Thou art the sum of thyself and I. Open thy heart.

[Exeunt]

Estoy usando el compilador SPL de drsam94 para compilar esto. Probar:

$ python splc.py sum.spl > sum.c
$ gcc sum.c -o sum.exe
$ echo -e "5\n16" | ./sum
21
Cobre
fuente
8

Brachylog , 2 bytes

+.

Espera una lista con los dos números como entrada

Alternativamente, si quieres la respuesta a STDOUT:

+w
Fatalizar
fuente
7

JavaScript (ES6), 9 bytes

a=>b=>a+b
Patrick Roberts
fuente
No creo que una función anidada cuente como una función de dos entradas en javascript
orgulloso haskeller
44
@proudhaskeller sí, lo hace
Patrick Roberts
1
Este también funciona en C #.
Grax32
7

PHP, 20 bytes

Sorprendentemente corto esta vez:

<?=array_sum($argv);

Se ejecuta desde la línea de comandos, como:

$ php sum.php 1 2
insertusernamehere
fuente
Su script también acepta, php sum.php 1 2 3 4 5 6así que no estoy 100% seguro de que eso esté bien.
timmyRS
@timmyRS El envío debe funcionar para un formato de entrada específico: dos enteros. No creo que deba manejar otras entradas también.
insertusernamehere
¿Qué pasa si el nombre del archivo fuente comienza con un dígito? :)
Alex Howansky
@AlexHowansky Psssssssst: no se lo digas a nadie. ;) Esta es la peculiaridad, cuando se ejecuta desde un archivo. Todavía puede ejecutarlo usando la -rbandera, entonces ya no es un problema.
insertusernamehere
7

Cheddar, 3 bytes

(+)

Esta es una característica genial de Cheddar llamada "operadores funcionalizados". El crédito por esta idea va para @ CᴏɴᴏʀO'Bʀɪᴇɴ.

Aquí hay más ejemplos de operadores funcionalizados:

(+)(1,2) // 3
(/)(6,2) // 3
(-)(5)   // -5
Downgoat
fuente
6

Python, 11 3 bytes

sum

int.__add__

Un simple operador especial.

Monja permeable
fuente
6

Geometry Dash - 15 objetos

Finalmente hecho.
15 objetos no son mucho, pero todavía fue una pesadilla hacer esto (especialmente debido a los números negativos).

ingrese la descripción de la imagen aquí

Como tendría que insertar 15 imágenes aquí para ver cómo reproducir esto, acabo de subir el nivel. El ID de nivel es 5216804. La descripción le indica cómo ejecutarlo y puede copiarlo ya que es copiable.

Explicación:

El disparador superior izquierdo (Conteo instantáneo 2) verificó si el primer agregado fue 0. Si lo fue, luego verificó si el segundo fue positivo o negativo. Si fue positivo, transfirió el valor del segundo sumando a la suma (estilo BF, usando bucles) y si fuera negativo, haría lo mismo.

La razón por la que necesitamos verificar si el segundo suma es positivo o negativo es que tendríamos que restar uno del segundo sumando y agregar uno a la suma o sumar al segundo sumando y restar uno de la suma respectivamente.

Si el primer sumando no es cero, prueba si es positivo o negativo usando el proceso anterior. Después de una iteración en el ciclo while, prueba para ver si el primer sumando es cero y si lo es, realiza el proceso descrito al comienzo de la explicación.

Dado que Geometry Dash es notablemente similar a BF, podría hacer una solución BF a partir de esto.

MilkyWay90
fuente
5

MATL, 1 byte

s

Acepta una matriz de dos enteros como entrada y los suma. Si bien el programa simple de +también funciona, eso ya se ha mostrado para otros idiomas.

Pruébalo en línea

Suever
fuente
5

Perl 5.10, 8 bytes

Los dos números para agregar deben estar en 2 líneas separadas para que este funcione:

say<>+<>

Prueba este aquí.

Uno con entrada en la misma línea ( 14 + 1 bytes para -a marca )

say$F[0]+$F[1]

Pruébalo aquí!

Uno con entrada en la misma línea ( 19 + 1 bytes para -a marca )

map{$s+=$_}@F;say$s

Prueba este aquí.

Otra, cambiando el separador predeterminado array ( 19 + 1 bytes para -a bandera así)

$"="+";say eval"@F"

Prueba este aquí!

Paul Picard
fuente
2
Hola, otro buen ejemplo (si esto terminará siendo un desafío de catálogo) es el método descrito por Dennis en esta publicación: codegolf.stackexchange.com/q/32884 (ab) usando la -pbandera.
Dom Hastings
En lugar de say$F[0]+$F[1], say pop()+popfunciona (probado en Strawberry 5.20.2 con -E) y le ahorra un byte.
msh210
5

Fuzzy Octo Guacamole , 1 byte

a

Una función que toma entradas desde la parte superior de la pila y las salidas empujando a la pila.

Ejemplo que se ejecuta en REPL:

>>> 8 9 :
[8,9]
>>> a :
17
Rɪᴋᴇʀ
fuente
5

PowerShell v2 +, 17 bytes

$args-join'+'|iex

Toma la entrada como dos argumentos de línea de comando separados, que se rellenan previamente en la matriz especial $args. Formamos una cadena con el -joinoperador al concatenarlos junto con un +en el medio, luego canalizamos esa cadena a Invoke-Expression(similar a eval).


Gracias a @DarthTwon por recordarme que cuando se trata de programas tan mínimos, existen múltiples métodos para tomar datos, todos al mismo número de bytes.

$args[0]+$args[1]
param($a,$b)$a+$b

PowerShell no es nada si no es flexible.

AdmBorkBork
fuente
1
Sí, solo te estoy acosando aquí: P Respuestas alternativas: $args[0]+$args[1]yparam($a,$b)$a+$b
ThePoShWolf
5

> <> , 7 6 3 bytes

+n;

Intérprete en línea

O pruébelo en TIO con la bandera -v.

Pruébalo en línea

Emigna
fuente
Como la pregunta le permite definir una función, creo que un simple +sería suficiente: sacaría dos números de la pila y volvería a colocar el resultado de su suma en la pila. El costo de -vtambién podría evitarse, ya que la lectura de los números podría haberse realizado de antemano con la invocación de la función.
Aaron
1
@ Aaron: Cierto. Pero como esa solución ya está publicada para varios otros idiomas, mantendré esto como un programa completo.
Emigna
1
Pensé que la bandera v sería un máximo de +1 byte, pero de cualquier manera podría usar el intérprete fishlanguage.com y su total sería de 3 bytes (no necesita -v).
Redstarcoder
@redstarcoder: Todos siempre especifican la bandera como 3 bytes para peces (y 1 byte para todos los demás idiomas). No estoy seguro de por qué es diferente, pero supongo que es por una razón válida.
Emigna
De todos modos, no necesita la bandera si solo usa el intérprete fishlanguage.com. ¿Tienes un enlace al meta? No he visto ningún programa> <> que agregue bytes para usar enteros en la pila inicial (también lo he hecho).
Redstarcoder
5

C, 35 bytes

s(x,y){return y?s(x^y,(x&y)<<1):x;}

Lo que he hecho aquí es la suma definida sin el uso de operadores booleanos o aritméticos. Esto hace recursivamente x los bits de suma por 'xor', y y los bits de acarreo por 'y' hasta que no haya carry. Aquí está la versión sin golf:

int sum(int x,int y){
    if(y==0){
        //anything plus 0 is itself
        return x;
    }
    //if it makes you happier imagine there's an else here
    int sumBits=x^y;
    int carryBits=(x&y)<<1;
    return sum(sumBits,carryBits);
}
Bijan
fuente
¿Por qué no agregas directamente?
Esolanging Fruit
Encontré que para ser aburrido, la versión totalmente golfizada es trivial.
Bijan
"Todas las respuestas deberían mostrar cierto esfuerzo para alcanzar un mejor puntaje. Por ejemplo, las respuestas a los desafíos del código de golf deberían ser lo más breves posible (dentro de las limitaciones del idioma elegido)". (de codegolf.meta.stackexchange.com/a/7073/61384 )
Esolanging Fruit
2
Obviamente pensé en sumar los números, y me esforcé por hacerlo más corto, solo bajo restricciones alternativas. Creo que, dado que esta es una pregunta poco convencional, merece una respuesta poco convencional. Siguiendo esa regla palabra por palabra, no habría ninguna razón para poner una respuesta si alguien ya ha presentado una respuesta más corta. Si coloca su solución python de 20 bytes y alguien ya tiene una versión de 4 bytes, entonces está demostrando que no sabe cómo copiar y pegar. La gente pone soluciones de 20 bytes, porque valoramos la originalidad.
Bijan
1
Se da a entender que es competitivo en el idioma que elija. Sin embargo, después de leer sobre meta, parece que no puedo afirmar que su respuesta es inválida ("Una respuesta puede implementar cualquier algoritmo, incluso si existen los más golfistas"), así que supongo que lo descartaré.
Esolanging Fruit
4

MATLAB, 4 bytes

1 byte eliminado gracias a @LeakyNun

@sum

Esta es una función anónima que toma una matriz y da la suma. Ejemplo de uso:

>> f = @sum
f = 
    @sum
>> f([3 4])
ans =
     7
Luis Mendo
fuente
¿Qué hay de sum?
Leaky Nun
@LeakyNun Gracias, ¡buena idea!
Luis Mendo
43 bytes? xD BTW: pensé que teníamos que tener un programa completo o una función , por lo que diría que solo @sumes una respuesta válida. ¿O hay otro meta consenso?
flawr
@flawr Creo que sí, sí. Pero no pude encontrarlo
Luis Mendo
44
Wooah, te ayudé a reducir de 43 a 4 bytes XD
error
4

GoLScript , 1 byte (no competitivo)

K

Agrega los 2 números superiores en la pila. Eso es.

Ahora cómo empujar ellos en la pila, no tengo idea. No creo que sea posible ... tos @ CᴏɴᴏʀO'Bʀɪᴇɴ tos

Rɪᴋᴇʀ
fuente
Explanation soon to be coming.- Riker 3 de julio de 2016
MD XF
+1 para un lenguaje de juego de la vida.
HighRadioactive
4

Lenguaje de programación de Shakespeare (SPL), 137 135 bytes

Programa completo, golfizado:

.
A.
B.
Act I
Scene I
[Enter A and B]
A: Listen to your heart!
B: Listen to your heart! You are the sum of me and you. Open your heart! 

Y una breve explicación:

----
.                                 <- Title, everything before the first 
                                     full stop is considered as the tittle and treated as a comment
----
A.                                <- Dramatis personae. Here are introduced the characters in the play.
                                     |Characters are treated as variables.   
B.                                <--
----
Act I                             <- Acts and scenes are used to divide a program into smaller
                                     chunks in order to be able to refer to them later.
                                     |
Scene I                           <--
----
[Enter A and B]                   <- Characters on stage in the current scene, which are the              
                                     variables the program will have access to.
----
A: Listen to your heart!          <- Line of code. All of them have the same structure
                                     Variable: code. In this case, the concrete sentence
                                    "Listen to your heart!" reads an input number and stores it
                                     on the character (variable) refered to.
B: Listen to your heart!          <- Same as above 
   You are the sum of me and you. <- Sum the values of itself and the caharacter (variable)
                                     refered to.
   Open your heart!               <- Output the value of the character (value) refered to.

No estoy seguro de que sea lo más corto posible. Consulta la página oficial para más información.

Edición 1: se eliminó el :after Act Iy Scene Iparece que todo lo que está después del número romano se ignora, lo que ahorra 2 bytes.

Ioannes
fuente
55
Esto no es valido. Los personajes deben ser de las obras de Shakespeare y los: s deben estar allí. Además, necesitas una coma después del nombre de cada personaje para una descripción.
Oliver Ni
4

Código de máquina x86_32, 2 bytes

08048540 <add7>:
 8048540:   01 c8                   add    %ecx,%eax

Suponiendo que los dos valores ya están en los registros ecx y eax, la ejecución de la instrucción de agregar agregará los valores de los dos registros y almacenará el resultado en el registro de destino.

Puede ver el programa completo escrito en C y ensamblado en línea aquí . Escribir el contenedor en C hace que sea más fácil proporcionar entradas y hacer pruebas, pero la función de agregar real se puede reducir a estos dos bytes.

davey
fuente
3
Esta no es una función, solo un fragmento. También necesita una retinstrucción (un byte). Y eso supone una convención de llamada personalizada donde eaxse usa como un registro de paso de arg. (La biblioteca de enseñanza de Irvine32 asm hace eso, pero ninguna convención de llamadas estándar para x86-32 o x86-64 hace eso, a diferencia de ARM, donde el registro de valor de retorno r0es también el primer registro de paso de argumentos). Sin embargo, asm funciona, por lo que no necesita cambiarlo a 3 bytes lea (%ecx, %edx), %eax+ 1 byte retpara Microsoft __fastcallo gcc -mregparm.
Peter Cordes
1
Sin embargo, es un desafío interesante para una convención de llamadas de stack-args. popes solo 1 byte, pero esplos modos de direccionamiento relativo necesitan un byte SIB. Por lo tanto, una convención de llamada de pop-call puede pop %ecx(la dirección de retorno), pop %eax/ pop %edx/ add %edx, %eax(2 bytes) / jmp *%ecx(2 bytes) = 7 bytes en total. vs. mov 4(%esp), %eax(4B) / add 8(%esp), %eax(4B) / ret= 9 bytes, o 11 bytes para una versión de ese llamador-pops ret imm16, si lo hice bien. Es 1 byte extra para el SIB con ESP como base, y 1 byte extra para el disp8 en cada entrada.
Peter Cordes