Bir girişi (n) STDIN'den (veya eşdeğeri) alan en kısa programı yazın ve x + n döndüren tek bir argümanla (x) basit bir artış işlevi çıktı ancak işlev farklı bir dilde olmalıdır. Oldukça basit!

Bu kod golf, normal kurallar uygulanır, en kısa program kazanır.

Örnek:> <> to Python (Ungolfed)

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

Giriş:

3

Çıktı:

def i(x):
    return x+3

EDIT: Anonim işlevler ve lambda ifadeleri izin verilir!

GS2 → K, 2 bayt

•+

Bu, sade, monadik bir işlev basar. Kaynak kod CP437 kodlamasını kullanır . Çevrimiçi deneyin!

Test sürüşü

$ 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

Nasıl çalışır

GS2

• GS2 otomatik olarak STDIN'den okur ve girişi yığına iter.

• • bir sonraki baytın bir singleton string değişmezi olduğunu gösterir.

• Çıkmadan önce GS2 tüm yığın öğelerini yazdırır.

K

Sol argüman kurutma işlemi K'da otomatik

Burada, n+ikili +argümanını sol argümanını ayarlayarak monadik bir işleve dönüştürür n.

ShapeScript → J, 4 bayt

"&+"

Bu, sade, monadik bir fiili basar. Çevrimiçi deneyin: ShapeScript , J

Test sürüşü

$ 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

Nasıl çalışır

ShapeScript

• ShapeScript otomatik olarak STDIN'den okur ve girişi yığına iter.

• "&+" bu dizgiyi yığına iter.

• Çıkmadan önce, ShapeScript tüm yığın öğelerini yazdırır.

J

& Argümanları köretmeyi gerçekleştirir.

Burada dyadik fiili, sol argümanını ayarlayarak monadik bir fiile n&+çevirir .+n

GolfScript → CJam, 4 bayt

{+}+

Bu bir kod bloğu yazdırır (anonim işlev). Çevrimiçi deneyin: GolfScript , CJam

Test sürüşü

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

Nasıl çalışır

GolfScript

• GolfScript otomatik olarak STDIN'den okur ve girişi yığına iter.

• {+} bu bloğu yığına iter.

• + mutlu bir şekilde bir dize ve bir blok birleştiren birleştirme gerçekleştirir.

• Çıkmadan önce GolfScript tüm yığın öğelerini yazdırır.

CJam

{n +}yürütüldüğü zaman, önce nyığına iterek , sonra yığından +iki tam sayı çıkartan ve toplamlarını iten bir kod bloğudur .

BrainF *** - JavaScript ES6, 57 bayt

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

(Girişin sayısal karakterlerden oluştuğunu varsayar)

Diyelim ki 1337girişiniz. Sonra, bu derlemek için olurdu:

x=>x+1337

Rotor-K, 2 bayt

'+

K bandagonuna girebilir.

O ila K, 5 bayt

i ++ o

@ Kirbyfan64sos teşekkürler

Mücadeleden sonra eklenen özellikleri kullanan başka bir sürüm oluşturuldu.

i +

• Girdiyi alır, istiflemeye zorlar
• Bir dizge olarak '+' işaretini basar
• Yığın içeriğini çıkarır

Julia'ya R, 19 bayt

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

Bu, kullanarak STDIN'dan bir tamsayı okur scan()ve adlandırılmamış bir Julia işlevini kullanarak STDOUT'a yazar cat(). Julia fonksiyonu basitçe x->x+n, nR programından geliyor.

Malbolge JavaScript ES6 için, 71 bayt

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

Malbolge kodunu oluşturmak her zaman eğlencelidir.

Minecraft 1.8.7 ila K, 7 6 + 33 + 27 + 62 = 129 128 Bayt

Bu bayt sayma sürümünü kullanıyor .

Komut blokları (soldan sağa doğru):

puan tahtası hedefleri K kukla ekleyin

çetele oyuncuları JK ayarladı <giriş>

tellraw @a {score: {name: "J", amaç: "K"}, ek: [{text: "+"}]}

Bu muhtemelen biraz daha golf oynayabilir, ancak oldukça basit: JAmaç ile bir değişken oluşturun Kve bu amaç için puanını girdi olarak ayarlayın (STDIN yok - bunun yeterince yakın olduğunu düşündüm). Sonra, bir onay işaretinden sonra, değişkenin puanını, ardından Jgelen hedef için çıktı alın . Basit.K+

Ciddiyetle Python, 15 bayt

,"lambda n:n+"+

Girdiyi dize biçiminde, yani "3"

Açıklama:

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

Çevrimiçi deneyin (girişin elle girmesi gerekir, çünkü permalink'ler tırnaklardan hoşlanmaz)

Mathematica - C #, 22 bayt

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

C # Func<int, int>formunu verir

x=>x+n

rs -> K, 2 bayt

/+

Canlı demo.

APL'ye Pyth, 7 5 bayt

+z"--

Pyth kodu, input ( z) komutunu dizeyle birleştirir "--". Bu form ile APL içinde isimsiz bir monadic treni yaratır n--, nPyth geliyor. APL'de çağırırken, (n--)xbazı argümanlar için xhesaplar n--x = n-(-x) = n+x.

Deneyin: Pyth , APL

Dennis sayesinde 2 bayt kaydedildi!

> <> to Python, 25 + 3 = 28 bayt

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

-vBayrakla giriş yapar , örneğin

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

ve bir Python lambda çıkarır, örn lambda x:x+27.

Bonus için 30 baytlık bir STDIN giriş sürümü:

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

Fare Ruby, 19 bayt

?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

Bu formun ismi açıklanmayan Yakut işlevi oluşturur Fare geliyor.->x{x+n}n

Mathematica Haskell, 14 bayt

(++"+#&").show

Java'ya brainfuck, 273

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

Böyle bir yöntemin Çıkışlar int d(int i){return i+42;}(gelmez bak ... Java Java yöntemine gibi ama!)

PHP → JavaScript (ES6), 20 24 bayt

STDIN'den okumak PHP'de her zaman pahalıdır. Biraz garip görünüyor:

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

x=>x+Dizeyi tamamlamak için kullanıcı girişini yazdırır ve bekler, isimsiz JavaScript işlevinin tamamı ile sona erer, örn x=>x+2.

İlk sürüm (24 bayt )

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

Pyth -> K, 4 bayt

+z\+

K burada suistimal etmek gerçekten çok kolay ...

Canlı demo.

Python 2 ila CJam, 18 20 bayt

İşlevselliğin düzeltilmesi için LegionMammal978'e teşekkürler.

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

Python, basit bir dize formatı yapar. %ffloat kodudur ve float işlemlerinde bayt kaybetmediğim için devam ettim ve yaptım.

CJam, Golfscript-> CJam'ın cevabıyla aynı. Bu gibi bir şey görünüyor:

{7.4+}

veya:

{23+}

Bu, yığındaki en yüksek değeri alan, özel sayıyı iten, sonra da ekleyen bir bloktur.

Haskell'e POSIX kabuğu, 19 bayt

read n;echo "($n+)"

Anonim işlevlere izin veriliyor, Haskell operatör bölümleri ile iyi bir çıktı seçimi.

Retina için Pip , 4 bayt

Bu satırların her biri için bir dosya kullanır + 1 penaltı bayt; veya her iki satırı da tek bir dosyaya yerleştirin ve -sbayrağı kullanın .

$
+_

Girişin bitişini ile $eşleştirir ve koyar +_. Bu 3+_, Pip'deki isimsiz bir fonksiyon olan formda bir şeyle sonuçlanır .

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

ve belki başkaları

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

Vitsy to K, 5 Bayt

Bunu yapabiliyorsa \ o / K çok yakında kullanılacaktır.

N '+', Z

ya da belki...

N '+' O

Giriş bir dizge olarak alınırsa (sadece 0-9 giriş için) ...

i '+', Z

Bunların tümü, giriş 2 için, çıktısı:

2+

Minik Lisp a Seylan , 68 61

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

Tiny Lisp'in gerçek girdi ve çıktısı yok - sadece ifade değerlendirmesi var. Yukarıdaki kod bir fonksiyon yaratır ve onu bağlar u. Daha sonra şöyle bir uargümanla arayabilirsiniz n: (u 7)ki bu, Tiny Lisp değerini şöyle değerlendirecek:

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

Bu, isteğe bağlı bir tam sayıya 7 ekleyen adsız bir işlev için geçerli bir Ceylon ifadesidir.

^{7 baytlık bir gelişme için DLosc sayesinde.}

Lambda Matematik , 39 bayt için JavaScript

(Bu bağlantılı belgeyi temel olarak kullanır.)

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

Diyelim ki giriş 5. Sonra bu olur:

"λa(5(add a))"

Mikroscript II den Javascript ES6, 9 bayt

"x=>x+"pF

GNU C'ye, 46 bayt

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

Seylan için Minik lisp , 76

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

Bu gibi çıkış (giriş hattı okuduktan sonra) üretir (q((x)(s 5(s 0 x))))olduğu küçük Lisp'te değerlendirir, ((x) (s 5 (s 0 x)))bir argüman alan bir fonksiyon x0 ila çıkarır bunu, ve 5 sonucunu çıkarır _{bir küçük Lisp'te ekler ne Evet, bu ( , yalnızca yerleşik bir çıkarma işlevi vardır. Tabii ki, önce bir ekleme işlevi tanımlanabilir, ancak bu daha uzun olur.)}

Bunu anonim bir işlev olarak kullanabilirsiniz:

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

(Bu 12'ye göre değerlendirilecektir.)

Ya da bir isim verebilirsin:

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

^{Tiny Lisp’in yazarı olan DLosc’tan yapılan Düzeltmeler ve Golf İpuçları.}

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

Bu kod adı verilen bir VALID PHP ve Javascript fonksiyonu yaratan isimsiz bir fonksiyondur anonymous.

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

Bu kodun yazılmasından itibaren, yalnızca Firefox ES6 yerelini (bayraklar ve benzeri şeyler olmadan) uygulamıştır.

Bu kod prompt()girdi istemek ve çıktı almak için işlevi kullanır . Firefox çıktısının kopyalanmasını destekler prompt(), bunu Javascript için yasal bir çıktı yöntemi yapar.

hususlar:

• ;Sonunda PHP için gereklidir
• Boşluk return $xJavascript tarafından isteniyor
  • Görmezden gelmek return$x, tanımsız olduğunu söyleyecektir.
• İşlev adı otomatiktir: Üzerinde başka seçeneğim yok
• Yalnızca PHP veya yalnızca Javascript seçmek, kodu yalnızca 1 baytta azaltır ve eğlence faktörünü yarıya indirir
• Diğer dillerle çalışabilir

Eski cevap (48 bayt):

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

Eski geçersiz cevap:

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