ゴール：

2つの自然数（0から無限大までの整数）が与えられた場合、それらの数の合計ではなく自然数である数値を出力します。

ソリューション例（TI-Basic）：

• A+B+1

• not(A+B)

無効なソリューション：

• A+B-1（入力の0,0場合、それは戻ります-1、これは自然ではありません）

• "ABC"（ABC数字ではありません）

ノート：

• 出力は常に2つの自然数の合計でなければなりません（実際には単なる自然数です）

• -1、undefined、infinity、NaNおよびエラーメッセージは自然数ではありません。私たちの目的で0は、これは自然です（ただし、すべての数学者が同意するわけではありません）。

RProgN、4 3 1バイト

_{取り消し線4はまだ4です;（}

E

最も単純なソリューションは、AとBが等しいかどうかを比較します。trueをプッシュします。同じ場合はRProgNは1として、そうでない場合はfalseとして0を認識します。

テストケース

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

オンラインでお試しください！

網膜、3バイト

 
1

オンラインでお試しください！

（最初の行には改行の前にスペースがあります。StackExchangeは末尾の空白を表示するのにあまり適していません。）

入力は、スペースで区切られた10進数の数値です（例：）12 34。このプログラムは、スペースをaに変更するだけ1で、入力数値の合計には大きすぎる数値を作成します（必然的に少なくとも2桁以上あり、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として処理すると、2バイト節約されます。

[(0,0)].pop

文字列I / Oが許可され、先行ゼロがOKの場合、8バイトのソリューションがあります

'1'.join

これは連結しますa1b。これは常により大きいですa+b。

MATL、他 1バイト

=

2つの自然数を入力として受け入れ、それらを比較します。それらが等しい場合、出力はで1あり、等しくない場合、出力は0です。これは、@ ATacoのソリューションと同じアプローチです。

• MATL

• ゼリー（by @ ais523）

• Stacked（by @Conor O'Brien）

• APL（Dyalog APL）（by @Adám）

• J（by @Adám）

• 実際（by @Mego）

• 暗黙的（by @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であり、byteを表していることに注意してください0x01。

vim（プログラミング言語ではない）がゴルフ言語と競合できる場合、それが大好きです。:)入力は次の形式で提供されます。

a
b

これは、最初の数値を1つ増やし（これが<C-a>一部です）、2つの数値の文字列表現を結合します。私が知る限り、これは決して合計にならないはずです。

Brain-Flak、8バイト

({}{}())

オンラインでお試しください！

これは私がこれまでに書いた中で最も読みやすい頭脳の答えです。:)

説明：

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

代替ソリューション（8バイトも）：

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

正の数でのみ機能する他のソリューションがたくさんあります。

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

ゼリー、2バイト

+‘

+は2つの入力を加算し、 'は回答を1つ増やします

オンラインでお試しください！

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（または、それを見つけるのは私たち次第でしたか？）

Brachylog、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+##&

2つの引数と1の合計を出力し1+##&[2,5]ます8。たとえば、yields 。

（サイドノート：Binomialほとんど動作しますが、反例です; しかしBinomial[1,0]=1、Binomial[4,2]=6それらは唯一の反例だと思います。）

PHP、17バイト

<?=1-join($argv);

次のように実行します：

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

説明

これは引数を連結するだけです。最初の引数（スクリプト名）にはが含まれます-。その結果、負の数になり、マイナス記号で否定します。次に、最初の入力番号が0（0123 = 123）の場合に備えて、1を追加します。

Perl 6、4バイト

!*+*

ラムダ（Whatever-curryingによって形成されます）。最初の引数のブール逆数（1または0）を2番目の引数に追加します。

オンラインでお試しください！

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 bytes

a->b->a-~b

Try it online!

HODOR, 40 bytes (non-competing)

This is probably the shortest program Hodor's ever written!

This is what happens when you have nothing to do for a 2-week school holiday: produce a bunch of really easily coded joke languages that do absolutely nothing. Yay for school holidays!!!

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

Walder was Hodor's original name and so is needed to begin the program.

Hodor?! takes either a number from STDIN or a single character and sets the accumulator to the input

Hodor add 1 to the accumulator

HODOR! outputs the accumulator as a number

HODOR!!! kills Hodor! Noooooo!

This is the pseudo code:

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

SmileBASIC, 4 bytes

!A+B

not(A)+B
1+1=2 -> !1+1 -> 0+1=1
0+1=1 -> !0+1 -> 1+1=2

R, 13 bytes

sum(scan()+1)

Thanks to Jonathan Allan for his inputs !

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.