เป้าหมาย:

กำหนดจำนวนธรรมชาติสองตัว (จำนวนเต็มตั้งแต่ 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 จริงซึ่ง RProgN เห็นเป็น 1 หากพวกเขาเหมือนกันหรือเท็จ aka 0 มิฉะนั้น

กรณีทดสอบ

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

ลองออนไลน์!

เรติน่า 3 ไบต์

 
1

ลองออนไลน์!

(บรรทัดแรกมีช่องว่างก่อนขึ้นบรรทัดใหม่การแลกเปลี่ยนสแต็กไม่ค่อยดีในการแสดงช่องว่างต่อท้าย)

อินพุตคือตัวเลขเป็นทศนิยมคั่นด้วยช่องว่าง (เช่น12 34) โปรแกรมนี้เพียงแค่เปลี่ยนช่องว่างเป็น a 1สร้างจำนวนมากเกินไปที่จะเป็นผลรวมของตัวเลขอินพุต (มันจำเป็นต้องมีอย่างน้อย 2 หลักมากกว่าอย่างใดอย่างหนึ่งและการเพิ่มตัวเลขสองตัวผลิตผลลัพธ์ที่ไม่เกิน 1 หลักมากกว่า อินพุตที่ใหญ่ขึ้น)

Pythonขนาด 13 ไบต์

[(0,0)].count

ลองออนไลน์! ใช้อินพุตเป็น tuple

การใช้วิธีการวัตถุlambdaสำหรับฟังก์ชั่นหลีกเลี่ยงต้นแบบของการเป็น

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

ที่นี่ความคิดที่จะทำแผนที่(0,0)การและทุกอย่างอื่นไป1 0เนื่องจาก0+0ให้ผลรวมของ0ตัวเลขธรรมชาติเท่านั้นซึ่งจะหลีกเลี่ยงการจับคู่ผลรวมเสมอ

หากใครสามารถส่งออกบูลีนที่นี่ซึ่งฉันพบว่าร่มรื่นไบต์จะถูกบันทึกเป็น

(0,0).__ge__

วิธีนี้จะตรวจสอบว่าอินพุต tuple มากที่สุด(0,0)หรือไม่ซึ่งเป็นจริงสำหรับ(0,0)เท่านั้น ในหลาม, และTrue==1 False==0ยิ่งน่าขนลุกยิ่งขึ้นการส่งออกผ่านรหัสออกและถือว่าเป็น Python Boolen จะช่วยประหยัดสองไบต์:

[(0,0)].pop

หากอนุญาตให้ใช้สตริง I / O และเลขศูนย์นำหน้าจะมีวิธีแก้ปัญหา 8 ไบต์

'1'.join

การต่อประสานนี้a1bซึ่งใหญ่กว่าa+bเสมอ

MATL, et al. 1 ไบต์

=

ยอมรับตัวเลขธรรมชาติสองตัวเป็นอินพุตและเปรียบเทียบ หากพวกเขามีค่าเท่ากันออกเป็นและถ้าพวกเขาไม่เท่ากันออกเป็น1 0นี่เป็นวิธีการเดียวกับโซลูชันของ @ ATaco

• MATL

• เยลลี่ (โดย @ ais523)

• ซ้อนกัน (โดย @Conor O'Brien)

• 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

เป็นกลุ่ม 3 ไบต์ / การกดแป้น

<C-a>gJ

ลองออนไลน์!

ทราบว่า<C-a>เป็นจริงCtrl-A0x01ซึ่งหมายถึงไบต์

ฉันชอบเมื่อเสียงเรียกเข้า (ซึ่งไม่ใช่ภาษาการเขียนโปรแกรม) สามารถแข่งขันกับภาษากอล์ฟได้ :) อินพุตมาในรูปแบบนี้:

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(หรืออาจเป็นเรื่องที่เราจะรู้ได้)

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+1Input = [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 ไบต์

!*+*

แลมบ์ดา (เกิดจากอะไรก็ตามที่ currying ) ที่เพิ่มการผกผันบูลีน (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 ไบต์ (ไม่แข่งขัน)

นี่อาจเป็นโปรแกรมที่สั้นที่สุดที่ Hodor เคยเขียน!

นี่คือสิ่งที่เกิดขึ้นเมื่อคุณไม่มีอะไรทำในช่วงวันหยุดโรงเรียน 2 สัปดาห์: สร้างภาษาตลก ๆ ที่เขียนโค้ดได้ง่าย ๆ ซึ่งไม่ทำอะไรเลย Yay สำหรับวันหยุดโรงเรียน !!!

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

Walder เป็นชื่อดั้งเดิมของ Hodor และจำเป็นต้องมีเพื่อเริ่มโปรแกรม

Hodor?! ใช้ตัวเลขจาก STDIN หรืออักขระเดี่ยวและตั้งค่าตัวสะสมเป็นอินพุต

Hodor เพิ่ม 1 เข้ากับตัวสะสม

HODOR! ส่งออกสะสมเป็นตัวเลข

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