Escreva o programa mais curto que recebe uma entrada (n) de STDIN (ou equivalente) e gera uma função de incremento simples com um argumento (x) que retorna x + n, mas a função deve estar em um idioma diferente. Bem simples!

Isso é código-golfe, aplicam-se regras normais, o menor programa vence.

Exemplo:> <> para Python (Ungolfed)

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

Entrada:

3

Saída:

def i(x):
    return x+3

EDIT: Funções anônimas e expressões lambda são permitidas!

GS2 → K, 2 bytes

•+

Isso imprime uma função tácita e monádica. O código fonte usa a codificação CP437 . Experimente online!

Execução de teste

$ 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

Como funciona

GS2

• O GS2 lê automaticamente de STDIN e empurra a entrada na pilha.

• • indica que o próximo byte é uma literal de string singleton.

• Antes de sair, o GS2 imprime todos os itens da pilha.

K

Currying à esquerda do argumento é automático em K.

Aqui, n+transforma a função diádica +em uma função monádica, definindo o argumento esquerdo para n.

ShapeScript → J, 4 bytes

"&+"

Isso imprime um verbo tácito e monádico. Experimente online: ShapeScript , J

Execução de teste

$ 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

Como funciona

ShapeScript

• O ShapeScript lê automaticamente do STDIN e empurra a entrada na pilha.

• "&+" coloca essa string na pilha.

• Antes de sair, o ShapeScript imprime todos os itens da pilha.

J

& executa currying de argumento.

Aqui, n&+transforma o verbo díádico +em um verbo monádico, definindo o argumento esquerdo para n.

GolfScript → CJam, 4 bytes

{+}+

Isso imprime um bloco de código (função anônima). Experimente online: GolfScript , CJam

Execução de teste

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

Como funciona

GolfScript

• O GolfScript lê automaticamente do STDIN e empurra a entrada na pilha.

• {+} empurra esse bloco na pilha.

• + executa concatenação, que felizmente concatena uma string e um bloco.

• Antes de sair, o GolfScript imprime todos os itens da pilha.

CJam

{n +}é um bloco de código que, quando executado, primeiro empurra na pilha e, em seguida +, é executado , que exibe dois números inteiros da pilha e empurra sua soma.

BrainF *** para JavaScript ES6, 57 bytes

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

(Supõe que a entrada seja composta de caracteres numéricos)

Diga 1337é a sua entrada. Em seguida, isso seria compilado para:

x=>x+1337

Rotor para K, 2 bytes

'+

Poderia muito bem pular na onda K.

O a K, 5 bytes

eu ++ o

Obrigado a @ kirbyfan64sos

Outra versão usando os recursos adicionados após a criação do desafio.

i '+

• Obtém entrada, empurra para empilhar
• Empurra '+' como uma string
• Conteúdo da pilha de saídas

R para Julia, 19 bytes

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

Isso lê um número inteiro de STDIN usando scan()e grava uma função Julia sem nome em STDOUT usando cat(). A função Julia é simples x->x+n, de onde nvem o programa R.

Malbolge para JavaScript ES6, 71 bytes

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

É sempre divertido gerar código Malbolge.

Minecraft 1.8.7 a K, 7 6 + 33 + 27 + 62 = 129 128 bytes

Isso está usando esta versão da contagem de bytes .

Blocos de comando (da esquerda para a direita):

objetivos do placar adicionar K manequim

jogadores do placar definem JK <input>

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

Provavelmente isso poderia ser um pouco mais complicado, mas é bastante simples: gere uma variável Jcom o objetivo Ke defina sua pontuação para esse objetivo como entrada (não há STDIN - imaginei que isso era próximo o suficiente). Depois de um tick, produza a pontuação da variável Jpara o objetivo, Kseguida de a +. Mole-mole.

Sério para Python, 15 bytes

,"lambda n:n+"+

Espera que a entrada esteja na forma de sequência, ou seja, "3"

Explicação:

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

Experimente on-line (você precisará inserir manualmente a entrada, porque os links permanentes não gostam de aspas)

Mathematica para C #, 22 bytes

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

Gera um C # Func<int, int>do formulário

x=>x+n

rs -> K, 2 bytes

/+

Demonstração ao vivo.

Pitão para APL, 7 5 bytes

+z"--

O código Pyth simplesmente concatena a entrada ( z) com a string "--". Isso cria um trem monádico sem nome no APL com o formulário n--, de onde nvem Pyth. Ao chamá-lo no APL, (n--)xalguns argumentos são xcomputados n--x = n-(-x) = n+x.

Experimente: Pyth , APL

Economizou 2 bytes graças a Dennis!

> <> para Python, 25 + 3 = 28 bytes

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

Recebe entrada através da -vbandeira, por exemplo

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

e gera um lambda Python, por exemplo lambda x:x+27.

Para um bônus, aqui está uma versão de entrada STDIN para 30 bytes:

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

Mouse para 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

Isso cria uma função Ruby sem nome do formulário de ->x{x+n}onde nvem o Mouse.

Haskell para Mathematica, 14 bytes

(++"+#&").show

Brainfuck para Java, 273

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

Produz um método como int d(int i){return i+42;}(que não se parece com um método Java, mas ... Java!)

PHP → JavaScript (ES6), 20 24 bytes

Ler do STDIN é sempre caro em PHP. Parece um pouco estranho:

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

Ele imprime x=>x+e aguarda a entrada do usuário para completar a sequência, termina com a função JavaScript anônima completa, por exemplo x=>x+2.

Primeira versão (24 bytes )

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

Pitão -> K, 4 bytes

+z\+

K é realmente fácil de abusar aqui ...

Demonstração ao vivo.

Python 2 a CJam, 18 20 bytes

Obrigado a LegionMammal978 por corrigir a funcionalidade.

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

O Python cria um formato básico de string. %fé o código para um float e, como não perderia bytes por manipular floats, fui adiante e o fiz.

O CJam é praticamente o mesmo que a resposta Golfscript-> CJam. Parece algo como isto:

{7.4+}

ou:

{23+}

É um bloco que retira o valor máximo da pilha, pressiona o número especial e os adiciona.

Shell POSIX para Haskell, 19 bytes

read n;echo "($n+)"

Sendo permitidas funções anônimas, o Haskell é uma boa opção de saída nas seções do operador.

Retina para Pip , 4 bytes

Usa um arquivo para cada uma dessas linhas + 1 byte de penalidade; ou, coloque as duas linhas em um único arquivo e use o -ssinalizador.

$
+_

Corresponde ao final da entrada com $e coloca +_lá. Isso resulta em algo do formulário 3+_, que é uma função anônima no Pip.

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

e talvez outros

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

Vitsy para K, 5 bytes

\ o / K estará sendo usado muito em breve, se puder fazer isso.

N '+' Z

ou talvez...

N '+' O

Se a entrada for tomada como uma sequência (apenas para a entrada 0-9) ...

i '+' Z

Tudo isso, para a entrada 2, produzirá:

2+

Lisp pequeno para Ceilão , 68 61

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

O Lisp minúsculo não possui entrada e saída reais - apenas possui avaliação de expressão. Este código acima cria uma função e a vincula u. Você pode chamar ucom o argumento ncomo este:, (u 7)que avaliará esse valor Tiny Lisp:

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

Esta é uma expressão válida do Ceilão, para uma função anônima que adiciona 7 a um número inteiro arbitrário.

^{Obrigado ao DLosc por uma melhoria de 7 bytes.}

JavaScript para Lambda Calculus , 39 bytes

(Isso usa o documento vinculado como base.)

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

Digamos que a entrada seja 5. Então isso se torna:

"λa(5(add a))"

Microscript II para Javascript ES6, 9 bytes

"x=>x+"pF

GNU sed para C, 46 bytes

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

Ceilão em Lisp minúsculo , 76

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

Isso produz (depois de ler uma linha de entrada) uma saída como (q((x)(s 5(s 0 x)))), que avalia em Tiny Lisp para ((x) (s 5 (s 0 x))), uma função que pega um argumento x, subtrai de 0 e subtrai o resultado de 5. _{(Sim, é assim que se adiciona Tiny Lisp , existe apenas uma função de subtração integrada. Obviamente, é possível definir uma função de adição primeiro, mas isso seria mais longo.)}

Você pode usá-lo assim como uma função anônima:

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

(Isso será avaliado como 12.)

Ou você pode dar um nome a ele:

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

^{Correções e dicas de golfe de DLosc, o autor de Tiny Lisp.}

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

Este código é uma função anônima que cria uma função VALID PHP e Javascript chamada anonymous.

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

No momento da criação deste código, apenas o Firefox implementou o ES6 nativamente (sem sinalizadores e afins).

Este código usa a prompt()função para solicitar entrada e saída. O Firefox suporta copiar a saída de prompt(), tornando este um método legítimo de saída para Javascript.

Considerações:

• O ;no final é necessário para PHP
• O espaço return $xé exigido por Javascript
  • Ignorá-lo dirá que return$xé indefinido
• O nome da função é automático: não tenho escolha sobre ele
• Escolher apenas PHP ou Javascript reduzirá apenas o código em 1 byte e reduzirá o fator divertido pela metade
• Pode funcionar com outros idiomas

Resposta antiga (48 bytes):

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

Resposta antiga inválida:

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