Escriba el programa más corto que toma una entrada (n) de STDIN (o equivalente) y genera una función de incremento simple con un argumento (x) que devuelve x + n pero la función debe estar en un idioma diferente. ¡Bastante simple!

Este es el código de golf, se aplican reglas normales, el programa más corto gana.

Ejemplo:> <> a Python (Ungolfed)

!v"def i(x):"a"    return x+"ir!
 >l?!;o

Entrada:

3

Salida:

def i(x):
    return x+3

EDITAR: ¡Se permiten funciones anónimas y expresiones lambda!

GS2 → K, 2 bytes

•+

Esto imprime una función tácita y monádica. El código fuente usa la codificación CP437 . Pruébalo en línea!

Prueba de funcionamiento

$ xxd -c 2 -g 1 sum-func.gs2
00000000: 07 2b  .+
$ printf 42 | gs2 sum-func.gs2
42+
$ kona
K Console - Enter \ for help

  (42+) 69
111
  f : 42+
42+
  f 69
111

Cómo funciona

GS2

• GS2 lee automáticamente desde STDIN y empuja la entrada en la pila.

• • indica que el siguiente byte es un literal de cadena singleton.

• Antes de salir, GS2 imprime todos los elementos de la pila.

K

El argumento izquierdo curry es automático en K.

Aquí, n+convierte la función diádica +en una función monádica al establecer su argumento izquierdo en n.

ShapeScript → J, 4 bytes

"&+"

Esto imprime un verbo tácito y monádico. Pruébelo en línea: ShapeScript , J

Prueba de funcionamiento

$ cat sum-func.shape; echo
"&+"
$ printf 42 | shapescript sum-func.shape; echo
42&+
$ j64-804/jconsole.sh 
   42&+ 69
111
   f =: 42&+
   f 69
111

Cómo funciona

ShapeScript

• ShapeScript lee automáticamente desde STDIN y empuja la entrada en la pila.

• "&+" empuja esa cuerda en la pila.

• Antes de salir, ShapeScript imprime todos los elementos de la pila.

J

& realiza argumentos curry.

Aquí, n&+convierte el verbo diádico +en un verbo monádico estableciendo su argumento izquierdo en n.

GolfScript → CJam, 4 bytes

{+}+

Esto imprime un bloque de código (función anónima). Pruébelo en línea: GolfScript , CJam

Prueba de funcionamiento

$ cat sum-func.gs; echo
{+}+
$ printf 42 | golfscript sum-func.gs
{42 +}
$ cjam
> 69 {42 +} ~
111
> {42 +}:F; 69F    
111

Cómo funciona

GolfScript

• GolfScript lee automáticamente desde STDIN y empuja la entrada en la pila.

• {+} empuja ese bloque en la pila.

• + realiza la concatenación, que felizmente concatena una cadena y un bloque.

• Antes de salir, GolfScript imprime todos los elementos de la pila.

CJam

{n +}es un bloque de código que, cuando se ejecuta, primero empuja nla pila, luego se ejecuta +, que saca dos enteros de la pila y empuja su suma.

BrainF *** a JavaScript ES6, 57 bytes

----[-->+++<]>--.[-->+<]>+.+.--[->++<]>.[--->+<]>+++.[,.]

(Asume que la entrada está compuesta de caracteres numéricos)

Decir 1337es su aporte. Entonces, esto se compilaría para:

x=>x+1337

Rotor a K, 2 bytes

'+

También podría subirse al carro K.

O a K, 5 bytes

i '++ o

Gracias a @ kirbyfan64sos

Otra versión que usa características agregadas después de que se creó el desafío.

i '+

• Obtiene entrada, empuja para apilar
• Empuja '+' como una cadena
• Salidas de contenido de la pila

R a Julia, 19 bytes

cat("x->x+",scan())

Esto lee un número entero de STDIN usando scan()y escribe una función de Julia sin nombre en STDOUT usando cat(). La función de Julia es simplemente x->x+n, de dónde nviene el programa R.

Malbolge a JavaScript ES6, 71 bytes

('&%@9]!~}43Wyxwvutsr)Mon+HGi4~fBBdR->=_]:[875t4rT}0/Pf,d*((II%GEE!Y}Az

Siempre es divertido generar código Malbolge.

Minecraft 1.8.7 a K, 7 6 + 33 + 27 + 62 = 129 128 Bytes

Esto está usando esta versión de conteo de bytes .

Bloques de comando (de izquierda a derecha):

los objetivos del marcador agregan K ficticio

los jugadores del marcador establecen JK <input>

tellraw @a {puntaje: {nombre: "J", objetivo: "K"}, extra: [{texto: "+"}]}

Probablemente esto se pueda jugar un poco más, pero es bastante simple: generar una variable Jcon el objetivo Ky establecer su puntaje para ese objetivo en la entrada (no hay STDIN, pensé que esto estaba lo suficientemente cerca). Luego, después de una marca, genera el puntaje de la variable Jpara el objetivo Kseguido de a +. Pan comido.

En serio a Python, 15 bytes

,"lambda n:n+"+

Espera que la entrada esté en forma de cadena, es decir "3"

Explicación:

,: read value from input
"lambda n:n+": push this literal string
+: concatenate top two values on stack

Pruébelo en línea (deberá ingresar manualmente la entrada porque a los enlaces permanentes no les gustan las comillas)

Mathematica a C #, 22 bytes

"x=>x+"<>InputString[]

Emite un C # Func<int, int>de formulario

x=>x+n

rs -> K, 2 bytes

/+

Demo en vivo.

Pyth a APL, 7 5 bytes

+z"--

El código Pyth simplemente concatena la entrada ( z) con la cadena "--". Esto crea un tren monádico sin nombre en APL con el formulario n--, de donde nproviene Pyth. Al llamarlo en APL, (n--)xpara algunos argumentos xcomputa n--x = n-(-x) = n+x.

Prueba: Pyth , APL

¡Ahorré 2 bytes gracias a Dennis!

> <> a Python, 25 + 3 = 28 bytes

"v+x:x adbmal
o/?(3l
;>~n

Toma entrada a través de la -vbandera, por ejemplo

py -3 fish.py add.fish -v 27

y genera una Python lambda, por ejemplo lambda x:x+27.

Para obtener una bonificación, aquí hay una versión de entrada STDIN para 30 bytes:

i:0(?v
x+"r~/"lambda x:
o;!?l<

Mouse to Ruby, 19 bytes

?N:"->x{x+"N.!"}"$

Sin golf:

? N:       ~ Read an integer from STDIN, store in N
"->x{x+"   ~ Write that string to STOUT
N. !       ~ Write N
"}"$       ~ Close bracket, end of program

Esto crea una función Ruby sin nombre del formulario de ->x{x+n}donde nproviene el mouse.

Haskell a Mathematica, 14 bytes

(++"+#&").show

Brainfuck a Java, 273

+ [-----> +++++. +++++. ++++++. [----> ++++. + [-> ++++ .- [- > +++ -.----- [-> +++. +++++. ++++++. [----> ++++ .- [---> ++ -. [-----> ++ -. [-> +++. --------- .-------------. [---> + ---. +. ---. ---- .- [-> +++++ -.- [---> ++ -. [-----> +++., [. ,] + [---------> +++ .- [---> +++.

Emite un método como int d(int i){return i+42;}(que no se parece a un método Java, pero ... ¡Java!)

PHP → JavaScript (ES6), 20 24 bytes

Leer desde STDIN siempre es costoso en PHP. Se ve un poco extraño:

x=>x+<?fgets(STDIN);

Imprime x=>x+y espera la entrada del usuario para completar la cadena, termina con la función completa de JavaScript anónimo, por ejemplo x=>x+2.

Primera versión (24 bytes )

<?='x=>x+'.fgets(STDIN);

Pyth -> K, 4 bytes

+z\+

K es realmente fácil de abusar aquí ...

Demo en vivo.

Python 2 a CJam, 18 20 bytes

Gracias a LegionMammal978 por corregir la funcionalidad.

print"{%f+}"%input()

Python tiene un formato de cadena básico. %fes el código para un flotante, y como no perdería ningún byte para manejar flotadores, seguí adelante y lo hice.

El CJam es muy similar a la respuesta Golfscript-> CJam. Se ve algo como esto:

{7.4+}

o:

{23+}

Es un bloque que toma el valor superior de la pila, empuja el número especial y luego los agrega.

POSIX shell a Haskell, 19 bytes

read n;echo "($n+)"

Al permitir las funciones anónimas, Haskell es una buena opción de salida con las secciones del operador.

Retina a Pip , 4 bytes

Utiliza un archivo para cada una de estas líneas + 1 byte de penalización; o, ponga ambas líneas en un solo archivo y use la -sbandera.

$
+_

Coincide con el final de la entrada $y los pone +_allí. Esto da como resultado algo de la forma 3+_, que es una función anónima en Pip.

Bash → C / C ++ / C # / Java, 33 bytes

y tal vez otros

echo "int f(int a){return a+$1;}"

Vitsy a K, 5 bytes

\ o / K se usará muy pronto si puede hacer esto.

N '+' Z

o tal vez...

N '+' O

Si la entrada se toma como una cadena (solo para la entrada 0-9) ...

i '+' Z

Todos estos, para la entrada 2, generarán:

2+

Diminuto Lisp a Ceilán , 68 61

(d u(q((n)(c(q(Integer x))(c(q =>)(c(c(q x+)(c n()))()))))))

Tiny Lisp no tiene entradas y salidas reales, solo tiene evaluación de expresiones. Este código anterior crea una función y la vincula u. Luego puede llamar ucon el argumento de nesta manera:, (u 7)que evaluará este valor de Tiny Lisp:

((Integer x) => (x+ 7))

Esta es una expresión válida de Ceilán, para una función anónima que agrega 7 a un entero arbitrario.

^{Gracias a DLosc por una mejora de 7 bytes.}

JavaScript para cálculo Lambda , 39 bytes

(Esto utiliza el documento vinculado como base).

alert((x=>`λa(${x}(add a))`)(prompt()))

Decir entrada es 5. Entonces esto se convierte en:

"λa(5(add a))"

Microscript II a Javascript ES6, 9 bytes

"x=>x+"pF

GNU sed a C, 46 bytes

sed -r 's/^([0-9]+)$/f(int x){return x+\1;}/'

Ceylon a Tiny lisp , 76

shared void run(){print("(q((x)(s ``process.readLine()else""``(s 0 x))))");}

Esto produce (después de leer una línea de entrada) como (q((x)(s 5(s 0 x)))), que se evalúa en Tiny Lisp ((x) (s 5 (s 0 x))), una función que toma un argumento x, lo resta de 0 y resta el resultado de 5. _{(Sí, así es como se agrega Tiny Lisp , solo hay una función de resta incorporada. Por supuesto, primero se podría definir una función de suma, pero sería más larga).}

Puede usarlo así como una función anónima:

((q((x)(s 5(s 0 x)))) 7)

(Esto evaluará a 12.)

O puedes darle un nombre:

(d p5 (q((x)(s 5(s 0 x)))))
(p5 7)

^{Correcciones y pistas de golf de DLosc, el autor de Tiny Lisp.}

Javascript (ES6)> PHP / Javascript, 38 48 47 bytes

Este código es una función anónima que crea una función PHP y Javascript VÁLIDA llamada anonymous.

P=prompt;P(Function('$x',`return $x+${P()};`));

A partir de la redacción de este código, solo Firefox ha implementado ES6 de forma nativa (sin banderas y demás).

Este código usa la prompt()función para solicitar entrada y salida. Firefox admite la copia de la salida de prompt(), lo que lo convierte en un método de salida legítimo para Javascript.

Consideraciones:

• Al ;final se requiere para PHP
• El espacio en return $xes requerido por Javascript
  • Ignorarlo dirá que return$xno está definido
• El nombre de la función es automático: no tengo otra opción
• Elegir solo PHP o solo Javascript solo reducirá el código en 1 byte y reduciría el factor diversión a la mitad
• Puede trabajar con otros idiomas.

Respuesta anterior (48 bytes):

alert(Function('$x',`return $x+${prompt()};`));

Antigua respuesta inválida:

y=>''+Function('$x',`return $x+${y};`)