Мета:

Враховуючи два натуральних числа (цілі числа від 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

Спробуйте в Інтернеті!

(У першому рядку є пробіл перед новим рядком. Обмін стеками не дуже добре показує пробіли пробілів.)

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

Пітон , 13 байт

[(0,0)].count

Спробуйте в Інтернеті! Вводиться як кортеж.

Використання об'єктного методу для функції дозволяє уникнути котлоагрегату a 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)

• Кількість в осередку (по @Conor О'Брайен)

• APL (Dyalog APL) (від @ Adám)

• J (від @ Adám)

• Насправді (від @Mego)

• Неявні (від @MD XF)

Javascript, 10 байт

x=>y=>!x+y

Бере 2 числа за допомогою синтаксису currying так:

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

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

<C-a>gJ

Спробуйте в Інтернеті!

Зауважте, що <C-a>насправді є ctrl-a , що представляє байт 0x01.

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

a
b

Це просто збільшує перше число по одному (Це <C-a>частина), а потім з'єднує рядкові представлення двох чисел разом. Наскільки я можу сказати, це ніколи не повинно призводити до суми.

Мозок-Флак , 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].

Математика, 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 байти

!*+*

Лямбда (утворена Що-небудь-каррі ), що додає булеву зворотну (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 байт (неконкурентоспроможний)

Це, мабуть, найкоротша програма, яку коли-небудь написав Ходор!

Це те, що відбувається, коли вам не потрібно нічого робити на 2-тижневому шкільному канікулі: складіть купу дійсно легко кодованих жартів, які не роблять абсолютно нічого. Так, на шкільні канікули !!!

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

не (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 byte

Q

Works the same as the RProgN answer.

Checks if a and b are the same. If so, print 1. Otherwise, print 0

Try it online!

C 26 24 19 bytes

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

Ungolfed version:

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

I hope I got the specification right. Can definitely be shortened!?

@Pavel Thanks for saving 2 bytes

@Neil Thanks for your input.

MATLAB / Octave, 3 bytes

@eq

Accepts two inputs and checks for equality and yields 1 if they are equal and 0 otherwise.

Online Demo

brainfuck, 12 bytes

Simple solution that outputs A+B+1.

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

Try it online

dc, 5 bytes

?1n+n

Try it online!

Input: Two natural numbers separated by a space on stdin.

Output: The digit 1 immediately followed by the sum of the two numbers, which is a number larger than the sum of the two numbers.

Example:

Input: 222 333

Output: 1555

PHP, 13 bytes; (17 REPL-less)

!max($argv)+0

Examples

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

For those without REPL use

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

and run using

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

Cubix, 9 8 bytes

u-~OII/@

Explanation

Expanded, this answer looks like this:

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

The order of the instructions that are executed is II~-O@

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

Tested for all combinations of inputs where both are in the range 0-100.

Try it here.

APL - 4 Bytes

1++/

Takes array, sums its elements and adds one. Test:

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

√ å ı ¥ ® Ï Ø ¿ , 4 bytes

II1_

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

To output, add o to the end.

Hexagony, 7 bytes

?<.!?)@

Try it online!

Or in more readable format,

 ? <
. ! ?
 ) @

This beats the current Hexagony solution of 11 bytes.

Explanation:

If the first number is not 0, the program takes the following path:

This reads the first number and branches right. Then it reads the second number, followed by wrapping and trying to read a third, but that doesn't exist so it reads 0. This is printed and the program terminated (note that if a>0, since b is non-negative a+b>0).

If the first number is 0, the program takes the following path to start with:

This reads the first number and branches left. It hits the corner, taking the route from along the north-west edge because the number is 0, and reads the second number. It wraps, then increments the second number and prints.

It bounces against the <, printing the incremented second input again. It increments the value and takes the north-east edge again, but this time because the current edge a twice-incremented non-negative value which is definitely positive. It then tries to get a third input, but receives 0 instead.

Finally it wraps and gets diverted by the arrow, then tries to read a fourth input and gets 0 again. It wraps and tries to read a fifth input and receives 0 for the last time. This it prints, and wraps to the @ and exits.

Note that b*(10^k+1)*10>0+b=b where k is the length of b in digits, so this works.

Billiards, 11 characters = 17 bytes

⇲
⇲
+
1
+
↥

Implements x + y + 1. Pretty elementary. It takes the inputs on two separate lines. (By the way, the language was modified slightly after the challenge, but only to suppress the prompt from inputting, not sure if this answer is still valid).

7 characters = 11 bytes, non-competing

This one is shorter but only possible after a new update of the language:

⇲
⇲
=
$

This uses x == y, which was shamelessly stolen from @ATaco's RProgN solution [ hope you don't mind (: ]. The $, on exit, outputs how many balls passed over it.