Цель:

Учитывая два натуральных числа (целые числа от 0 до бесконечности), выведите число, которое не является суммой этих чисел, но является натуральным числом.

Примеры решений (TI-Basic):

• A+B+1

• not(A+B)

Неверные решения:

• A+B-1(для входных данных 0,0возвращается -1, что не является естественным)

• "ABC"( ABCэто не число)

Заметки:

• Выходные данные всегда должны быть суммой двух натуральных чисел (на самом деле это просто натуральное число)

• -1, undefined, infinity, NaNИ сообщения об ошибках не натуральные числа. Для наших целей 0это естественно (хотя не все математики согласны).

RProgN , 4 3 1 байт

_{Зачеркнуто 4 - это еще 4; (}

E

Самое простое из решений, сравнивает, если A и B равны. Pushes true, который RProgN видит как 1, если они одинаковы, или false aka 0 в противном случае.

Тестовые случаи

0+0 = 1
1+0 = 0
0+1 = 0
1+1 = 1

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

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

 
1

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

(В первой строке перед новой строкой есть пробел. Stack Exchange не очень хорошо показывает конечные пробелы.)

Ввод - это десятичные числа, разделенные пробелом (например 12 34). Эта программа просто меняет пространство на a 1, создавая число, слишком большое, чтобы быть суммой входных чисел (оно обязательно должно иметь по крайней мере на 2 цифры больше, чем любая из них, и добавление двух чисел приводит к выводу не более чем на 1 цифру больше больший вклад).

Python , 13 байт

[(0,0)].count

Попробуйте онлайн! Принимает ввод как кортеж.

Использование метода объекта для этой функции позволяет избежать использования шаблона lambda.

lambda a,b:a-~b   # 15 bytes

Здесь идея сопоставить (0,0)с 1и всем остальным 0. Поскольку только 0+0дает сумму 0среди натуральных чисел, это всегда позволяет избежать совпадения суммы.

Если бы можно было вывести здесь логическое значение, которое я считаю теневым, байт можно сохранить как

(0,0).__ge__

Это проверяет, является ли входной кортеж не более (0,0), что верно только для (0,0). В Python True==1и False==0. Более того, вывод через код завершения и обработка его как Python Boolen позволит сэкономить два байта:

[(0,0)].pop

Если разрешен строковый ввод-вывод и начальные нули в порядке, есть 8-байтовое решение

'1'.join

Это объединяет a1b, который всегда больше, чем a+b.

MATL и соавт. 1 байт

=

Принимает два натуральных числа в качестве входных данных и сравнивает их. Если они равны, вывод равен, 1а если они не равны, вывод равен 0. Это тот же подход, что и решение @ ATaco.

• MATL

• Желе (автор @ ais523)

• С накоплением (@ Конор О'Брайен)

• APL (Dyalog APL) (автор @ Adám)

• J (автор @ Adám)

• На самом деле (от @Mego)

• Неявный (@MD XF)

Javascript, 10 байт

x=>y=>!x+y

Принимает 2 числа, используя синтаксис карри, например:

(x=>y=>!x+y)(0)(0) // 1

Vim, 3 байта / нажатия клавиш

<C-a>gJ

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

Обратите внимание, что <C-a>на самом деле это ctrl-a , который представляет байт 0x01.

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

a
b

Это просто увеличивает первое число на единицу (это <C-a>часть), а затем соединяет строковые представления двух чисел вместе. Насколько я могу сказать, это никогда не должно привести к сумме.

Brain-Flak , 8 байт

({}{}())

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

Это самый читаемый ответ, который я когда-либо писал. :)

Объяснение:

(      )    # Push the sum of all the following:
 {}         #   The first input
   {}       #   The second input
     ()     #   and one

Альтернативные решения (также 8 байтов):

({}[]{})    # Sum + 1
([]{}{})    # Sum + 2

Есть множество других решений, которые работают только с положительными числами:

(<{}>{})
({}<{}>)
({{}}())
({{}()})
({{}}[])
({{}[]})

Желе , 2 байта

+‘

+ Добавляет два входа вместе, затем 'увеличивает ответ на единицу

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

TI-Basic, 3 байта

not(max(Ans

Альтернативные решения:

10^(sum(Ans         3 bytes @DestructibleWatermelon
not(sum(Ans         3 bytes
1+sum(Ans           4 bytes
Input :X=Y          5 bytes @ATaco
Input :X+not(Y      6 bytes
Input :not(X+Y      6 bytes
Input :10^(X+Y      6 bytes
Input :X+Y+1        7 bytes
Input :not(max(X,Y  7 bytes
Ans(1)=Ans(2        8 bytes
Ans(1)+not(Ans(2    9 bytes
not(Ans(1)+Ans(2    9 bytes

Интересно, что вы сделали примеры вопросов в TI-Basic, но вы забыли более короткое A=B(или, может быть, мы должны были это выяснить?)

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

+<

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

объяснение

+     The sum of the elements in the Input...
 <    ...is strictly less than the Output
      (implicitely label the output with an integer respecting this constraint)

Это всегда приведет к A+B+1, если Input = [A, B].

Mathematica, 5 байтов

1+##&

Выводит сумму двух аргументов плюс 1. Например, 1+##&[2,5]возвращает 8.

(Примечание: Binomialпочти работает, хотя Binomial[1,0]=1и Binomial[4,2]=6являются контрпримерами; я думаю, что они единственные контрпримеры.)

PHP, 17 байт

<?=1-join($argv);

Запустите так:

echo '<?=1-join($argv);' | php -- 0 0
> 1

объяснение

Это просто объединяет аргументы. Первый аргумент (имя скрипта) содержит -. В результате получается отрицательное число, которое я отрицаю со знаком минус. Затем я добавляю 1, на случай, если первое введенное число - 0(0123 = 123).

Perl 6 , 4 байта

!*+*

Лямбда (образованная Wh независимо-curry ), которая добавляет булеву инверсию (1 или 0) первого аргумента ко второму аргументу.

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

Turtlèd , 12 байт

делает очень большие числа

'1?:?:[1'0l]

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

Объяснение:

'1                write one on the starting grid square
  ?:?:            take a number, move right that many (repeat)
      [1   ]      while not on a grid square with a one on it
        '0l       put a zero on that square, move left
[implicit output of grid]

Таким образом, он выдает 10 ** (x + y).

PHP, 19 байт

1<?=max([0]+$argv);

Java (OpenJDK 9) , 10 байт

a->b->a-~b

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

HODOR , 40 байт (не конкурирует)

Это, наверное, самая короткая программа, когда-либо написанная Ходором!

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

Walder
Hodor?!
Hodor?!
Hodor HODOR!
HODOR!!!

Walder было оригинальное имя Ходора и поэтому необходимо, чтобы начать программу.

Hodor?! принимает число из STDIN или один символ и устанавливает аккумулятор на вход

Hodor добавить 1 к аккумулятору

HODOR! выводит аккумулятор в виде числа

HODOR!!!убивает Ходора! Noooooo!

Это псевдокод:

Take input
Take input
Add 1 to sum(inputs)
Output value

SmileBASIC, 4 байта

!A+B

нет (А) + В
1+1=2 -> !1+1 -> 0+1=1
0+1=1 -> !0+1 -> 1+1=2

R 13 байт

sum(scan()+1)

Спасибо Джонатану Аллану за его вклад!

05AB1E , 1 байт

Q

Работает так же, как RProgNответ.

Проверяет, если aи bодинаковы. Если так, распечатайте 1. В противном случае распечатайте0

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

C 26 24 19 байтов

f(c,d){return!c+d;}

Безголовая версия:

int f(int c,int d)
{
   return !c+d; 
}

Надеюсь, я правильно понял спецификацию. Определенно можно сократить !?

@Pavel Спасибо за сохранение 2 байта

@Neil Спасибо за ваш вклад.

MATLAB / Octave, 3 байта

@eq

Принимает два входа и проверяет равенство и дает, 1если они равны, и в 0противном случае.

Демо онлайн

брейкфук, 12 байт

Простое решение, которое выводит A+B+1.

,>,[-<+>]<+.

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

постоянный ток , 5 байт

?1n+n

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

Ввод: два натуральных числа, разделенных пробелом на стандартном вводе.

Вывод: за цифрой 1 сразу же следует сумма двух чисел, которая больше, чем сумма двух чисел.

Пример:

Входные данные: 222 333

Выход: 1555

PHP, 13 байт; (17 REPL-менее)

!max($argv)+0

Примеры

[0,0] -> 1
[0,1] -> 0
[1,0] -> 0

Для тех, кто не использует REPL

<?=!max($argv)+0;

и запустить с помощью

echo '<?=!max($argv)+0;' | php -- 0 0

Cubix, 9 8 байтов

u-~OII/@

объяснение

В развернутом виде этот ответ выглядит так:

    u -
    ~ O
I I / @ . . . .
. . . . . . . .
    . .
    . .

Порядок выполнения инструкций II~-O@

II~-O@
I      # First input
   -   # Minus
 I~    # NOT(second input)
    O  # Output as integer
     @ # End program

Протестировано для всех комбинаций входов, где оба находятся в диапазоне 0-100.

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

APL - 4 байта

1++/

Принимает массив, суммирует его элементы и добавляет один. Тест:

 1++/1 2  
4
 1++/1 0
2

√ å ı ¥ ® Ï Ø ¿ , 4 байта

II1_

II   Take 2 inputs and push to the stack
  1  Push 1 to the stack
   _ Push the sum of the stack

Для вывода добавьте oв конец.

Гексагония , 7 байт

?<.!?)@

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

Или в более читаемом формате,

 ? <
. ! ?
 ) @

Это превосходит текущее решение Hexagony в 11 байтов.

Объяснение:

Если первое число не равно 0, программа выберет следующий путь:

Это читает первый номер и ветви справа. Затем он читает второе число, за которым следует перенос и попытка прочитать третье, но этого не существует, поэтому он читает 0. Это печатается, и программа завершается (обратите внимание, что если a> 0, так как b неотрицательный a + Ь> 0).

Если первое число равно 0, программа выбирает следующий путь:

Это читает первый номер и оставленные ветви. Он попадает в угол, беря маршрут по северо-западному краю, потому что число равно 0, и читает второе число. Он оборачивает, затем увеличивает второй номер и печатает.

Он отскакивает от <, снова печатая увеличенный второй ввод. Он увеличивает значение и снова принимает северо-восточный фронт, но на этот раз, потому что текущий фронт - неотрицательное значение, увеличенное вдвое, что определенно положительно. Затем он пытается получить третий вход, но вместо этого получает 0.

Наконец, он переносится и отклоняется стрелкой, затем пытается прочитать четвертый ввод и снова получает 0. Он оборачивается и пытается прочитать пятый вход и получает 0 в последний раз. Это он печатает, и переносит @и выходит.

Обратите внимание, что b * (10 ^ k + 1) * 10> 0 + b = b, где k - длина b в цифрах, так что это работает.

Бильярд , 11 символов = 17 байтов

⇲
⇲
+
1
+
↥

Реализует x + y + 1. Довольно элементарно. Он принимает входные данные в двух отдельных строках. (Кстати, язык был немного изменен после запроса, но только для того, чтобы подавить подсказку от ввода, не уверен, что этот ответ все еще действителен).

7 символов = 11 байт, не конкурирующие

Это короче, но возможно только после нового обновления языка:

⇲
⇲
=
$

Это использует x == y, который был бесстыдно украден из решения RProgN @ ATaco [надеюсь, вы не возражаете (:). При $выходе выводит, сколько шаров прошло над ним.