20

Если в качестве входных данных указаны 2 неотрицательных целых числа, выведите неотрицательное целое число, которое невозможно создать с помощью математических операторов на 2 входах.

Например, данные входы 2и 3, 6, 0, 5, 1, 9, 8, 23, 2все являются недействительными выходами.

Операции, которые должны быть приняты во внимание:

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

В случаях, когда операция может привести к нецелочисленному результату (например, 2/3), всегда указывайте слово floor. Так2 / 3 = 0

Предположим, что любые недопустимые операции (например, деление на 0) приводят к 0.

вход

2 неотрицательных целых числа.

Стандартные методы ввода / вывода принимаются

Вы можете предположить, что ввод всегда будет в пределах обрабатываемого диапазона для вашего языка, однако помните, что стандартные лазейки все еще применяются.

Выход

Любое неотрицательное целое число, которое не может быть создано с помощью любой из вышеуказанных операций на 2 входах.

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

счет

Это код-гольф, поэтому побеждает меньше байтов!

— Skidsdev
источник

Связанные

— Скидсдев

Я думаю, что единственный способ решить эту проблему - найти какое-то простое число, которое больше (a + b)

— Мертвый опоссум

1

@DeadPossum определенно будет верным решением, хотя, возможно, не единственным и не самым удачным;)

— Skidsdev

Могу поспорить, что есть какой-то причудливый язык, который может сделать это за пару байтов: D

— Мертвый опоссум

16

Не

— связано

20

Сетчатка , 3 байта

.
1

Попробуйте онлайн!

Принимает входные данные, разделенные пробелом (или любой отдельный не-символ новой строки)

Заменяет все цифры на 1и объединяет полученные числа с другими 1.

Доказательство правильности

Предоставлено Мартином Эндером

Эта операция вычисляет результат с одной цифрой больше, чем количество цифр двух чисел вместе; единственная операция, которая может дать такой большой результат, это возведение в степень.
Результатом является воссоединение (число, цифры которого все 1).
«Известно [sic] [...], что воссоединение в базе 10 не может [...] быть совершенной силой». Это означает, что этот результат также не может быть получен путем возведения в степень.

— Лео
источник

технически это не объединяет полученные числа с другими 1, просто принимает ввод как строку из двух чисел, разделенных пробелами, и заменяет каждый символ на 1. Но, как говорится, я не могу найти примеров, которые доказывают, что вы не правы. .. еще

— Скидсдев

@Mayube, конечно, делает, и поэтому может работать с любой строкой, а не только с одной, состоящей из двух чисел, разделенных одним пробелом. Мое объяснение в терминах абстракции «два входных числа».

— Лев

2

«Известно [sic] [...], что воссоединение в базе 10 не может [...] быть совершенной силой». Никакая операция в данном списке, кроме возведения в степень, не может привести к большему количеству цифр, чем общее количество входных цифр, поэтому это должно быть допустимо.

— Мартин Эндер

Ты нахальный пидор! +1

— Фонд Моники иск

Работает и в QuadR !

— Адам

11

Желе , 3 байта

+Æn

Попробуйте онлайн!

Объяснение:

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

— Эрик Outgolfer
источник

Я думаю, что это действительно ...

— Эрик Outgolfer

Я предполагаю, что это суммирует вход и выводит первое простое больше суммы?

— Скидсдев

1

@DeadPossum Я собирался написать один. Надеюсь, я хорошо играл в гольф.

— Эрик Outgolfer

1

Постулат Бертрана должен быть почти достаточно хорош, чтобы доказать сочинение работ. Конкатенируя с меньшим числом b справа, мы имеем a..b> = 10a> 4a> 2 (a + b), и конкатенируя с меньшим числом b слева, мы имеем b..a> (b + 1) а. Единственный немалый интересный случай здесь должен быть b = 1, где мы имеем 1..a> 2a = 2 (a + b) - 2. Место, где эта граница самая тесная, находится для a = 9 .... 9. Это единственный немалый случай, который может стать проблемой для постулата Бертрана. Тем не менее, есть лучшие результаты, такие как mathoverflow.net/questions/2724

— tehtmi

1

Я предполагаю, что есть версия постулата Бертрана о доказательствах n <p <2n - 2, которая должна работать для всего. Я думал n <p <2n.

— Техми

9

Python 2 , 8 байт

'1'.join

Попробуйте онлайн!

Принимает список из двух числовых строк в качестве входных данных, выводит одну числовую строку. Объединяет числа с 1посередине.

В результате слишком много цифр, кроме показателя степени. Обратите внимание, что выходные данные для for (x,y)имеют еще одну цифру, чем xи yвместе взятые, если только xили не yравно 0. Для показателя степени мы проверяем, что это средство x**yникогда не совпадает.

Если x0 или 1, то это так x**y, что слишком мало
Если y<=1, то x**y<=xслишком мало
Если y==2, то x**2должно иметь еще две цифры, чем x. Это происходит до x=316, и мы не можем проверить ни одну из этих работ.
Если y==3, то x**3должно иметь еще две цифры, чем x. Это происходит до x=21. Мы можем проверить, что ничего из этого не работает.
Если 3<y<13, то x**yбыстро становится слишком долго. Только правдоподобно имеет правильное количество цифр x<=25, и мы можем проверить это.
Если y>=14, то x**yслишком долго, даже для наименьшего возможного x==2.

— XNOR
источник

7

CJam (7 символов)

{+))m!}

Это создает число, (a+b+2)!которое больше, чем наибольшее связанное число почти во всех случаях.

Это довольно очевидно , что самое большое число связанных должен быть один из a ** b, b ** a, concat(a, b), concat(b, a).

Если мы рассмотрим логарифмы, мы находим, что

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)

Таким образом, он асимптотически больше, и нам нужно беспокоиться только о нескольких небольших случаях. Фактически, единственным случаем, для которого выходное значение не больше всех связанных чисел, является 0, 1(или 1, 0), для которого он дает, 6и наибольшее связанное число является 10.

— Питер Тейлор
источник

3

JavaScript (ES6), 15 байт

Принимает ввод в синтаксисе карри.

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

a² + b² + 1 завершится ошибкой для многих записей, таких как 3² + 5² + 1 = 35 или 7² + 26² + 1 = 726 (объединение). a² + b² + 2 должно быть безопасным. Это было тщательно проверено на 0 ≤ a ≤ b ≤ 50000 .

демонстрация

Показать фрагмент кода

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

Развернуть фрагмент

— Arnauld
источник

1

Это должно быть безопасно от объединения. Пусть b будет числом, соединенным справа. Зафиксируя b, мы можем решить квадратное уравнение для a: a ^ 2 + b ^ 2 + 2 - 10 ^ k * a - b = 0. Дискриминант квадрата должен быть идеальным квадратом, чтобы это уравнение имело целочисленное решение. , Дискриминант равен 10 ^ 2k - 4 (b ^ 2 - b + 2) = 10 ^ 2k - (2b - 1) ^ 2 - 7. Рассмотрим по модулю 9. k не имеет значения, и мы никогда не получим квадратичный остаток для любого б.

— Техми

3

Питон, 115 95 79 байтов

Глупое прямолинейное решение. Не стесняйтесь обгонять меня.

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 байт из-за глупости x/0.
-20 байт благодаря @RobinJames
-16 байт благодаря @tehtmi

— HyperNeutrino
источник

x / y, если y, иначе 0 будет меньше или равно x * y для x, y неотрицательно, поэтому я думаю, что вы можете получить эти 12 байтов назад плюс еще 3

— Робин Джеймс Керрисон

@RobinJames Ах да, я тупой. Благодарю.

— HyperNeutrino

1

Я думаю, что вы должны быть в состоянии удалить больше случаев: 1) x - y <= x <= x + y; 2) x% y <= y <= x + y; 3,4,5) х | y = x ^ y + x & y <= x ^ y + 2 * (x & y) = x + y. (Для этого последнего XOR подобен добавлению без переноса, и AND находит биты, которые будут нести. ИЛИ принимает (1, 1) -> 1 вместо (1,1) -> 2, как в реальном сложении.)

— Техми

2

Python, 27 байт

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

Выводит число больше всех связанных номеров.

Попробуйте онлайн!

-1 байт благодаря Кевину Круйссену.
-2 байта благодаря Мертвому Опоссуму.

— Ankoganit
источник

Ваша TIO-ссылка пуста. Кроме того, я думаю, что вы можете удалить пробел после, :если я не ошибаюсь.

— Кевин Круйссен

@KevinCruijssen Упс, исправил это, спасибо!

— Анкоганит

Вы можете удалить f=- безымянная лямбда приемлема

— Мертвый опоссум

@DeadPossum Не знал этого, спасибо!

— Анкоганит

Возможно, вы могли бы избавиться хотя бы от одной из двух девяток (и соответствующих +), но я не совсем уверен.

— Тео

2

Python 2, 25 байт

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

Объединяет и добавляет 3

Попробуйте онлайн

— TFeld
источник

Работает ли это, если x и y оба равны 3?

— Роберт Бенсон

@RobertBenson Должен сделать, на самом деле, вы не можете сделать 36 из 3 и 3

— Skidsdev

Это, наверное, хорошо для меня. Обратная конкатенация должна иметь другой остаток по модулю 9. Для возведения в степень необходимо рассмотреть лишь конечное число случаев, прежде чем в результате возведения в степень будет слишком много цифр в строках ответа Python от xnor. Я не видел никаких конфликтов (ни для +1, хотя +2 имеет 2 ** 6 = 62 + 2).

— Техми

@tehtmi +1 терпит неудачу при x = y = 0 Попробовать онлайн-тестирование ссылок для всех комбинаций x и y в диапазоне [0,400]

— TFeld

2

JS (ES6), 12 байт

x=>x.join`1`

Тот же алгоритм, что и в этом ответе Python . Принимает ввод как массив целых.

1

Braingolf , 4 байта

9&+^

Попробуйте онлайн! (Верхний и нижний колонтитулы являются Интерпретатором, код - это фактический код Braingolf, аргументы - это входные данные)

Выходы (a+b+9)**(a+b+9)

Из моего тестирования я не смог найти пары, на которых это не работает.

— Skidsdev
источник

1

Python 2 , 19 байт

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

Попробуйте онлайн!

Я уверен, что сдвиг битов работает во всех случаях, но я не на 100%. Во всяком случае, это экономит несколько байтов по сравнению с версией возведения в степень.

— KSmarts
источник

1

J , 5 байт

Просто перевод желе .

4 p:+

Попробуйте онлайн!

— Адам
источник

1

APL (Дьялог) , 4 байта

Алгоритм взят отсюда .

!2++

Попробуйте онлайн!

! факториал

2+¨ два плюс

+ сумма

Работает в J тоже.

— Адам
источник

1

QBIC , 8 байт

Чувак, так много классных способов просто взять эти цифры и получить не связанный номер. Мне просто пришлось попробовать несколько, чтобы посмотреть, как QBIC будет идти в ногу. Самый короткий - порт ответа Python от xnor, объединяющий числа с 1 в середине:

?;+@1`+;

Все, порт Лео Retina ответ:

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

Нахождение следующего большего простого числа:

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

— steenbergh
источник

1

sed , 6 байт

s/ /1/

Попробуйте онлайн!

Ввод осуществляется через стандартный ввод в виде «x y», вывод в стандартный вывод.

Порт этого Python ответа , который включает в себя доказательство правильности. Большое спасибо xnor за такой простой метод.

— Kevin
источник

1

Java 8, 15 байт

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

Порт от @Arnauld удивительного JavaScript (ES6) ответа «s .
Попробуй это здесь.

Прямой подход ( ~~177~~ 170 байт ):

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

Попробуй это здесь.

— Кевин Круйссен
источник

1

05AB1E , 2 4 байта

+ØDm

Попробуйте онлайн!

То же, что и ответ желе, находит штрих после суммы. На один байт короче :)

РЕДАКТИРОВАТЬ : Теперь поднимает его в своих собственных силах, чтобы достаточно для исключения.

— Нил А.
источник

На самом деле это не тот же алгоритм, он находит a+bпростое число, в то время как мое находит наименьшее простое больше, чем a+b.

— Эрик Outgolfer

В любом случае, это должно работать.

— Нил А.

3

Сбой для 6443, 3 (что дает простое 64433, конкатенация).

— Техми

@ Tehtmi правильно, это не удается.

— Скидсдев

См. Мое редактирование, должно работать сейчас

— Нил А.

1

Брахилог , 3 байта

+<ṗ

Попробуйте онлайн!

Здесь нет ничего нового.

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

Теперь, чтобы выяснить, как найти несвязанную строку ...

— Несвязанная строка
источник

Найти несвязанный номер

вход

Выход

Testcases

счет

Сетчатка , 3 байта

Доказательство правильности

Желе , 3 байта

Python 2 , 8 байт

CJam (7 символов)

JavaScript (ES6), 15 байт

демонстрация

Питон, 115 95 79 байтов

Python, 27 байт

Python 2, 25 байт

JS (ES6), 12 байт

Braingolf , 4 байта

Python 2 , 19 байт

J , 5 байт

APL (Дьялог) , 4 байта

QBIC , 8 байт

sed , 6 байт

Java 8, 15 байт

05AB1E , 2 4 байта

Брахилог , 3 байта