Bei 2 nicht negativen Ganzzahlen als Eingabe wird eine nicht negative Ganzzahl ausgegeben, die durch keine mathematischen Operatoren für die 2 Eingaben erstellt werden kann.

Zum Beispiel, da Eingaben 2und 3, 6, 0, 5, 1, 9, 8, 23, 2sind alle ungültigen Ausgänge.

Zu berücksichtigende Vorgänge sind:

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

In Fällen, in denen eine Operation zu einer Nicht-Ganzzahl (wie z. B. 2/3) führen würde, immer floor. So2 / 3 = 0

Angenommen, ungültige Operationen (z. B. Teilen durch 0) führen zu 0.

Eingang

2 nicht negative ganze Zahlen.

Standard-E / A-Methoden werden akzeptiert

Sie können davon ausgehen, dass die Eingabe für Ihre Sprache immer in einem handhabbaren Bereich liegt. Beachten Sie jedoch, dass weiterhin Standardlücken gelten.

Ausgabe

Jede nicht negative Ganzzahl, die nicht über eine der oben genannten Operationen an den 2 Eingängen erstellt werden kann.

Testfälle

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

Wertung

Dies ist Code-Golf, so dass die wenigsten Bytes gewinnen!

Netzhaut , 3 Bytes

.
1

Probieren Sie es online!

Übernimmt Eingaben, die durch ein Leerzeichen (oder ein einzelnes Zeichen ohne Zeilenumbruch) getrennt sind

Ersetzt alle Ziffern durch 1und verbindet die resultierenden Zahlen miteinander 1.

Beweis der Richtigkeit

Mit freundlicher Genehmigung von Martin Ender

• Diese Operation berechnet ein Ergebnis mit einer Ziffer mehr als die Anzahl der Ziffern der beiden Zahlen zusammen; Die einzige Operation, die zu einem so großen Ergebnis führen kann, ist die Potenzierung.

• Das Ergebnis ist eine Repunit (eine Zahl, deren Ziffern alle 1 sind).

• "Es ist bekannt, [...] dass eine Repunit in Basis 10 keine perfekte [...] Kraft sein kann." Dies bedeutet, dass dieses Ergebnis auch nicht durch Potenzierung erzeugt werden kann.

Gelee , 3 Bytes

+Æn

Probieren Sie es online!

Erläuterung:

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

Python 2 , 8 Bytes

'1'.join

Probieren Sie es online!

Nimmt eine Liste von zwei Zahlenfolgen als Eingaben und gibt eine einzelne Zahlenfolge aus. Verkettet die Zahlen mit einem 1in der Mitte.

Das Ergebnis enthält zu viele Ziffern für alles andere als einen Exponenten. Beachten Sie, dass die Ausgabe für (x,y)eine Ziffer mehr als xund ykombiniert ist, es sei denn, xoder yist 0. Für den Exponenten überprüfen wir, ob dies bedeutetx**y niemals übereinstimmt.

• Wenn x0 oder 1 ist, ist dies auch x**y, was zu klein ist
• Wenn ja y<=1, dann x**y<=xist es zu klein
• Wenn y==2, dann x**2müssen zwei Ziffern mehr als x. Dies geschieht bis zu x=316und wir können keine dieser Arbeiten überprüfen.
• Wenn y==3, dann x**3müssen zwei Ziffern mehr als x. Das passiert bis zu x=21. Wir können überprüfen, dass nichts davon funktioniert.
• Wenn ja 3<y<13, dann wird es x**yschnell zu lang. Es ist nur plausibel, dass es die richtige Anzahl von Stellen hat x<=25, und wir können diese überprüfen.
• Wenn ja y>=14, dann x**yist das auch für die kleinstmöglichen zu lang x==2.

CJam (7 Zeichen)

{+))m!}

Dies erzeugt eine Nummer (a+b+2)! in fast allen Fällen die größer ist als die größte zugehörige Zahl.

Es ist ziemlich offensichtlich, dass die größte verwandte Zahl eine von sein muss a ** b , b ** a, concat(a, b), concat(b, a) .

Wenn wir Logarithmen betrachten, finden wir das

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

Somit ist es asymptotisch größer und wir müssen uns nur um ein paar kleine Fälle kümmern. Tatsächlich ist 0, 1(oder 1, 0) der einzige Fall, in dem der ausgegebene Wert nicht größer als alle zugehörigen Zahlen ist, derjenige , für den er angegeben wird, 6und der größte zugehörige Wert ist10 .

JavaScript (ES6), 15 Byte

Übernimmt Eingaben in der Currying-Syntax.

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

a² + b² + 1 würde bei vielen Einträgen fehlschlagen, z. B. 3² + 5² + 1 = 35 oder 7² + 26² + 1 = 726 (Verkettung). a² + b² + 2 sollte sicher sein. Dies wurde ausführlich auf 0 ≤ a ≤ b ≤ 50000 getestet .

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

Dumme unkomplizierte Lösung. Fühlen Sie sich frei, mich zu überraschen.

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 wegen doof x/0.
-20 Bytes dank @RobinJames
-16 Bytes dank @tehtmi

Python, 27 Bytes

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

Gibt eine Nummer aus, die größer ist als alle zugehörigen Nummern.

Probieren Sie es online!

-1 Byte dank Kevin Cruijssen.
-2 Bytes dank Dead Possum.

Python 2, 25 Bytes

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

Verkettet und addiert 3

Probieren Sie es online aus

JS (ES6), 12 Bytes

x=>x.join`1`

Gleicher Algorithmus wie diese Python-Antwort . Nimmt Eingaben als Array von Ints.

Braingolf , 4 Bytes

9&+^

Probieren Sie es online! (Header & Footer sind Interpreter, Code ist der aktuelle Braingolf-Code, Argumente sind Eingaben)

Ausgänge (a+b+9)**(a+b+9)

Bei meinen Tests konnte ich keine Paare finden, bei denen dies nicht funktioniert.

Python 2 , 19 Bytes

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

Probieren Sie es online!

Ich bin mir ziemlich sicher, dass die Bitverschiebung in allen Fällen funktioniert, aber ich bin nicht zu 100% damit einverstanden. Auf jeden Fall werden gegenüber der Exponentiationsversion einige Bytes gespart.

J , 5 Bytes

Nur eine Übersetzung von Jelly .

4 p:+

Probieren Sie es online!

APL (Dyalog) , 4 Bytes

Algorithmus von hier genommen .

!2++

Probieren Sie es online!

! factorial of

2+¨ two plus

+ the sum

Works in J too.

QBIC, 8 bytes

Man, so many cool ways to just take these numbers and get an unrelated number. I just had to try a few, to see how QBIC'd keep up. The shortest one is a port of xnor's Python answer, concatenating the numbers with a 1 in the middle:

?;+@1`+;

All ones, a port of Leo's Retina answer:

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

Finding the next bigger prime:

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

+<ṗ

Probieren Sie es online!

Hier gibt es nichts Neues.

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

Um herauszufinden, wie man eine nicht verwandte Zeichenfolge findet ...