Schreiben Sie das kürzeste Programm, das eine Eingabe (n) von STDIN (oder einer Entsprechung) nimmt und eine einfache Inkrementierungsfunktion mit einem Argument (x) ausgibt, das x + n zurückgibt, die Funktion muss jedoch in einer anderen Sprache vorliegen. Ziemlich einfach!

Dies ist Code-Golf, es gelten die normalen Regeln, die kürzesten Programmgewinne.

Beispiel:> <> zu Python (Ungolfed)

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

Eingang:

3

Ausgabe:

def i(x):
    return x+3

EDIT: Anonyme Funktionen und Lambda-Ausdrücke sind erlaubt!

GS2 → K, 2 Bytes

•+

Dies gibt eine implizite, monadische Funktion aus. Der Quellcode verwendet die CP437- Codierung. Probieren Sie es online!

Testlauf

$ 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

Wie es funktioniert

GS2

• GS2 liest automatisch von STDIN und schiebt die Eingabe auf den Stapel.

• • Gibt an, dass das nächste Byte ein Singleton-Zeichenfolgenliteral ist.

• Vor dem Beenden druckt GS2 alle Stapelobjekte.

K

Das Curry des linken Arguments erfolgt automatisch in K.

Hier wird n+die dyadische Funktion +in eine monadische Funktion umgewandelt, indem das linke Argument auf gesetzt wird n.

ShapeScript → J, 4 Bytes

"&+"

Dies gibt ein stillschweigendes, monadisches Verb aus. Probieren Sie es online aus: ShapeScript , J

Testlauf

$ 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

Wie es funktioniert

ShapeScript

• ShapeScript liest automatisch aus STDIN und überträgt die Eingabe auf den Stapel.

• "&+" schiebt die Saite auf den Stapel.

• Vor dem Beenden druckt ShapeScript alle Stapelelemente.

J

& führt Argumente aus.

Hier wird n&+das dyadische Verb +in ein monadisches Verb umgewandelt, indem das linke Argument auf gesetzt wird n.

GolfScript → CJam, 4 Bytes

{+}+

Dies druckt einen Codeblock (anonyme Funktion). Probieren Sie es online aus: GolfScript , CJam

Testlauf

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

Wie es funktioniert

GolfScript

• GolfScript liest automatisch aus STDIN und schiebt die Eingabe auf den Stapel.

• {+} schiebt diesen Block auf den Stapel.

• + Führt eine Verkettung durch, die eine Zeichenfolge und einen Block glücklich verkettet.

• Vor dem Beenden druckt GolfScript alle Stapelelemente.

CJam

{n +}ist ein Codeblock, der bei seiner Ausführung zuerst nauf den Stapel drückt und dann ausführt. Dabei +werden zwei Ganzzahlen aus dem Stapel gezogen und ihre Summe gedrückt.

BrainF *** auf JavaScript ES6, 57 Bytes

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

(Angenommen, die Eingabe besteht aus numerischen Zeichen.)

Sprich 1337ist dein Input. Dann würde dies kompilieren, um:

x=>x+1337

Rotor zu K, 2 Bytes

'+

Könnte auch in den K-Zug einsteigen.

O bis K, 5 Bytes

i '++ o

Vielen Dank an @ kirbyfan64sos

Eine weitere Version mit Funktionen, die hinzugefügt wurden, nachdem die Herausforderung erstellt wurde.

i '+

• Ruft Eingaben ab, drückt zum Stapeln
• Drückt '+' als Zeichenfolge
• Gibt Stapelinhalte aus

R bis Julia, 19 Bytes

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

Dies liest eine Ganzzahl aus STDIN mit scan()und schreibt eine unbenannte Julia-Funktion mit in STDOUT cat(). Die Julia-Funktion ist einfach x->x+n, woher ndas R-Programm kommt.

Malbolge zu JavaScript ES6, 71 Bytes

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

Es macht immer Spaß, Malbolge-Code zu generieren.

Minecraft 1.8.7 bis K, 7 6 + 33 + 27 + 62 = 129 128 Bytes

Dies verwendet diese Version der Bytezählung .

Befehlsblöcke (von links nach rechts):

Anzeiger Ziele hinzufügen K Dummy

Anzeiger Spieler setzen JK <input>

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

Dies könnte wahrscheinlich ein bisschen mehr Golf gespielt werden, aber es ist ziemlich einfach: Erzeugen Sie eine Variable Jmit dem Ziel Kund setzen Sie die Punktzahl für dieses Ziel auf die Eingabe (es gibt kein STDIN - ich dachte, das wäre nah genug). Geben Sie dann nach einem Häkchen die Punktzahl der Variablen Jfür das Ziel aus, Kgefolgt von a +. Kinderleicht.

Ernsthaft zu Python, 15 Bytes

,"lambda n:n+"+

Erwartet, dass die Eingabe in String-Form erfolgt, d. H "3"

Erläuterung:

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

Probieren Sie es online aus (Sie müssen die Eingabe manuell eingeben, da die Permalinks keine Anführungszeichen mögen)

Mathematica zu C #, 22 Bytes

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

Gibt ein C # -Formular Func<int, int>aus

x=>x+n

rs -> K, 2 Bytes

/+

Live-Demo.

Pyth zu APL, 7 5 Bytes

+z"--

Der Pyth-Code verkettet einfach die Eingabe ( z) mit der Zeichenfolge "--". Dadurch wird in APL ein unbenannter monadischer Zug mit der Form erstellt n--, ndie von Pyth stammt. Beim Aufruf in APL wird (n--)xfür einige Argumente xgerechnet n--x = n-(-x) = n+x.

Versuchen Sie: Pyth , APL

2 Bytes gespart dank Dennis!

> <> zu Python, 25 + 3 = 28 Bytes

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

Übernimmt Eingaben über die -vFlagge, z

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

und gibt ein Python-Lambda aus, z lambda x:x+27.

Als Bonus gibt es hier eine STDIN-Eingabeversion für 30 Bytes:

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

Maus zu Ruby, 19 Bytes

?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

Dadurch wird eine unbenannte Ruby-Funktion des Formulars erstellt, ->x{x+n}das nvon der Maus stammt.

Haskell zu Mathematica, 14 Bytes

(++"+#&").show

Brainfuck zu Java, 273

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

Gibt eine Methode wie int d(int i){return i+42;}(die nicht wie eine Java-Methode aussieht , aber ... Java!) Aus.

PHP → JavaScript (ES6), 20 bis 24 Bytes

Das Lesen von STDIN ist in PHP immer teuer. Es sieht ein bisschen seltsam aus:

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

Es druckt x=>x+und wartet auf Benutzereingaben, um die Zeichenfolge zu vervollständigen, endet mit der vollständigen anonymen JavaScript-Funktion, z x=>x+2.

Erste Version (24 Bytes )

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

Pyth -> K, 4 Bytes

+z\+

K ist hier wirklich leicht zu missbrauchen ...

Live-Demo.

Python 2 bis CJam, 18 bis 20 Bytes

Vielen Dank an LegionMammal978 für die Korrektur der Funktionalität.

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

Das Python macht ein grundlegendes Zeichenkettenformat. %fist der Code für einen Float, und da ich keine Bytes für den Umgang mit Floats verlieren würde, ging ich voran und tat es.

Der CJam ist ähnlich wie die Golfscript-> CJam-Antwort. Es sieht ungefähr so ​​aus:

{7.4+}

oder:

{23+}

Es ist ein Block, der den höchsten Wert vom Stapel nimmt, die spezielle Zahl drückt und sie dann addiert.

POSIX-Shell zu Haskell, 19 Bytes

read n;echo "($n+)"

Da anonyme Funktionen zulässig sind, ist Haskell eine gute Wahl für die Ausgabe in den Operatorbereichen.

Retina zu Pip , 4 Bytes

Verwendet eine Datei für jede dieser Zeilen + 1 Strafbyte; Oder setzen Sie beide Zeilen in eine einzelne Datei und verwenden Sie das -sFlag.

$
+_

Stimmt mit dem Ende der Eingabe überein $und setzt +_dort. Daraus ergibt sich etwas von der Form 3+_, die in Pip eine anonyme Funktion ist.

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

und vielleicht auch andere

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

Vitsy zu K, 5 Bytes

\ o / K wird in Kürze verwendet, wenn dies möglich ist.

N '+' Z

oder vielleicht...

N '+' O

Wenn die Eingabe als Zeichenfolge verwendet wird (nur für 0-9-Eingabe) ...

i '+' Z

Alle diese Befehle für Eingabe 2 geben Folgendes aus:

2+

Kleine Lisp zu Ceylon , 68 61

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

Tiny Lisp hat keine echte Eingabe und Ausgabe, sondern nur eine Ausdrucksbewertung. Dieser obige Code erstellt eine Funktion und bindet sie an u. Sie können dann rufen Sie umit dem Argument nwie folgt aus : (u 7), die auf diese Tiny Lisp Wert auswertet:

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

Dies ist ein gültiger Ceylon-Ausdruck für eine anonyme Funktion, die einer beliebigen Ganzzahl eine 7 hinzufügt.

^{Vielen Dank an DLosc für eine Verbesserung von 7 Bytes.}

JavaScript zu Lambda Calculus , 39 Bytes

(Hierbei wird das verknüpfte Dokument als Basis verwendet.)

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

Angenommen, die Eingabe ist 5. Dann wird dies:

"λa(5(add a))"

Microscript II auf Javascript ES6, 9 Bytes

"x=>x+"pF

GNU auf C, 46 Bytes gesetzt

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

Ceylon bis Tiny Lisp , 76

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

Dies erzeugt (nach dem Lesen einer Eingabezeile) eine Ausgabe wie (q((x)(s 5(s 0 x)))), die in Tiny Lisp zu ausgewertet wird ((x) (s 5 (s 0 x))), eine Funktion, die ein Argument nimmt x, es von 0 subtrahiert und das Ergebnis von 5 subtrahiert. _{(Ja, so fügt man in Tiny Lisp hinzu.) , es ist nur eine Subtraktionsfunktion eingebaut. Natürlich könnte man zuerst eine Additionsfunktion definieren, aber das wäre länger.)}

Sie können es wie folgt als anonyme Funktion verwenden:

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

(Dies wird zu 12 ausgewertet.)

Oder Sie können ihm einen Namen geben:

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

^{Korrekturen und Golftipps von DLosc, dem Autor von Tiny Lisp.}

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

Dieser Code ist eine anonyme Funktion, die eine GÜLTIGE PHP- und Javascript-Funktion mit dem Namen erstellt anonymous.

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

Zum Zeitpunkt der Erstellung dieses Codes hat nur Firefox ES6 nativ implementiert (ohne Flags und solche).

Dieser Code verwendet die prompt()Funktion, um die Eingabe und Ausgabe anzufordern. Firefox unterstützt das Kopieren der Ausgabe von prompt()und macht dies zu einer legitimen Ausgabemethode für Javascript.

Überlegungen:

• Das ;am Ende wird für PHP benötigt
• Der Platz in return $xwird von Javascript benötigt
  • Wird es ignoriert, heißt das, dass return$xes undefiniert ist
• Der Funktionsname ist automatisch: Ich habe keine Wahl darüber
• Wenn Sie nur PHP oder nur Javascript auswählen, wird der Code nur in 1 Byte reduziert und der Spaßfaktor um die Hälfte reduziert
• Kann mit anderen Sprachen arbeiten

Alte Antwort (48 Bytes):

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

Alte ungültige Antwort:

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