Viết chương trình ngắn nhất lấy một đầu vào (n) từ STDIN (hoặc tương đương) và xuất ra hàm tăng đơn giản với một đối số (x) trả về x + n nhưng hàm phải ở ngôn ngữ khác. Khá đơn giản!

Đây là môn đánh gôn, áp dụng luật bình thường, chương trình ngắn nhất sẽ thắng.

Ví dụ:> <> thành Python (Ungolfed)

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

Đầu vào:

3

Đầu ra:

def i(x):
    return x+3

EDIT: Các hàm ẩn danh và biểu thức lambda được cho phép!

GS2 → K, 2 byte

•+

Điều này in một chức năng ngầm, đơn điệu. Mã nguồn sử dụng mã hóa CP437 . Hãy thử trực tuyến!

Chạy thử nghiệm

$ 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

Làm thế nào nó hoạt động

GS2

• GS2 tự động đọc từ STDIN và đẩy đầu vào trên ngăn xếp.

• • chỉ ra rằng byte tiếp theo là một chuỗi ký tự đơn.

• Trước khi thoát, GS2 in tất cả các mục ngăn xếp.

K

Currying đối số trái là tự động trong K.

Ở đây, n+biến hàm dyadic +thành hàm monadic bằng cách đặt đối số bên trái của nó thành n.

ShapeScript → J, 4 byte

"&+"

Điều này in một động từ ngầm, đơn điệu. Dùng thử trực tuyến: ShapeScript , J

Chạy thử nghiệm

$ 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

Làm thế nào nó hoạt động

ShapeScript

• ShapeScript tự động đọc từ STDIN và đẩy đầu vào trên ngăn xếp.

• "&+" đẩy chuỗi đó trên ngăn xếp.

• Trước khi thoát, ShapeScript in tất cả các mục ngăn xếp.

J

& thực hiện currying đối số.

Ở đây, n&+biến động từ dyadic +thành một động từ đơn âm bằng cách đặt đối số bên trái của nó thành n.

GolfScript → CJam, 4 byte

{+}+

Điều này in một khối mã (chức năng ẩn danh). Dùng thử trực tuyến: GolfScript , CJam

Chạy thử nghiệm

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

Làm thế nào nó hoạt động

GolfScript

• GolfScript tự động đọc từ STDIN và đẩy đầu vào trên ngăn xếp.

• {+} đẩy khối đó lên ngăn xếp.

• + thực hiện nối, trong đó vui vẻ nối một chuỗi và một khối.

• Trước khi thoát, GolfScript in tất cả các mục ngăn xếp.

Camam

{n +}là một khối mã, khi được thực thi, đầu tiên sẽ đẩy nvào ngăn xếp, sau đó thực thi +, sẽ bật hai số nguyên từ ngăn xếp và đẩy tổng của chúng.

BrainF *** sang JavaScript ES6, 57 byte

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

(Giả sử rằng đầu vào bao gồm các ký tự số)

Nói 1337là đầu vào của bạn. Sau đó, điều này sẽ biên dịch thành:

x=>x+1337

Rôto đến K, 2 byte

'+

Cũng có thể nhảy vào bandwagon K.

O đến K, 5 byte

tôi '++ o

Cảm ơn @ kirbyfan64sos

Một phiên bản khác sử dụng các tính năng được thêm vào sau khi thử thách được tạo.

tôi '+

• Được đầu vào, đẩy để xếp
• Đẩy '+' dưới dạng chuỗi
• Nội dung ngăn xếp đầu ra

R đến Julia, 19 byte

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

Điều này đọc một số nguyên từ STDIN bằng cách sử dụng scan()và viết một hàm Julia chưa được đặt tên cho STDOUT bằng cách sử dụng cat(). Hàm Julia đơn giản là x->x+n, nxuất phát từ chương trình R.

Chuyển sang JavaScript ES6, 71 byte

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

Thật vui khi tạo mã Malbolge.

Minecraft 1.8.7 đến K, 7 6 + 33 + 27 + 62 = 129 128 byte

Đây là sử dụng phiên bản đếm byte này .

Khối lệnh (đi từ trái sang phải):

mục tiêu bảng điểm thêm K giả

người chơi bảng điểm đặt JK <input>

Tellraw @a {điểm: {name: "J", mục tiêu: "K"}, thêm: [{text: "+"}]}

Điều này có thể có thể được đánh gôn nhiều hơn một chút, nhưng nó khá đơn giản: tạo một biến Jcó mục tiêu Kvà đặt điểm của nó cho mục tiêu đó (không có STDIN - tôi cho rằng điều này đã đủ gần). Sau đó, sau một đánh dấu, xuất điểm của biến Jcho mục tiêu Ktheo sau là a +. Dễ như ăn bánh.

Nghiêm túc với Python, 15 byte

,"lambda n:n+"+

Dự kiến ​​đầu vào ở dạng chuỗi, nghĩa là "3"

Giải trình:

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

Hãy thử trực tuyến (bạn sẽ phải nhập thủ công đầu vào vì permalinks không thích dấu ngoặc kép)

Toán học đến C #, 22 byte

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

Kết quả đầu ra C # Func<int, int>của hình thức

x=>x+n

rs -> K, 2 byte

/+

Bản thử trực tiếp.

Từ 15 đến APL, 7 5 byte

+z"--

Mã Pyth chỉ đơn giản ghép nối đầu vào ( z) với chuỗi "--". Điều này tạo ra một đoàn tàu đơn nguyên không tên trong APL với hình thức n--, nxuất phát từ Pyth. Khi gọi nó trong APL, (n--)xđối với một số xtính toán đối số n--x = n-(-x) = n+x.

Hãy thử: Pyth , APL

Đã lưu 2 byte nhờ Dennis!

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

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

Đưa đầu vào qua -vcờ, vd

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

và đưa ra một lambda Python, ví dụ lambda x:x+27.

Để nhận phần thưởng, đây là phiên bản đầu vào STDIN cho 30 byte:

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

Chuột vào Ruby, 19 byte

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

Ung dung:

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

Điều này tạo ra một chức năng của Ruby giấu tên của mẫu đơn ->x{x+n}nơi nxuất phát từ chuột.

Haskell to Mathicala, 14 byte

(++"+#&").show

Brainfuck sang Java, 273

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

Kết quả đầu ra một phương pháp như int d(int i){return i+42;}(mà không trông giống như một phương thức Java, nhưng ... Java!)

PHP → JavaScript (ES6), 20 24 byte

Đọc từ STDIN luôn đắt trong PHP. Có vẻ hơi lạ:

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

Nó in x=>x+và đợi đầu vào của người dùng hoàn thành chuỗi, kết thúc bằng hàm JavaScript ẩn danh hoàn chỉnh, vd x=>x+2.

Phiên bản đầu tiên (24 byte )

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

Pyth -> K, 4 byte

+z\+

K thực sự rất dễ lạm dụng ở đây ...

Bản thử trực tiếp.

Python 2 đến CJam, 18 20 byte

Cảm ơn LegionMammal978 đã sửa lỗi chức năng.

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

Python thực hiện một định dạng chuỗi cơ bản. %flà mã cho một float, và vì tôi sẽ không mất bất kỳ byte nào để xử lý các float, tôi đã tiếp tục và làm như vậy.

Câu trả lời của CJam giống như câu trả lời của Golfscript-> CJam. Nó trông giống như thế này:

{7.4+}

hoặc là:

{23+}

Đó là một khối lấy giá trị hàng đầu ra khỏi ngăn xếp, đẩy số đặc biệt, sau đó thêm chúng.

ShellIX đến Haskell, 19 byte

read n;echo "($n+)"

Các chức năng ẩn danh được cho phép, Haskell là một lựa chọn đầu ra tốt với các phần vận hành.

Võng mạc thành Pip , 4 byte

Sử dụng một tệp cho mỗi dòng này + 1 byte hình phạt; hoặc, đặt cả hai dòng trong một tệp và sử dụng -scờ.

$
+_

Khớp với phần cuối của đầu vào $và đặt +_ở đó. Điều này dẫn đến một cái gì đó có dạng 3+_, là một hàm ẩn danh trong Pip.

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

và có thể những người khác

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

Vitsy đến K, 5 byte

\ o / K sẽ được sử dụng rất sớm nếu nó có thể làm điều này.

N '+' Z

hoặc có thể...

N '+' O

Nếu đầu vào được lấy dưới dạng chuỗi (chỉ cho đầu vào 0-9) ...

tôi '+' Z

Tất cả những thứ này, cho đầu vào 2, sẽ xuất ra:

Hơn 2

Lisp nhỏ đến Ceylon , 68 61

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

Tiny Lisp không có đầu vào và đầu ra thực sự - nó chỉ có đánh giá biểu thức. Mã này ở trên tạo ra một chức năng và liên kết nó với u. Sau đó, bạn có thể gọi uvới đối số nnhư thế này : (u 7), sẽ đánh giá giá trị Tiny Lisp này:

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

Đây là biểu thức Ceylon hợp lệ, cho một hàm ẩn danh thêm 7 vào một số nguyên tùy ý.

^{Cảm ơn DLosc đã cải thiện 7 byte.}

JavaScript sang Lambda Tính , 39 byte

(Điều này sử dụng tài liệu được liên kết làm cơ sở.)

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

Nói đầu vào là 5. Sau đó, điều này trở thành:

"λa(5(add a))"

Microscript II sang Javascript ES6, 9 byte

"x=>x+"pF

GNU sed đến C, 46 byte

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

Điều này tạo ra (sau khi đọc một dòng đầu vào) như (q((x)(s 5(s 0 x)))), đánh giá trong Tiny Lisp ((x) (s 5 (s 0 x))), một hàm lấy một đối số x, trừ nó từ 0 và trừ kết quả từ 5. _{(Vâng, đây là cách người ta thêm vào Tiny Lisp , chỉ có một hàm trừ được tích hợp. Tất nhiên, người ta có thể định nghĩa một hàm cộng trước, nhưng điều này sẽ dài hơn.)}

Bạn có thể sử dụng nó như thế này như một chức năng ẩn danh:

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

(Điều này sẽ đánh giá đến 12.)

Hoặc bạn có thể đặt tên cho nó:

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

^{Sửa chữa và gợi ý chơi gôn từ DLosc, tác giả của Tiny Lisp.}

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

Mã này là một hàm ẩn danh tạo ra một hàm VALID PHP và Javascript được gọi anonymous.

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

Khi viết mã này, chỉ Firefox mới triển khai ES6 nativelly (không có cờ và các thứ tương tự).

Mã này sử dụng prompt()chức năng để yêu cầu đầu vào và đầu ra. Firefox hỗ trợ sao chép đầu ra của prompt(), biến đây thành phương thức đầu ra hợp pháp cho Javascript.

Cân nhắc:

• Các ;cuối cùng là cần thiết cho PHP
• Không gian trong return $xđược yêu cầu bởi Javascript
  • Bỏ qua nó sẽ nói rằng return$xkhông xác định
• Tên chức năng là tự động: Tôi không có lựa chọn nào về nó
• Chỉ chọn PHP hoặc chỉ Javascript sẽ chỉ giảm mã trong 1 byte và sẽ giảm một nửa yếu tố vui nhộn
• Có thể làm việc với các ngôn ngữ khác

Câu trả lời cũ (48 byte):

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

Câu trả lời cũ không hợp lệ:

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