Dados 2 enteros no negativos como entrada, genera un entero no negativo que no se puede crear a través de ningún operador matemático en las 2 entradas.

Por ejemplo, las entradas dadas 2y 3, 6, 0, 5, 1, 9, 8, 23, 2son todas las salidas inválidas.

Las operaciones que deben tenerse en cuenta son:

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())

En casos donde una operación conduciría a un número no entero (como 2/3), siempre piso. Entonces2 / 3 = 0

Suponga que cualquier operación no válida (como dividir por 0) da como resultado 0.

Entrada

2 enteros no negativos.

Se aceptan métodos estándar de E / S

Puede suponer que la entrada siempre estará dentro de un rango manejable para su idioma dado, sin embargo, recuerde que todavía existen vacíos legales .

Salida

Cualquier número entero no negativo que no se puede crear mediante ninguna de las operaciones anteriores en las 2 entradas.

Casos de prueba

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

Puntuación

Este es el código de golf, ¡ por lo que gana menos bytes!

Retina , 3 bytes

.
1

Pruébalo en línea!

Toma entradas separadas por espacio (o cualquier carácter único que no sea de nueva línea)

Reemplaza todos los dígitos con 1, y une los números resultantes con otro 1.

Prueba de corrección

Cortesía de Martin Ender.

• Esta operación calcula un resultado con un dígito más que el número de dígitos de los dos números juntos; La única operación que podría producir un resultado tan grande es la exponenciación.

• El resultado es una repunidad (un número cuyos dígitos son todos 1).

• "Se sabe [sic] que [...] una repunidad en la base 10 no puede ser [...] un poder perfecto". Esto significa que este resultado tampoco puede ser producido por exponenciación.

Jalea , 3 bytes

+Æn

Pruébalo en línea!

Explicación:

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

Python 2 , 8 bytes

'1'.join

Pruébalo en línea!

Toma una lista de dos cadenas de números como entradas, genera una sola cadena de números. Concatena los números con a 1en el medio.

El resultado tiene demasiados dígitos para cualquier cosa que no sea exponente. Tenga en cuenta que la salida de (x,y)tiene un dígito más xy ycombinado, a menos que xo yes 0. Para exponente, se comprueba, comprobamos que esto significa que x**ynunca más partidos.

• Si xes 0 o 1, entonces también lo es x**y, lo cual es demasiado pequeño
• Si y<=1, entonces x**y<=xes demasiado pequeño
• Si y==2, entonces x**2debe tener dos dígitos más que x. Esto sucede hasta x=316, y no podemos verificar ninguno de esos trabajos.
• Si y==3, entonces x**3debe tener dos dígitos más que x. Esto sucede hasta x=21. Podemos comprobar que ninguno de esos funciona.
• Si 3<y<13, entonces x**yrápidamente se hace demasiado largo. Solo es plausible tiene el número correcto de dígitos x<=25, y podemos verificarlos.
• Si y>=14, entonces x**yes demasiado largo, incluso para el más pequeño posible x==2.

CJam (7 caracteres)

{+))m!}

Esto crea un número (a+b+2)!que es mayor que el número relacionado más grande en casi todos los casos.

Es bastante obvio que el mayor número relacionado debe ser uno de a ** b, b ** a, concat(a, b), concat(b, a).

Si consideramos logaritmos, encontramos 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)

Por lo tanto, asintóticamente es más grande, y solo tenemos que preocuparnos por unos pocos casos pequeños. De hecho, el único caso para el que el valor de salida no es mayor que todos los números relacionados es 0, 1(o 1, 0), para el cual da 6y el número relacionado más grande es 10.

JavaScript (ES6), 15 bytes

Toma entrada en la sintaxis de curry.

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

a² + b² + 1 fallaría para muchas entradas como 3² + 5² + 1 = 35 o 7² + 26² + 1 = 726 (concatenación). a² + b² + 2 debe ser seguro. Esto se probó exhaustivamente para 0 ≤ a ≤ b ≤ 50000 .

Manifestación

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

Estúpida solución directa. Siéntete libre de superarme.

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 estúpido x/0.
-20 bytes gracias a @RobinJames
-16 bytes gracias a @tehtmi

Python, 27 bytes

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

Emite un número mayor que todos los números relacionados.

Pruébalo en línea!

-1 byte gracias a Kevin Cruijssen.
-2 bytes gracias a Dead Possum.

Python 2, 25 bytes

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

Concatena y agrega 3

Pruébalo en línea

JS (ES6), 12 bytes

x=>x.join`1`

Mismo algoritmo que esta respuesta de Python . Toma datos como una matriz de entradas.

Braingolf , 4 bytes

9&+^

Pruébalo en línea!(El encabezado y el pie de página son intérpretes, el código es un código de braingolf real, los argumentos son entradas)

Salidas (a+b+9)**(a+b+9)

De mis pruebas no pude encontrar ningún par en el que esto no funcione.

Python 2 , 19 bytes

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

Pruébalo en línea!

Estoy bastante seguro de que el cambio de bits funciona para todos los casos, pero no estoy al 100%. De todos modos, ahorra algunos bytes sobre la versión de exponenciación.

J , 5 bytes

Solo una traducción de Jelly .

4 p:+

Pruébalo en línea!

APL (Dyalog) , 4 bytes

Algoritmo tomado de aquí .

!2++

Pruébalo en línea!

! factorial de

2+¨ dos más

+ la suma

Funciona en J también.

QBIC , 8 bytes

Hombre, hay muchas maneras geniales de tomar estos números y obtener un número no relacionado. Solo tuve que probar algunos, para ver cómo QBIC seguiría el ritmo. El más corto es un puerto de la respuesta de Python de xnor, concatenando los números con un 1 en el medio:

?;+@1`+;

Todos, un puerto de la Retina de Leo responde:

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

Encontrar el próximo primo más grande:

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

sed , 6 bytes

s/ /1/

Pruébalo en línea!

La entrada es vía stdin en la forma "x y", la salida es stdout.

Puerto de esta respuesta de Python , que incluye la prueba de corrección. Muchas gracias a xnor por un método tan simple.

Java 8, 15 bytes

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

Puerto de la sorprendente respuesta JavaScript (ES6) de @Arnauld .
Pruébalo aquí

Enfoque directo ( 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;}

Pruébalo aquí

05AB1E , 2 4 bytes

+ØDm

Pruébalo en línea!

Igual que la respuesta de Jelly, encuentra una prima después de la suma. Un byte más corto :)

EDITAR : ahora lo eleva a su propio poder para ser suficiente para la excepción.

Brachylog , 3 bytes

+<ṗ

Pruébalo en línea!

Nada nuevo aquí.

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

Ahora, para descubrir cómo encontrar una cadena no relacionada ...