Dados 2 números inteiros não negativos como entrada, produza um número inteiro não negativo que não pode ser criado através de nenhum operador matemático nas 2 entradas.

Por exemplo, dadas entradas 2e 3,6, 0, 5, 1, 9, 8, 23, 2 são todas saídas inválidas.

As operações que devem ser levadas em consideração são:

Addition        (a + b)
Subtraction     (a - b) and (b - a)
Multiplication  (a * b)
Division        (a / b) and (b / a)
Modulus         (a % b) and (b % a)
Exponentiation  (a ** b) and (b ** a)
Bitwise OR      (a | b)
Bitwise XOR     (a ^ b)
Bitwise AND     (a & b)
Concatenation   (a.toString() + b.toString()) and (b.toString() + a.toString())

Nos casos em que uma operação levaria a um não inteiro (como 2/3), sempre use floor. tão2 / 3 = 0

Suponha que qualquer operação inválida (como dividir por 0) resulte em 0.

Entrada

2 números inteiros não negativos.

Métodos de E / S padrão são aceitos

Você pode supor que a entrada sempre estará dentro de um intervalo que pode ser manuseado para o seu idioma, no entanto, lembre-se de que ainda existem brechas padrão .

Saída

Qualquer número inteiro não negativo que não possa ser criado por meio de nenhuma das operações acima nas 2 entradas.

Casos de teste

Input  -> Invalid outputs
2, 3   -> 0, 1, 2, 3, 5, 6, 8, 9, 23, 32
0, 0   -> 0
17, 46 -> 0, 2, 12, 17, 29, 63, 782, 1746, 4617, 18487710785295216663082172416, 398703807810572411498315063055075847178723756123452198369
6, 6   -> 0, 1, 6, 12, 36, 66, 46656
1, 1   -> 0, 1, 2, 11

Pontuação

Este é o código-golfe, pois o menor número de bytes vence!

Retina , 3 bytes

.
1

Experimente online!

Pega entradas separadas por espaço (ou qualquer caractere que não seja de nova linha)

Substitui todos os dígitos por 1e une os números resultantes por outro 1.

Prova de correção

Cortesia de Martin Ender

• Esta operação calcula um resultado com mais um dígito que o número de dígitos dos dois números juntos; a única operação que poderia produzir um resultado tão grande é a exponenciação.

• O resultado é uma repunit (um número cujos dígitos são todos 1).

• "Sabe-se [...] que um repunit na base 10 não pode [...] ser um poder perfeito". Isso significa que esse resultado também não pode ser produzido por exponenciação.

Gelatina , 3 bytes

+Æn

Experimente online!

Explicação:

+Æn Arguments: x, y
+                            x + y.
 Æn Find a prime larger than

Python 2 , 8 bytes

'1'.join

Experimente online!

Pega uma lista de duas seqüências numéricas como entradas, produz uma única sequência numérica. Concatena os números com um 1no meio.

O resultado tem muitos dígitos para qualquer coisa, exceto expoente. Note-se que a saída para (x,y)tem mais um dígito que xe ycombinado, a menos que xou yé 0. Para expoente, verificamos verificamos que isso significa que x**ynão corresponde.

• Se xé 0 ou 1, também é x**y, o que é muito pequeno
• Se y<=1entãox**y<=x é muito pequeno
• Se y==2, então x**2deve ter mais dois dígitos que x. Isso acontece x=316, e não podemos verificar nenhum desses trabalhos.
• Se y==3, então x**3deve ter mais dois dígitos que x. Isso acontece atéx=21 . Podemos verificar se nenhum deles funciona.
• Se 3<y<13, então x**yrapidamente fica muito tempo. Apenas plausível tem o número certo de dígitos parax<=25 , e podemos verificá-los.
• Se y>=14, então x**yé muito longo, mesmo para o menor possível x==2.

CJam (7 caracteres)

{+))m!}

Isso cria um número (a+b+2)!maior que o maior número relacionado em quase todos os casos.

É bastante óbvio que o maior número relacionado deve ser um dos a ** b, b ** a, concat(a, b), concat(b, a).

Se considerarmos logaritmos, descobrimos que

• log(a ** b) = b log a
• log(concat(a, b)) ~= (log a) + log (b)
• log((a + b + 2)!) ~= (a + b + 2) log (a + b + 2) - (a + b + 2)

Assim, assintoticamente, é maior e precisamos nos preocupar apenas com alguns casos pequenos. De fato, o único caso em que o valor de saída não é maior que todos os números relacionados é 0, 1(ou 1, 0), para o qual ele fornece 6e o maior número relacionado é 10.

JavaScript (ES6), 15 bytes

Recebe entrada na sintaxe de currying.

a=>b=>a*a+b*b+2

a² + b² + 1 falharia em muitas entradas, como 3² + 5² + 1 = 35 ou 7² + 26² + 1 = 726 (concatenação). a² + b² + 2 deve ser seguro. Isso foi exaustivamente testado para 0 ≤ a ≤ b ≤ 50000 .

Demo

let f =

a=>b=>a*a+b*b+2

for(a = 0; a < 5; a++) {
  for(b = a; b < 5; b++) {
    console.log(a, b, f(a)(b));
  }
}

for(i = 0; i < 10; i++) {
  a = Math.random() * 1000 | 0;
  b = Math.random() * 1000 | 0;
  console.log(a, b, f(a)(b));
}

Python, 115 95 79 bytes

Solução simples e estúpida. Sinta-se livre para me superar.

x,y=input()
f=lambda x,y:[x+y,x*y,x**y,int(`x`+`y`)]
print max(f(x,y)+f(y,x))+1

+12 bytes por causa de estúpido x/0.
-20 bytes graças a @RobinJames
-16 bytes graças a @tehtmi

Python, 27 bytes

lambda a,b:(a+b+9)**(a+b+9)

Produz um número maior que todos os números relacionados.

Experimente online!

-1 byte graças a Kevin Cruijssen.
-2 bytes graças ao Dead Possum.

Python 2, 25 bytes

lambda x,y:int(`x`+`y`)+3

Concatena e adiciona 3

Experimente online

JS (ES6), 12 bytes

x=>x.join`1`

O mesmo algoritmo que esta resposta em python . Recebe a entrada como uma matriz de entradas.

Braingolf , 4 bytes

9&+^

Experimente online! (Cabeçalho e rodapé são intérpretes, código é o código braingolf real, args são entradas)

Saídas (a+b+9)**(a+b+9)

Nos meus testes, não consegui encontrar pares nos quais isso não funcionasse.

Python 2 , 19 bytes

lambda x,y:x+9<<y+9

Experimente online!

Tenho certeza de que a mudança de bits funciona para todos os casos, mas não estou 100% nisso. De qualquer forma, ele salva alguns bytes sobre a versão de exponenciação.

J , 5 bytes

Apenas uma tradução de geléia .

4 p:+

Experimente online!

APL (Dyalog) , 4 bytes

Algoritmo retirado daqui .

!2++

Experimente online!

! fatorial de

2+¨ mais dois

+ a soma

Trabalha em J também.

QBIC , 8 bytes

Cara, existem muitas maneiras legais de pegar esses números e obter um número não relacionado. Eu só tinha que tentar alguns, para ver como o QBIC se manteria. A mais curta é uma porta da resposta Python do xnor, concatenando os números com um 1 no meio:

?;+@1`+;

Todos, um porto da resposta de Retina de Leo:

[0,_l;|+_l;||Z=Z+@1

Encontrando o próximo maior primo:

c=:+:+1≈µc|+1|c=c+1]?c

sed, 6 bytes

s/ /1/

Try it online!

Input is via stdin in the form "x y", output is to stdout.

Port of this python answer, which includes the proof of correctness. Many thanks to xnor for such a simple method.

Java 8, 15 bytes

a->b->a*a+b*b+2

Port from @Arnauld's amazing JavaScript (ES6) answer.
Try it here.

Straight-forward approach (177 170 bytes):

a->b->{int r=1;for(;a+b==r|a-b==r|a*b==r|(b>0?a/b==r|a%b==r:0>1)|Math.pow(a,b)==r|(a|b)==r|(a^b)==r|(a&b)==r|new Integer(""+a+b)==r|new Integer(""+b+a)==r;r++);return r;}

Try it here.

05AB1E, 2 4 bytes

+ØDm

Try it online!

Same as the Jelly answer, finds a prime after the sum. One byte shorter :)

EDIT: Now raises it to its own power to suffice for the exception.

Brachylog, 3 bytes

+<ṗ

Try it online!

Nothing new here.

       The output
  ṗ    is a prime number
 <     which is strictly greater than
+      the sum of the elements of
       the input.

Now, to figure out how to find an unrelated string...