Étant donné 2 entiers non négatifs en entrée, sortez un entier non négatif qui ne peut être créé par aucun opérateur mathématique sur les 2 entrées.

Par exemple, les entrées données 2et 3, 6, 0, 5, 1, 9, 8, 23, 2sont toutes les sorties non valides.

Les opérations à prendre en compte sont:

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

Dans les cas où une opération conduirait à un non-entier (tel que 2/3), toujours au sol. Donc2 / 3 = 0

Supposons que toute opération non valide (telle que la division par 0) donne 0.

Contribution

2 entiers non négatifs.

Les méthodes d'E / S standard sont acceptées

Vous pouvez supposer que l'entrée sera toujours dans une plage manipulable pour votre langue donnée, mais n'oubliez pas que les failles standard s'appliquent toujours.

Production

Tout entier non négatif qui ne peut pas être créé via l'une des opérations ci-dessus sur les 2 entrées.

Cas de test

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

Notation

C'est le code-golf donc le moins d'octets gagne!

Rétine , 3 octets

.
1

Essayez-le en ligne!

Prend les entrées séparées par un espace (ou n'importe quel caractère non nouveau de ligne)

Remplace tous les chiffres par 1et joint les numéros résultants par un autre 1.

Preuve d'exactitude

Avec l'aimable autorisation de Martin Ender

• Cette opération calcule un résultat avec un chiffre de plus que le nombre de chiffres des deux nombres ensemble; la seule opération qui pourrait produire un résultat aussi grand est l'exponentiation.

• Le résultat est une répétition (un nombre dont les chiffres sont tous 1).

• "Il est connu [sic] [...] qu'un remboursement en base 10 ne peut pas [...] être un pouvoir parfait." Cela signifie que ce résultat ne peut pas non plus être produit par exponentiation.

Gelée , 3 octets

+Æn

Essayez-le en ligne!

Explication:

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

Python 2 , 8 octets

'1'.join

Essayez-le en ligne!

Prend une liste de deux chaînes de nombres comme entrées, sort une chaîne de nombres unique. Concatène les nombres avec un 1au milieu.

Le résultat a trop de chiffres pour autre chose que l'exposant. Notez que la sortie pour (x,y)a un chiffre de plus que xet ycombiné, sauf si xou yest 0. Pour l'exposant, nous vérifions que nous vérifions que cela x**yne correspond jamais.

• Si xest 0 ou 1, alors c'est le cas x**y, ce qui est trop petit
• Si y<=1, alors x**y<=xc'est trop petit
• Si y==2, alors x**2doit avoir deux chiffres de plus que x. Cela arrive jusqu'à x=316, et nous ne pouvons vérifier aucun de ces travaux.
• Si y==3, alors x**3doit avoir deux chiffres de plus que x. Cela arrive jusqu'à x=21. Nous pouvons vérifier qu'aucun de ces éléments ne fonctionne.
• Si 3<y<13, puis x**ydevient rapidement trop long. Il n'est plausible que d'avoir le bon nombre de chiffres x<=25, et nous pouvons les vérifier.
• Si y>=14, alors x**yc'est trop long même pour le plus petit possible x==2.

CJam (7 caractères)

{+))m!}

Cela crée un nombre (a+b+2)!qui est plus grand que le plus grand nombre apparenté dans presque tous les cas.

Il est assez évident que le plus grand nombre apparenté doit être l'un des a ** b , b ** a, concat(a, b), concat(b, a).

Si nous considérons les logarithmes, nous constatons 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)

Ainsi, asymptotiquement, il est plus grand et nous n'avons à nous soucier que de quelques petits cas. En fait, le seul cas pour lequel la valeur de sortie n'est pas supérieure à tous les nombres associés est 0, 1(ou 1, 0), pour lequel il donne6 et le plus grand nombre lié est 10.

JavaScript (ES6), 15 octets

Prend une entrée dans la syntaxe de curry.

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

a² + b² + 1 échouerait pour de nombreuses entrées telles que 3² + 5² + 1 = 35 ou 7² + 26² + 1 = 726 (concaténation). a² + b² + 2 devrait être sûr. Ceci a été testé de manière exhaustive pour 0 ≤ a ≤ b ≤ 50000 .

Démo

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 octets

Solution simple stupide. N'hésitez pas à me surpasser.

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 octets à cause de stupide x/0.
-20 octets grâce à @RobinJames
-16 octets grâce à @tehtmi

Python, 27 octets

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

Génère un nombre supérieur à tous les nombres associés.

Essayez-le en ligne!

-1 octet merci à Kevin Cruijssen.
-2 octets grâce à Dead Possum.

Python 2, 25 octets

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

Concatène et ajoute 3

Essayez-le en ligne

JS (ES6), 12 octets

x=>x.join`1`

Même algorithme que cette réponse python . Prend l'entrée comme un tableau d'entiers.

Braingolf , 4 octets

9&+^

Essayez-le en ligne!(L'en-tête et le pied de page sont interprètes, le code est le code braingolf réel, les arguments sont des entrées)

Les sorties (a+b+9)**(a+b+9)

D'après mes tests, je n'ai trouvé aucune paire sur laquelle cela ne fonctionne pas.

Python 2 , 19 octets

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

Essayez-le en ligne!

Je suis presque sûr que le décalage de bits fonctionne dans tous les cas, mais je ne suis pas à 100%. Quoi qu'il en soit, il enregistre quelques octets sur la version d'exponentiation.

J , 5 octets

Juste une traduction de Jelly .

4 p:+

Essayez-le en ligne!

APL (Dyalog) , 4 octets

Algorithme tiré d' ici .

!2++

Essayez-le en ligne!

! factorielle de

2+¨ deux plus

+ la somme

Fonctionne aussi en J.

QBIC , 8 octets

Man, tant de façons intéressantes de simplement prendre ces chiffres et d'obtenir un numéro sans rapport. Je devais juste en essayer quelques-uns, pour voir comment le QBIC allait suivre. Le plus court est un port de réponse Python de xnor, concaténant les nombres avec un 1 au milieu:

?;+@1`+;

Tous, un port de la rétine de Leo répond:

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

Trouver le prochain plus grand nombre premier:

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

sed , 6 octets

s/ /1/

Essayez-le en ligne!

L'entrée se fait via stdin sous la forme "x y", la sortie est vers stdout.

Port de cette réponse python , qui inclut la preuve d'exactitude. Un grand merci à xnor pour une méthode aussi simple.

Java 8, 15 octets

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

Port de @Arnauld JavaScript incroyable de (ES6) réponse .
Essayez-le ici.

Approche directe ( 177 170 octets ):

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;}

Essayez-le ici.

05AB1E , 2 4 octets

+ØDm

Essayez-le en ligne!

Identique à la réponse Jelly, trouve un nombre premier après la somme. Un octet plus court :)

EDIT : le soulève maintenant à son propre pouvoir pour suffire à l'exception.

Brachylog , 3 octets

+<ṗ

Essayez-le en ligne!

Rien de nouveau ici.

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

Maintenant, pour savoir comment trouver une chaîne sans rapport ...