Objetivo:

Dados dois números naturais (números inteiros de 0 ao infinito), imprima um número que não seja a soma desses números, mas que seja um número natural.

Exemplos de soluções (TI-Basic):

• A+B+1

• not(A+B)

Soluções inválidas:

• A+B-1(para entradas 0,0, retorna -1, o que não é natural)

• "ABC"( ABCnão é um número)

Notas:

• A saída deve sempre ser uma soma de dois números naturais (que na verdade é apenas um número natural)

• -1, undefined, infinity, NaNE mensagens de erro não são números naturais. Para nossos propósitos, 0é natural (embora nem todos os matemáticos concordem).

RProgN , 4 3 1 Byte

_{O riscado 4 ainda é 4; (}

E

A mais simples das soluções compara se A e B são iguais. Envia true, que RProgN vê como 1, se forem iguais, ou false, também conhecido como 0, caso contrário.

Casos de teste

0+0 = 1
1+0 = 0
0+1 = 0
1+1 = 1

Experimente online!

Retina , 3 bytes

 
1

Experimente online!

(A primeira linha tem um espaço antes da nova linha. O Stack Exchange não é muito bom em mostrar espaços em branco à direita.)

Entrada são os números em decimal, separados por um espaço (por exemplo 12 34). Este programa apenas altera o espaço para a 1, criando um número muito grande para ser a soma dos números de entrada (ele necessariamente possui pelo menos mais 2 dígitos do que qualquer um deles, e a adição de dois números produz uma saída com não mais que 1 dígito a mais que o entrada maior).

Python , 13 bytes

[(0,0)].count

Experimente online! Recebe a entrada como uma tupla.

O uso de um método de objeto para a função evita o clichê de a lambda.

lambda a,b:a-~b   # 15 bytes

Aqui, a idéia é mapear (0,0)para 1e tudo o mais para 0. Como apenas 0+0fornece uma soma 0entre números naturais, isso sempre evita corresponder à soma.

Se alguém pudesse produzir um booleano aqui, o que acho obscuro, um byte poderia ser salvo como

(0,0).__ge__

Isso verifica se a tupla de entrada é no máximo (0,0), o que é verdadeiro apenas para (0,0). Em Python, True==1e False==0. Ainda mais sombrio, a saída via código de saída e o tratamento como um Python Boolen economizaria dois bytes:

[(0,0)].pop

Se a E / S da string for permitida e os zeros à esquerda estiverem OK, existe a solução de 8 bytes

'1'.join

Isso concatena a1b, que é sempre maior que a+b.

MATL et al. 1 byte

=

Aceita dois números naturais como entradas e os compara. Se eles são iguais, a saída é 1e, se não forem iguais, a saída é 0. Essa é a mesma abordagem da solução da @ ATaco.

• MATL

• Geléia (por @ ais523)

• Stacked (de @Conor O'Brien)

• APL (Dyalog APL) (por @ Adám)

• J (por @ Adám)

• Na verdade (por @Mego)

• Implícito (por @MD XF)

Javascript, 10 bytes

x=>y=>!x+y

Toma dois números usando a sintaxe de currying da seguinte forma:

(x=>y=>!x+y)(0)(0) // 1

Vim, 3 bytes / pressionamentos de tecla

<C-a>gJ

Experimente online!

Observe que <C-a>na verdade é ctrl-a , que representa byte 0x01.

Adoro quando o vim (que nem sequer é uma linguagem de programação) pode competir com as linguagens do golfe. :) A entrada vem neste formato:

a
b

Isso simplesmente incrementa o primeiro número em um (esta é a <C-a>parte) e, em seguida, une as representações de string dos dois números. Até onde eu sei, isso nunca deve resultar na soma.

Flak cerebral , 8 bytes

({}{}())

Experimente online!

Esta é a resposta mais fácil de ler que já escrevi. :)

Explicação:

(      )    # Push the sum of all the following:
 {}         #   The first input
   {}       #   The second input
     ()     #   and one

Soluções alternativas (também 8 bytes):

({}[]{})    # Sum + 1
([]{}{})    # Sum + 2

Existem várias outras soluções que funcionam apenas com números positivos:

(<{}>{})
({}<{}>)
({{}}())
({{}()})
({{}}[])
({{}[]})

Geléia , 2 bytes

+‘

O + adiciona as duas entradas e o 'incrementa a resposta em um

Experimente online!

TI-Basic, 3 bytes

not(max(Ans

Soluções alternativas:

10^(sum(Ans         3 bytes @DestructibleWatermelon
not(sum(Ans         3 bytes
1+sum(Ans           4 bytes
Input :X=Y          5 bytes @ATaco
Input :X+not(Y      6 bytes
Input :not(X+Y      6 bytes
Input :10^(X+Y      6 bytes
Input :X+Y+1        7 bytes
Input :not(max(X,Y  7 bytes
Ans(1)=Ans(2        8 bytes
Ans(1)+not(Ans(2    9 bytes
not(Ans(1)+Ans(2    9 bytes

É interessante que você tenha feito os exemplos da pergunta no TI-Basic, mas você esqueceu o mais curto A=B(ou talvez tenhamos sido nós que descobrimos?)

Braquilog , 2 bytes

+<

Experimente online!

Explicação

+     The sum of the elements in the Input...
 <    ...is strictly less than the Output
      (implicitely label the output with an integer respecting this constraint)

Isso sempre resultará em A+B+1, se Input = [A, B].

Mathematica, 5 bytes

1+##&

Produz a soma dos dois argumentos mais 1. Por exemplo, 1+##&[2,5]produz 8.

(Nota: Binomialquase funciona, embora Binomial[1,0]=1e Binomial[4,2]=6são contra-exemplos, eu acho que eles são os únicos contra-exemplos, no entanto.)

PHP, 17 bytes

<?=1-join($argv);

Execute assim:

echo '<?=1-join($argv);' | php -- 0 0
> 1

Explicação

Isso apenas concatena os argumentos. O primeiro argumento (nome do script) contém -. Então isso resulta em um número negativo, que eu nego com o sinal de menos. Então adiciono 1, caso o primeiro número de entrada seja a 0(0123 = 123).

Perl 6 , 4 bytes

!*+*

Um lambda (formado por Whatever-currying ), que adiciona o inverso booleano (1 ou 0) do primeiro argumento ao segundo argumento.

Experimente online!

Turtlèd , 12 bytes

faz números muito grandes

'1?:?:[1'0l]

Experimente online!

Explicação:

'1                write one on the starting grid square
  ?:?:            take a number, move right that many (repeat)
      [1   ]      while not on a grid square with a one on it
        '0l       put a zero on that square, move left
[implicit output of grid]

Assim, gera 10 ** (x + y).

PHP, 19 bytes

1<?=max([0]+$argv);

Java (OpenJDK 9) , 10 bytes

a->b->a-~b

Experimente online!

HODOR , 40 bytes (não concorrente)

Este é provavelmente o programa mais curto que Hodor já escreveu!

É o que acontece quando você não tem nada para fazer durante as férias escolares de duas semanas: produza um monte de linguagens de piadas realmente facilmente codificadas que não fazem absolutamente nada. Yay para férias escolares !!!

Walder
Hodor?!
Hodor?!
Hodor HODOR!
HODOR!!!

Walder era o nome original de Hodor e, portanto, é necessário para iniciar o programa.

Hodor?! pega um número de STDIN ou um único caractere e define o acumulador para a entrada

Hodor adicione 1 ao acumulador

HODOR! gera o acumulador como um número

HODOR!!!mata Hodor! Nããããão!

Este é o pseudo-código:

Take input
Take input
Add 1 to sum(inputs)
Output value

SmileBASIC, 4 bytes

!A+B

não (A) + B
1+1=2 -> !1+1 -> 0+1=1
0+1=1 -> !0+1 -> 1+1=2

R, 13 bytes

sum(scan()+1)

Obrigado a Jonathan Allan por suas contribuições!

05AB1E , 1 byte

Q

Funciona da mesma forma que a RProgNresposta.

Verifica se ae bé o mesmo. Se sim, imprima 1. Caso contrário, imprima0

Experimente online!

C 26 24 19 bytes

f(c,d){return!c+d;}

Versão não destruída:

int f(int c,int d)
{
   return !c+d; 
}

Espero ter acertado as especificações. Definitivamente pode ser encurtado !?

@Pavel Obrigado por salvar 2 bytes

@ Neil Obrigado pela sua contribuição.

MATLAB / oitava, 3 bytes

@eq

Aceita duas entradas e verifica a igualdade e produz 1se forem iguais ou 0não.

Demo Online

brainfuck, 12 bytes

Solução simples que gera A+B+1.

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

Experimente online

dc , 5 bytes

?1n+n

Experimente online!

Entrada: Dois números naturais separados por um espaço em stdin.

Saída: o dígito 1 seguido imediatamente pela soma dos dois números, que é um número maior que a soma dos dois números.

Exemplo:

Entrada: 222 333

Saída: 1555

PHP, 13 bytes; (17 sem REPL)

!max($argv)+0

Exemplos

[0,0] -> 1
[0,1] -> 0
[1,0] -> 0

Para aqueles sem uso de REPL

<?=!max($argv)+0;

e corra usando

echo '<?=!max($argv)+0;' | php -- 0 0

Cubix, 9 8 bytes

u-~OII/@

Explicação

Expandida, esta resposta tem a seguinte aparência:

    u -
    ~ O
I I / @ . . . .
. . . . . . . .
    . .
    . .

A ordem das instruções executadas é II~-O@

II~-O@
I      # First input
   -   # Minus
 I~    # NOT(second input)
    O  # Output as integer
     @ # End program

Testado para todas as combinações de entradas em que ambas estão no intervalo 0-100.

Experimente aqui .

APL - 4 bytes

1++/

Pega array, soma seus elementos e adiciona um. Teste:

 1++/1 2  
4
 1++/1 0
2

√ å ı ¥ ® Ï Ø ¿ , 4 bytes

II1_

II   Take 2 inputs and push to the stack
  1  Push 1 to the stack
   _ Push the sum of the stack

Para gerar, adicione ono final.

Hexagonia , 7 bytes

?<.!?)@

Experimente online!

Ou em um formato mais legível,

 ? <
. ! ?
 ) @

Isso supera a atual solução Hexagony de 11 bytes.

Explicação:

Se o primeiro número não for 0, o programa seguirá o seguinte caminho:

Isso lê o primeiro número e ramifica à direita. Em seguida, ele lê o segundo número, seguido pelo empacotamento e pela tentativa de ler um terceiro, mas isso não existe e, portanto, lê 0. Isso é impresso e o programa é encerrado (observe que, se a> 0, pois b não é negativo a + b> 0).

Se o primeiro número for 0, o programa seguirá o seguinte caminho:

Lê o primeiro número e ramificações restantes. Ele atinge a esquina, seguindo a rota ao longo da borda noroeste, porque o número é 0 e lê o segundo número. Ele envolve, depois incrementa o segundo número e imprime.

Ele salta contra o <, imprimindo a segunda entrada incrementada novamente. Ele incrementa o valor e retoma a borda nordeste novamente, mas desta vez porque a borda atual é um valor não negativo duas vezes incrementado que é definitivamente positivo. Em seguida, tenta obter uma terceira entrada, mas recebe 0.

Finalmente, envolve e é desviado pela seta, tenta ler uma quarta entrada e obtém 0 novamente. Ele envolve e tenta ler uma quinta entrada e recebe 0 pela última vez. Isso imprime e envolve as @saídas e.

Observe que b * (10 ^ k + 1) * 10> 0 + b = b onde k é o comprimento de b em dígitos, portanto, isso funciona.

Bilhar , 11 caracteres = 17 bytes

⇲
⇲
+
1
+
↥

Implementos x + y + 1. Bem elementar. Leva as entradas em duas linhas separadas. (A propósito, o idioma foi modificado um pouco após o desafio, mas apenas para suprimir a solicitação de entrada, sem ter certeza se essa resposta ainda é válida).

7 caracteres = 11 bytes, não concorrente

Este é mais curto, mas só é possível após uma nova atualização do idioma:

⇲
⇲
=
$

Esse uso x == y, que foi descaradamente roubado da solução RProgN da @ ATaco [espero que você não se importe (:]. O $, na saída, gera quantas bolas passaram por ele.