Écrivez le programme le plus court qui prend une entrée (n) de STDIN (ou équivalent) et génère une fonction d'incrémentation simple avec un argument (x) qui renvoie x + n mais la fonction doit être dans une langue différente. Assez simple!

Il s'agit de code-golf, les règles normales s'appliquent, les gains de programme les plus courts.

Exemple:> <> vers Python (non golfé)

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

Contribution:

3

Sortie:

def i(x):
    return x+3

EDIT: Les fonctions anonymes et les expressions lambda sont autorisées!

GS2 → K, 2 octets

•+

Cela imprime une fonction tacite et monadique. Le code source utilise l' encodage CP437 . Essayez-le en ligne!

Essai

$ 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

Comment ça marche

GS2

• GS2 lit automatiquement depuis STDIN et pousse l'entrée sur la pile.

• • indique que l'octet suivant est un littéral de chaîne singleton.

• Avant de quitter, GS2 imprime tous les éléments de la pile.

K

Le currying des arguments de gauche est automatique en K.

Ici, n+transforme la fonction dyadique en fonction +monadique en définissant son argument de gauche sur n.

ShapeScript → J, 4 octets

"&+"

Cela imprime un verbe tacite et monadique. Essayez-le en ligne: ShapeScript , J

Essai

$ 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

Comment ça marche

ShapeScript

• ShapeScript lit automatiquement à partir de STDIN et pousse l'entrée sur la pile.

• "&+" pousse cette chaîne sur la pile.

• Avant de quitter, ShapeScript imprime tous les éléments de la pile.

J

& effectue le curry d'argument.

Ici, n&+transforme le verbe dyadique en verbe +monadique en définissant son argument de gauche sur n.

GolfScript → CJam, 4 octets

{+}+

Ceci imprime un bloc de code (fonction anonyme). Essayez-le en ligne: GolfScript , CJam

Essai

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

Comment ça marche

GolfScript

• GolfScript lit automatiquement à partir de STDIN et pousse l'entrée sur la pile.

• {+} pousse ce bloc sur la pile.

• + effectue la concaténation, qui concatène avec bonheur une chaîne et un bloc.

• Avant de quitter, GolfScript imprime tous les éléments de la pile.

CJam

{n +}est un bloc de code qui, une fois exécuté, pousse d'abord nsur la pile, puis s'exécute +, ce qui extrait deux entiers de la pile et pousse leur somme.

BrainF *** vers JavaScript ES6, 57 octets

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

(Suppose que l'entrée est composée de caractères numériques)

Dites 1337est votre entrée. Ensuite, cela se compilerait pour:

x=>x+1337

Rotor à K, 2 octets

'+

Autant sauter dans le train en marche.

O à K, 5 octets

i '++ o

Merci à @ kirbyfan64sos

Une autre version utilisant des fonctionnalités ajoutées après la création du défi.

je '+

• Obtient une entrée, pousse pour empiler
• Pousse '+' comme chaîne
• Affiche le contenu de la pile

R à Julia, 19 octets

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

Cela lit un entier depuis STDIN en utilisant scan()et écrit une fonction Julia sans nom dans STDOUT en utilisant cat(). La fonction Julia est simplement x->x+n, d'où nvient le programme R.

Malbolge vers JavaScript ES6, 71 octets

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

C'est toujours amusant de générer du code Malbolge.

Minecraft 1.8.7 à K, 7 6 + 33 + 27 + 62 = 129 octets

Ceci utilise cette version du comptage d'octets .

Blocs de commande (allant de gauche à droite):

les objectifs du tableau de bord ajoutent un mannequin K

les joueurs du tableau de bord définissent JK <input>

tellraw @a {score: {nom: "J", objectif: "K"}, extra: [{text: "+"}]}

Cela pourrait probablement être joué un peu plus, mais c'est assez simple: générer une variable Javec l'objectif Ket définir son score pour cet objectif à l'entrée (il n'y a pas de STDIN - je pensais que c'était assez proche). Ensuite, après une coche, sortez le score de la variable Jpour l'objectif Ksuivi de a +. Peasy facile.

Sérieusement pour Python, 15 octets

,"lambda n:n+"+

Attend que l'entrée soit sous forme de chaîne, c'est-à-dire "3"

Explication:

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

Essayez-le en ligne (vous devrez entrer manuellement l'entrée car les permaliens n'aiment pas les guillemets)

Mathematica en C #, 22 octets

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

Sort un C # Func<int, int>de formulaire

x=>x+n

rs -> K, 2 octets

/+

Démo en direct.

Pyth à APL, 7 5 octets

+z"--

Le code Pyth concatène simplement l'entrée ( z) avec la chaîne "--". Cela crée un train monadique sans nom en APL avec la forme n--, d'où nvient Pyth. Lors de son appel dans APL, (n--)xpour certains arguments, xcalcule n--x = n-(-x) = n+x.

Essayez: Pyth , APL

Enregistré 2 octets grâce à Dennis!

> <> à Python, 25 + 3 = 28 octets

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

Prend entrée via le -vdrapeau, par exemple

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

et génère un lambda Python, par exemple lambda x:x+27 .

Pour un bonus, voici une version d'entrée STDIN pour 30 octets:

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

Souris à Ruby, 19 octets

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

Non 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

Cela crée une fonction Ruby sans nom du formulaire d' ->x{x+n}où nprovient Mouse.

Haskell à Mathematica, 14 octets

(++"+#&").show

Brainfuck à Java, 273

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

Génère une méthode comme int d(int i){return i+42;}(qui ne ressemble pas à une méthode Java, mais ... Java!)

PHP → JavaScript (ES6), 20 24 octets

La lecture depuis STDIN coûte toujours cher en PHP. Cela semble un peu étrange:

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

Il imprime x=>x+et attend l'entrée de l'utilisateur pour terminer la chaîne, se termine par la fonction JavaScript anonyme complète, par exemplex=>x+2 .

Première version (24 octets )

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

Pyth -> K, 4 octets

+z\+

K est vraiment facile à abuser ici ...

Démo en direct.

Python 2 à CJam, 18 20 octets

Merci à LegionMammal978 pour avoir corrigé la fonctionnalité.

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

Le Python fait un format de chaîne de base. %fest le code d'un flotteur, et comme je ne perdrais aucun octet pour la gestion des flottants, je suis allé de l'avant et je l'ai fait.

Le CJam est sensiblement le même que la réponse Golfscript-> CJam. Cela ressemble à ceci:

{7.4+}

ou:

{23+}

C'est un bloc qui prend la valeur la plus élevée de la pile, pousse le numéro spécial, puis les ajoute.

Shell POSIX vers Haskell, 19 octets

read n;echo "($n+)"

Les fonctions anonymes étant autorisées, Haskell est un bon choix de sortie avec les sections opérateur.

Rétine à Pip , 4 octets

Utilise un fichier pour chacune de ces lignes + 1 octet de pénalité; ou, mettez les deux lignes dans un seul fichier et utilisez l' -sindicateur.

$
+_

Correspond à la fin de l'entrée avec $et la place +_. Il en résulte quelque chose de la forme 3+_, qui est une fonction anonyme dans Pip.

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

et peut-être d'autres

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

Vitsy à K, 5 octets

\ o / K sera utilisé très bientôt s'il peut le faire.

N '+' Z

ou peut-être...

N '+' O

Si l'entrée est prise comme une chaîne (uniquement pour une entrée 0-9) ...

i '+' Z

Tous ces éléments, pour l'entrée 2, produiront:

2+

Tiny Lisp à Ceylan , 68 61

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

Tiny Lisp n'a pas de véritable entrée et sortie - il a juste une évaluation d'expression. Ce code ci-dessus crée une fonction et la lie à u. Vous pouvez ensuite appeler uavec l'argument ncomme ceci:, (u 7)qui évaluera cette valeur Tiny Lisp:

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

Il s'agit d'une expression de Ceylan valide, pour une fonction anonyme qui ajoute 7 à un entier arbitraire.

^{Merci à DLosc pour une amélioration de 7 octets.}

JavaScript pour Lambda Calculus , 39 octets

(Cela utilise le document lié comme base.)

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

Dites que l'entrée est 5. Cela devient alors:

"λa(5(add a))"

Microscript II à Javascript ES6, 9 octets

"x=>x+"pF

GNU sed à C, 46 octets

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

Ceylan à Tiny lisp , 76

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

Cela produit (après avoir lu une ligne d'entrée) une sortie comme (q((x)(s 5(s 0 x)))), qui évalue en Tiny Lisp à ((x) (s 5 (s 0 x))), une fonction qui prend un argument x, le soustrait de 0 et soustrait le résultat de 5. _{(Ouais, c'est comme ça qu'on ajoute dans Tiny Lisp , il n'y a qu'une fonction de soustraction intégrée. Bien sûr, on pourrait d'abord définir une fonction d'addition, mais ce serait plus long.)}

Vous pouvez l'utiliser comme ceci comme fonction anonyme:

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

(Cela évaluera à 12.)

Ou vous pouvez lui donner un nom:

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

^{Corrections and Golfing Hints de DLosc, l'auteur de Tiny Lisp.}

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

Ce code est une fonction anonyme qui crée une fonction PHP et Javascript VALIDE appelée anonymous.

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

Au moment de la rédaction de ce code, seul Firefox a implémenté ES6 nativelly (sans drapeaux et autres).

Ce code utilise la prompt()fonction pour demander une entrée et une sortie. Firefox prend en charge la copie de la sortie de prompt(), ce qui en fait une méthode de sortie légitime pour Javascript.

Considérations:

• Le ;à la fin est requis pour PHP
• L'espace en return $xest requis par Javascript
  • L'ignorer dira que ce return$xn'est pas défini
• Le nom de la fonction est automatique: je n'ai pas le choix
• Choisir uniquement PHP ou Javascript ne réduira le code qu'en 1 octet et réduira de moitié le facteur plaisir
• Peut fonctionner avec d'autres langues

Ancienne réponse (48 octets):

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

Ancienne réponse invalide:

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