Find an Unrelated Number

Question

Given 2 non-negative integers as input, output a non-negative integer that cannot be created through any mathematical operators on the 2 inputs.

For example, given inputs 2 and 3, 6, 0, 5, 1, 9, 8, 23, 2 are all invalid outputs.

Operations that must be taken into account are:

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 cases where an operation would lead to a non-integer (such as 2 / 3), always floor. So 2 / 3 = 0

Assume any invalid operations (such as dividing by 0) result in 0.

Input

2 non-negative integers.

Standard I/O methods are accepted

You can assume the input will always be within a handleable range for your given language, however remember standard loopholes still apply.

Output

Any non-negative integer that can not be created via any of the above operations on the 2 inputs.

Testcases

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

Scoring

This is code-golf so fewest bytes wins!

Answer 1

Retina, 3 bytes

.
1

Try it online!

Takes inputs separated by space (or any single non-newline character)

Replaces all digits with 1, and joins the resulting numbers with another 1.

Proof of correctness

Courtesy of Martin Ender

• This operation computes a result with one more digit than the number of digits of the two numbers together; the only operation that could produce a result so big is exponentiation.

• The result is a repunit (a number whose digits are all 1).

• "It is know [sic] [...] that a repunit in base 10 cannot [...] be a perfect power." This means that this result can't be produced by exponentiation either.

Answer 2

Jelly, 3 bytes

+Æn

Try it online!

Explanation:

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

Answer 3

Python 2, 8 bytes

'1'.join

Try it online!

Takes a list of two number strings as inputs, outputs a single number string. Concatenates the numbers with a 1 in the middle.

The result has too many digits for anything but exponent. Note that the output for (x,y) has one more digit than x and y combined, unless x or y is 0. For exponent, we check we check that this means x**y never matches.

• If x is 0 or 1, then so is x**y, which is too small
• If y<=1, then x**y<=x is too small
• If y==2, then x**2 must have two more digits than x. This happens up to x=316, and we can check none of those work.
• If y==3, then x**3 must have two more digits than x. This happens up to x=21. We can check that none of those work.
• If 3<y<13, then x**y quickly gets too long. It only plausible has the right number of digits for x<=25, and we can check these.
• If y>=14, then x**y is too long even for the smallest possible x==2.

Answer 4

CJam (7 chars)

{+))m!}

This creates a number (a+b+2)! which is larger than the largest related number in almost all cases.

It's fairly obvious that the largest related number must be one of a ** b, b ** a, concat(a, b), concat(b, a).

If we consider logarithms, we find that

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

Thus asymptotically it's larger, and we only need to worry about a few small cases. In fact, the only case for which the value output is not larger than all related numbers is 0, 1 (or 1, 0), for which it gives 6 and the largest related number is 10.

Answer 5

Python, 115 95 79 bytes

Stupid straightforward solution. Feel free to outgolf me.

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 because of stupid x/0.
-20 bytes thanks to @RobinJames
-16 bytes thanks to @tehtmi

Answer 6

JavaScript (ES6), 15 bytes

Takes input in currying syntax.

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

a² + b² + 1 would fail for many entries such as 3² + 5² + 1 = 35 or 7² + 26² + 1 = 726 (concatenation). a² + b² + 2 should be safe. This was exhaustively tested for 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));
}

Answer 7

Python, 27 bytes

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

Outputs a number larger than all the related numbers.

Try it online!

-1 byte thanks to Kevin Cruijssen.
-2 bytes thanks to Dead Possum.

Answer 8

Python 2, 25 bytes

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

Concatenates and adds 3

Try it online

Answer 9

JS (ES6), 12 bytes

x=>x.join`1`

Same algorithm as this python answer. Takes input as an array of ints.

Answer 10

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.

Answer 11

Braingolf, 4 bytes

9&+^

Try it online! (Header & Footer are Interpreter, code is actual braingolf code, args are inputs)

Outputs (a+b+9)**(a+b+9)

From my testing I couldn't find any pairs that this doesn't work on.

Answer 12

Python 2, 19 bytes

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

Try it online!

I'm pretty sure the bit shift works for all cases, but I'm not 100% on it. Anyway, it saves a few bytes over the exponentiation version.

Answer 13

J, 5 bytes

Just a translation of Jelly.

4 p:+

Try it online!

Answer 14

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.

Answer 15

APL (Dyalog), 4 bytes

Algorithm taken from here.

!2++

Try it online!

! factorial of

2+¨ two plus

+ the sum

Works in J too.

Answer 16

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

Answer 17

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.

Answer 18

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...