编写最短的程序，该程序从STDIN（或等效项）获取一个输入（n），并输出一个带有一个返回x + n的参数（x）的简单递增函数，但该函数必须使用另一种语言。很简单！

这是代码高尔夫球，适用常规规则，最短程序获胜。

示例：> <>到Python（非高尔夫）

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

输入：

3

输出：

def i(x):
    return x+3

编辑：允许匿名函数和lambda表达式！

GS2 →K，2个字节

•+

这将打印出默认的单调函数。源代码使用CP437编码。在线尝试！

测试运行

$ 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

怎么运行的

GS2

• GS2自动从STDIN读取并将输入压入堆栈。

• • 指示下一个字节是单例字符串文字。

• 在退出之前，GS2将打印所有堆栈项目。

ķ

左参数currying在K中是自动的。

在此，通过n+将其二元函数+的left参数设置为，将其转换为一元函数n。

ShapeScript →J，4个字节

"&+"

这会打印一个默认的单调动词。在线尝试：ShapeScript，J

测试运行

$ 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

怎么运行的

ShapeScript

• ShapeScript自动从STDIN读取并将输入推入堆栈。

• "&+" 将该字符串压入堆栈。

• 退出之前，ShapeScript将打印所有堆栈项目。

Ĵ

& 执行参数currying。

在这里，通过n&+将其二元动词+的左参数设置为，将其变成一元动词n。

GolfScript→CJam，4个字节

{+}+

这将打印一个代码块（匿名函数）。在线尝试：GolfScript，CJam

测试运行

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

怎么运行的

高尔夫脚本

• GolfScript自动从STDIN读取并将输入推入堆栈。

• {+} 将该块压入堆栈。

• + 执行级联，愉快地级联字符串和块。

• 退出之前，GolfScript将打印所有堆栈项目。

贾姆

{n +}是一个代码块，执行该代码块时，首先将n其压入堆栈，然后执行+，从堆栈中弹出两个整数并压入它们的和。

BrainF ***至JavaScript ES6，57字节

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

（假设输入由数字字符组成）

说1337是您的意见。然后，将其编译为：

x=>x+1337

转子到K，2个字节

'+

可能还会加入K潮流。

O至K，5个字节

我++

谢谢 @ kirbyfan64sos

创建挑战后添加功能的另一个版本。

我+

• 获取输入，推送到堆栈
• 将“ +”作为字符串插入
• 输出堆栈内容

R to Julia，19个字节

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

这会使用从STDIN中读取一个整数，scan()并使用将未命名的Julia函数写入STDOUT中cat()。Julia函数就是x->x+n，n它来自R程序。

Malbolge到JavaScript ES6，71个字节

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

生成Malbolge代码总是很有趣。

Minecraft 1.8.7至K，7 6 + 33 + 27 + 62 = 129128字节

这是使用此版本的字节计数。

命令块（从左到右）：

计分板目标加K虚拟

计分板球员设置JK <输入>

tellraw @a {得分：{名称：“ J”，目标：“ K”}，附加：[{text：“ +”}]}

可能需要打更多的球，但这很简单：J用目标生成一个变量并将该目标K的得分设置为输入（没有STDIN-我认为这已经足够接近了）。然后，蜱后，输出变量的得分J为目标K，接着一个+。十分简单。

认真对待 Python，15个字节

,"lambda n:n+"+

期望输入为字符串形式，即 "3"

说明：

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

在线尝试（您必须手动输入输入内容，因为永久链接不喜欢引号）

Mathematica至C＃，22个字节

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

输出C＃Func<int, int>形式

x=>x+n

rs-> K，2个字节

/+

现场演示。

Pyth到APL，7个 5字节

+z"--

Pyth代码只是将输入（z）与字符串连接起来"--"。这会在APL中创建一个未命名的单轨火车，其形式为n--，n来自Pyth。在APL中调用该(n--)x参数时x计算n--x = n-(-x) = n+x。

尝试：Pyth，APL

感谢Dennis，节省了2个字节！

> <>到Python，25 + 3 = 28字节

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

通过-v标志接受输入，例如

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

并输出Python lambda，例如lambda x:x+27。

作为奖励，这是30字节的STDIN输入版本：

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

鼠标转Ruby，19个字节

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

取消高尔夫：

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

This creates an unnamed Ruby function of the form ->x{x+n} where n comes from Mouse.

Haskell to Mathematica, 14 bytes

(++"+#&").show

Brainfuck to Java, 273

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

Outputs a method like int d(int i){return i+42;} (which doesn't look like a Java method, but... Java!)

PHP → JavaScript (ES6), 20 24 bytes

Reading from STDIN is always expensive in PHP. It looks a bit strange:

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

It prints x=>x+ and waits for user input to complete the string, terminates with the complete anonymous JavaScript function, e.g. x=>x+2.

First version (24 bytes)

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

Pyth -> K, 4 bytes

+z\+

K is really easy to abuse here...

Live demo.

Python 2 to CJam, 18 20 bytes

Thanks to LegionMammal978 for correcting the functionality.

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

The Python does a basic string format. %f is the code for a float, and since I wouldn't lose any bytes for handling floats, I went ahead and did so.

The CJam is much the same as the Golfscript->CJam answer. It looks something like this:

{7.4+}

or:

{23+}

It's a block that takes the top value off the stack, pushes the special number, then adds them.

POSIX shell to Haskell, 19 bytes

read n;echo "($n+)"

Anonymous functions being allowed, Haskell is a good output choice with the operator sections.

Retina to Pip, 4 bytes

Uses one file for each of these lines + 1 penalty byte; or, put both lines in a single file and use the -s flag.

$
+_

Matches the end of the input with $ and puts +_ there. This results in something of the form 3+_, which is an anonymous function in Pip.

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

and maybe others

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

Vitsy to K, 5 Bytes

\o/ K will be being used very soon if it can do this.

N'+'Z

or maybe...

N'+'O

If the input is taken as a string (only for 0-9 input)...

i'+'Z

All of these, for input 2, will output:

2+

Tiny Lisp to Ceylon, 68 61

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

Tiny Lisp doesn't have real input and output – it just has expression evaluation. This code above creates a function and binds it to u. You can then call u with the argument n like this: (u 7), which will evaluate to this Tiny Lisp value:

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

This is a valid Ceylon expression, for an anonymous function which adds 7 to an arbitrary integer.

^{Thanks to DLosc for an improvement of 7 bytes.}

JavaScript to Lambda Calculus, 39 bytes

(This uses the linked document as a basis.)

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

Say input is 5. Then this becomes:

"λa(5(add a))"

Microscript II to Javascript ES6, 9 bytes

"x=>x+"pF

GNU sed to C, 46 bytes

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

Ceylon to Tiny lisp, 76

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

This produces (after reading a line of input) output like (q((x)(s 5(s 0 x)))), which evaluates in Tiny Lisp to ((x) (s 5 (s 0 x))), a function which takes an argument x, subtracts it from 0, and subtracts the result from 5. _{(Yeah, this is how one adds in Tiny Lisp, there is only a subtraction function build in. Of course, one could define an addition function first, but this would be longer.)}

You can use it like this as an anonymous function:

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

(This will evaluate to 12.)

Or you can give it a name:

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

^{Corrections and Golfing Hints from DLosc, the author of Tiny Lisp.}

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

This code is an anonymous function that creates a VALID PHP and Javascript function called anonymous.

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

As of the writting of this code, only Firefox has implemented ES6 nativelly (without flags and suchs).

This code uses the prompt() function to request input and for output. Firefox supports copying the output of prompt(), making this a legitime output method for Javascript.

Considerations:

• The ; at the end is required for PHP
• The space in return $x is required by Javascript
  • Ignoring it will say that return$x is undefined
• The function name is automatic: I have no choice over it
• Picking only PHP or only Javascript will only reduce the code in 1 byte, and would reduce the fun-factor by half
• May work with other languages

Old answer (48 bytes):

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

Old invalid answer:

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