Scrivi il programma più breve che accetta un input (n) da STDIN (o equivalente) e genera una semplice funzione di incremento con un argomento (x) che restituisce x + n ma la funzione deve essere in una lingua diversa. Abbastanza semplice!

Si tratta di code-golf, si applicano le normali regole, il programma più corto vince.

Esempio:> <> in Python (Ungolfed)

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

Ingresso:

3

Produzione:

def i(x):
    return x+3

EDIT: sono consentite funzioni anonime ed espressioni lambda!

GS2 → K, 2 byte

•+

Ciò stampa una tacita funzione monadica. Il codice sorgente utilizza la codifica CP437 . Provalo online!

Prova

$ 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

Come funziona

GS2

• GS2 legge automaticamente da STDIN e invia l'input nello stack.

• • indica che il byte successivo è una stringa singleton letterale.

• Prima di uscire, GS2 stampa tutti gli oggetti dello stack.

K

Il curriculum argomento sinistro è automatico in K.

Qui, n+trasforma la funzione diadica +in una funzione monadica impostando il suo argomento sinistro su n.

ShapeScript → J, 4 byte

"&+"

Questo stampa un verbo tacito e monadico. Provalo online: ShapeScript , J

Prova

$ 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

Come funziona

ShapeScript

• ShapeScript legge automaticamente da STDIN e invia l'input nello stack.

• "&+" spinge quella stringa in pila.

• Prima di uscire, ShapeScript stampa tutti gli elementi dello stack.

J

& esegue il curriculum degli argomenti.

Qui, n&+trasforma il verbo diadico +in un verbo monadico impostando il suo argomento sinistro su n.

GolfScript → CJam, 4 byte

{+}+

Questo stampa un blocco di codice (funzione anonima). Provalo online: GolfScript , CJam

Prova

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

Come funziona

GolfScript

• GolfScript legge automaticamente da STDIN e invia l'input nello stack.

• {+} spinge quel blocco in pila.

• + esegue la concatenazione, che concatena felicemente una stringa e un blocco.

• Prima di uscire, GolfScript stampa tutti gli elementi dello stack.

CJam

{n +}è un blocco di codice che, una volta eseguito, preme prima nsullo stack, quindi viene eseguito +, il che estrae due numeri interi dallo stack e ne spinge la somma.

Cervello da *** a JavaScript ES6, 57 byte

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

(Suppone che l'input sia composto da caratteri numerici)

Di 1337'il tuo contributo. Quindi, questo verrebbe compilato per:

x=>x+1337

Rotore a K, 2 byte

'+

Potrebbe anche saltare sul carrozzone K.

Da O a K, 5 byte

i '++ o

Grazie a @ kirbyfan64sos

Un'altra versione che utilizza funzionalità aggiunte dopo la creazione della sfida.

I '+

• Ottiene l'input, spinge per impilare
• Spinge '+' come stringa
• Emette i contenuti dello stack

R a Julia, 19 byte

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

Questo legge un numero intero da STDIN usando scan()e scrive una funzione Julia senza nome su STDOUT usando cat(). La funzione Julia è semplicemente x->x+n, da dove nproviene il programma R.

Malbolge a JavaScript ES6, 71 byte

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

È sempre divertente generare codice Malbolge.

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

Questo sta usando questa versione del conteggio dei byte .

Blocchi di comando (da sinistra a destra):

gli obiettivi del tabellone segnapunti aggiungono K manichino

i giocatori del tabellone segnano JK <input>

tellraw @a {punteggio: {nome: "J", obiettivo: "K"}, extra: [{text: "+"}]}

Probabilmente questo potrebbe essere giocato un po 'di più, ma è abbastanza semplice: generare una variabile Jcon l'obiettivo Ke impostare il punteggio per quell'obiettivo sull'input (non c'è STDIN - ho pensato che fosse abbastanza vicino). Quindi, dopo un segno di spunta, genera il punteggio della variabile Jper l'obiettivo Kseguito da a +. Vai tranquillo.

Seriamente a Python, 15 byte

,"lambda n:n+"+

Si aspetta che l'input sia in forma di stringa, ad es "3"

Spiegazione:

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

Provalo online (dovrai inserire manualmente l'input perché ai permalink non piacciono le virgolette)

Mathematica a C #, 22 byte

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

Emette un C # Func<int, int>del modulo

x=>x+n

rs -> K, 2 byte

/+

Dimostrazione dal vivo.

Pyth in APL, 7 5 byte

+z"--

Il codice Pyth concatena semplicemente l'input ( z) con la stringa "--". Questo crea un treno monadico senza nome in APL con la forma n--, da dove nproviene Pyth. Quando lo si chiama in APL, (n--)xper alcuni argomenti viene xcalcolato n--x = n-(-x) = n+x.

Prova: Pyth , APL

Salvato 2 byte grazie a Dennis!

> <> in Python, 25 + 3 = 28 byte

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

Accetta input tramite -vflag, ad es

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

e genera un lambda Python, ad es lambda x:x+27.

Per un bonus, ecco una versione di input STDIN per 30 byte:

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

Mouse per Ruby, 19 byte

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

Ungolfed:

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

Questo crea una funzione Ruby senza nome della forma da ->x{x+n}cui nproviene il mouse.

Haskell a Mathematica, 14 byte

(++"+#&").show

Brainfuck a Java, 273

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

Emette un metodo simile int d(int i){return i+42;}(che non sembra un metodo Java, ma ... Java!)

PHP → JavaScript (ES6), 20 24 byte

Leggere da STDIN è sempre costoso in PHP. Sembra un po 'strano:

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

Stampa x=>x+e attende l'input dell'utente per completare la stringa, termina con la funzione JavaScript anonima completa, ad es x=>x+2.

Prima versione (24 byte )

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

Pyth -> K, 4 byte

+z\+

K è davvero facile abusare qui ...

Dimostrazione dal vivo.

Python 2 a CJam, 18 20 byte

Grazie a LegionMammal978 per aver corretto la funzionalità.

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

Python esegue un formato di stringa di base. %fè il codice per un float, e dato che non perderei byte per la gestione dei float, sono andato avanti e l'ho fatto.

La CJam è molto simile alla risposta Golfscript-> CJam. Sembra qualcosa del genere:

{7.4+}

o:

{23+}

È un blocco che toglie il valore più alto dallo stack, spinge il numero speciale, quindi li aggiunge.

Shell POSIX per Haskell, 19 byte

read n;echo "($n+)"

Essendo consentite funzioni anonime, Haskell è una buona scelta di output con le sezioni dell'operatore.

Retina in Pip , 4 byte

Utilizza un file per ciascuna di queste righe + 1 byte di penalità; oppure, inserisci entrambe le righe in un singolo file e usa il -sflag.

$
+_

Abbina la fine dell'input con $e inserisce +_lì. Ciò si traduce in qualcosa del modulo 3+_, che è una funzione anonima in Pip.

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

e forse altri

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

Da Vitsy a K, 5 byte

\ o / K verrà utilizzato molto presto se può farlo.

N '+' Z

o forse...

N '+' O

Se l'input viene considerato come una stringa (solo per input 0-9) ...

i '+' Z

Tutti questi, per l'ingresso 2, produrranno:

2+

Piccolo Lisp a Ceylon , 68 61

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

Tiny Lisp non ha input e output reali, ha solo una valutazione delle espressioni. Questo codice sopra crea una funzione e la lega a u. È quindi possibile chiamare ucon l'argomento nin questo modo: (u 7)che valuterà a questo valore piccolo Lisp:

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

Questa è un'espressione di Ceylon valida, per una funzione anonima che aggiunge 7 a un numero intero arbitrario.

^{Grazie a DLosc per un miglioramento di 7 byte.}

JavaScript a Lambda Calculus , 39 byte

(Questo utilizza il documento collegato come base.)

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

Dire input è 5. Quindi questo diventa:

"λa(5(add a))"

Da Microscript II a Javascript ES6, 9 byte

"x=>x+"pF

GNU sed a C, 46 byte

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))))");}

Questo produce (dopo aver letto una riga di input) output come (q((x)(s 5(s 0 x)))), che valuta in Tiny Lisp ((x) (s 5 (s 0 x))), una funzione che prende un argomento x, lo sottrae da 0 e sottrae il risultato da 5. _{(Sì, ecco come si aggiunge in Tiny Lisp , c'è solo una funzione di sottrazione integrata. Naturalmente, si potrebbe prima definire una funzione di addizione, ma questa sarebbe più lunga.)}

Puoi usarlo in questo modo come una funzione anonima:

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

(Questo valuterà a 12.)

Oppure puoi dargli un nome:

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

^{Correzioni e suggerimenti sul golf di DLosc, l'autore di Tiny Lisp.}

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

Questo codice è una funzione anonima che crea una funzione VALID PHP e Javascript chiamata anonymous.

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

A partire dalla stesura di questo codice, solo Firefox ha implementato ES6 nativelly (senza flag e simili).

Questo codice utilizza la prompt()funzione per richiedere input e output. Firefox supporta la copia dell'output di prompt(), rendendolo un metodo di output legale per Javascript.

considerazioni:

• Alla ;fine è richiesto per PHP
• Lo spazio in return $xè richiesto da Javascript
  • Ignorarlo dirà che return$xnon è definito
• Il nome della funzione è automatico: non ho scelta
• Scegliere solo PHP o solo Javascript ridurrà il codice in 1 byte e ridurrebbe la metà del fattore divertimento
• Può funzionare con altre lingue

Vecchia risposta (48 byte):

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

Vecchia risposta non valida:

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