Mục tiêu:

Cho hai số tự nhiên (số nguyên từ 0 đến vô cùng), xuất ra một số không phải là tổng của các số đó, nhưng là một số tự nhiên.

Các giải pháp ví dụ (TI-Basic):

• A+B+1

• not(A+B)

Giải pháp không hợp lệ:

• A+B-1(đối với đầu vào 0,0, nó trả về -1, điều này không tự nhiên)

• "ABC"( ABCkhông phải là số)

Ghi chú:

• Đầu ra phải luôn là tổng của hai số tự nhiên (thực ra chỉ là số tự nhiên)

• -1, undefined, infinity, NaNVà thông báo lỗi không phải là số tự nhiên. Đối với mục đích của chúng tôi, 0là tự nhiên (mặc dù không phải tất cả các nhà toán học đồng ý).

RProgN , 4 3 1 Byte

_{Vượt qua 4 vẫn là 4; (}

E

Các giải pháp đơn giản nhất, so sánh nếu A và B bằng nhau. Đẩy đúng, mà RProgN xem là 1, nếu chúng giống nhau hoặc sai aka 0 khác.

Các trường hợp thử nghiệm

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

Hãy thử trực tuyến!

Võng mạc , 3 byte

 
1

Hãy thử trực tuyến!

(Dòng đầu tiên có khoảng trắng trước dòng mới. Stack Exchange không tốt lắm trong việc hiển thị khoảng trắng ở cuối.)

Đầu vào là các số thập phân, cách nhau bởi một khoảng trắng (ví dụ 12 34). Chương trình này chỉ thay đổi không gian thành a 1, tạo ra một số quá lớn bằng tổng của các số đầu vào (nó nhất thiết phải có ít nhất 2 chữ số hơn một, và thêm hai số tạo ra một đầu ra có nhiều hơn 1 chữ số đầu vào lớn hơn).

Python , 13 byte

[(0,0)].count

Hãy thử trực tuyến! Mất đầu vào như một tuple.

Sử dụng một phương thức đối tượng cho hàm để tránh bản tóm tắt của a lambda.

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

Ở đây, ý tưởng là ánh xạ (0,0)tới 1và mọi thứ khác 0. Vì chỉ 0+0đưa ra một tổng 0số trong số các số tự nhiên, điều đó luôn tránh khớp với tổng.

Nếu ai đó có thể xuất Boolean ở đây, mà tôi thấy mờ ám, một byte có thể được lưu dưới dạng

(0,0).__ge__

Điều này kiểm tra nếu bộ dữ liệu đầu vào nhiều nhất (0,0), điều này chỉ đúng với (0,0). Trong Python True==1và False==0. Thậm chí còn tồi tệ hơn, xuất ra thông qua mã thoát và coi đó là Python Boolen sẽ tiết kiệm được hai byte:

[(0,0)].pop

Nếu I / O chuỗi được phép và các số 0 đứng đầu đều ổn, thì có giải pháp 8 byte

'1'.join

Điều này concatenates a1b, mà luôn luôn lớn hơn a+b.

MATL, et al. 1 byte

=

Chấp nhận hai số tự nhiên làm đầu vào và so sánh chúng. Nếu chúng bằng nhau, đầu ra là 1và nếu chúng không bằng đầu ra 0. Đây là cách tiếp cận tương tự như giải pháp của @ ATaco.

• TOÁN

• Thạch (bởi @ ais523)

• Xếp chồng lên nhau (bởi @Conor O'Brien)

• APL (Dyalog APL) (bởi @ Adám)

• J (bởi @ Adám)

• Trên thực tế (bởi @Mego)

• Tiềm ẩn (bởi @MD XF)

Javascript, 10 byte

x=>y=>!x+y

Có 2 số sử dụng cú pháp currying như vậy:

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

Vim, 3 byte / tổ hợp phím

<C-a>gJ

Hãy thử trực tuyến!

Lưu ý rằng đó <C-a>thực sự là ctrl-a , đại diện cho byte 0x01.

Tôi thích nó khi vim (thậm chí không phải là ngôn ngữ lập trình) có thể cạnh tranh với các ngôn ngữ chơi gôn. :) Đầu vào có định dạng này:

a
b

Điều này chỉ đơn giản là tăng số đầu tiên lên một (Đây là <C-a>phần) và sau đó nối các biểu diễn chuỗi của hai số lại với nhau. Theo như tôi có thể nói, điều này sẽ không bao giờ dẫn đến tổng.

Brain-Flak , 8 byte

({}{}())

Hãy thử trực tuyến!

Đây là câu trả lời dễ đọc nhất mà tôi từng viết. :)

Giải trình:

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

Các giải pháp thay thế (cũng 8 byte):

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

Có một loạt các giải pháp khác chỉ hoạt động với số dương:

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

Thạch , 2 byte

+‘

Dấu + cộng hai đầu vào lại với nhau sau đó 'tăng câu trả lời lên một

Hãy thử trực tuyến!

TI-Basic, 3 byte

not(max(Ans

Các giải pháp thay thế:

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

Thật thú vị khi bạn thực hiện các ví dụ của câu hỏi trong TI-Basic, nhưng bạn đã quên ngắn hơn A=B(hoặc có thể tùy thuộc vào chúng tôi để tìm hiểu?)

Brachylog , 2 byte

+<

Hãy thử trực tuyến!

Giải trình

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

Điều này sẽ luôn luôn dẫn đến A+B+1, nếu Input = [A, B].

Toán học, 5 byte

1+##&

Xuất ra tổng của hai đối số cộng 1. Ví dụ: 1+##&[2,5]sản lượng 8.

(Lưu ý bên lề: Binomialgần như hoạt động, mặc dù Binomial[1,0]=1và Binomial[4,2]=6là các mẫu đối lập; tôi nghĩ rằng chúng chỉ là các mẫu tương ứng.)

PHP, 17 byte

<?=1-join($argv);

Chạy như thế này:

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

Giải trình

Điều này chỉ kết hợp các đối số. Đối số đầu tiên (tên tập lệnh) chứa -. Vì vậy, kết quả là một số âm, mà tôi phủ định bằng dấu trừ. Sau đó, tôi thêm 1, chỉ trong trường hợp số đầu vào đầu tiên là một 0(0123 = 123).

Perl 6 , 4 byte

!*+*

Một lambda (được hình thành bởi Any-currying ), có thêm nghịch đảo boolean (1 hoặc 0) của đối số thứ nhất với đối số thứ hai.

Hãy thử trực tuyến!

Turtlèd , 12 byte

làm cho số lượng rất lớn

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

Hãy thử trực tuyến!

Giải trình:

'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]

Do đó, nó tạo ra 10 ** (x + y).

PHP, 19 byte

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

Java (OpenJDK 9) , 10 byte

a->b->a-~b

Hãy thử trực tuyến!

HODOR , 40 byte (không cạnh tranh)

Đây có lẽ là chương trình ngắn nhất mà Hodor từng viết!

Đây là những gì xảy ra khi bạn không có gì để làm cho kỳ nghỉ học 2 tuần: tạo ra một loạt các ngôn ngữ trò đùa thực sự dễ dàng được mã hóa mà hoàn toàn không làm gì. Yay cho ngày nghỉ học !!!

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

Walder là tên gốc của Hodor và vì vậy cần thiết để bắt đầu chương trình.

Hodor?! lấy một số từ STDIN hoặc một ký tự đơn và đặt bộ tích lũy thành đầu vào

Hodor thêm 1 vào bộ tích lũy

HODOR! xuất ra bộ tích lũy dưới dạng số

HODOR!!!Giết chết Hodor! Không!

Đây là mã giả:

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

SmileBASIC, 4 byte

!A+B

không (A) + B
1+1=2 -> !1+1 -> 0+1=1
0+1=1 -> !0+1 -> 1+1=2

R, 13 byte

sum(scan()+1)

Cảm ơn Jonathan Allan cho đầu vào của mình!

05AB1E , 1 byte

Q

Hoạt động giống như RProgNcâu trả lời.

Kiểm tra nếu avà bgiống nhau. Nếu vậy, in 1. Nếu không, in0

Hãy thử trực tuyến!

C 26 24 19 byte

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

Phiên bản bị đánh cắp:

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

Tôi hy vọng tôi có đặc điểm kỹ thuật đúng. Chắc chắn có thể rút ngắn!?

@Pavel Cảm ơn bạn đã lưu 2 byte

@Neil Cảm ơn bạn đã đóng góp.

MATLAB / Octave, 3 byte

@eq

Chấp nhận hai đầu vào và kiểm tra sự bằng nhau và sản lượng 1nếu chúng bằng nhau và 0khác.

Demo trực tuyến

cân não, 12 byte

Giải pháp đơn giản mà đầu ra A+B+1 .

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

Dùng thử trực tuyến

đc , 5 byte

?1n+n

Hãy thử trực tuyến!

Đầu vào: Hai số tự nhiên cách nhau bởi một khoảng trắng trên stdin.

Đầu ra: Chữ số 1 ngay sau đó là tổng của hai số, là một số lớn hơn tổng của hai số.

Thí dụ:

Đầu vào: 222 333

Đầu ra: 1555

PHP, 13 byte; (17 REPL-ít hơn)

!max($argv)+0

Ví dụ

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

Đối với những người không sử dụng REPL

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

và chạy bằng

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

Hình khối, 9 8 byte

u-~OII/@

Giải trình

Mở rộng, câu trả lời này trông như thế này:

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

Thứ tự của các hướng dẫn được thực hiện là II~-O@

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

Đã kiểm tra tất cả các kết hợp đầu vào trong đó cả hai đều nằm trong phạm vi 0-100 .

Hãy thử nó ở đây .

APL - 4 byte

1++/

Lấy mảng, tính tổng các phần tử của nó và thêm một. Kiểm tra:

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

Å ı ® Ø , 4 byte

II1_

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

Để đầu ra, thêm ovào cuối.

Lục giác , 7 byte

?<.!?)@

Hãy thử trực tuyến!

Hoặc ở định dạng dễ đọc hơn,

 ? <
. ! ?
 ) @

Điều này đánh bại giải pháp Hexagony hiện tại là 11 byte.

Giải trình:

Nếu số đầu tiên không phải là 0, chương trình sẽ đi theo đường dẫn sau:

Điều này đọc số đầu tiên và các chi nhánh phải. Sau đó, nó đọc số thứ hai, tiếp theo là gói và cố đọc số thứ ba, nhưng nó không tồn tại nên nó đọc 0. Nó được in và chương trình kết thúc (lưu ý rằng nếu a> 0, vì b không âm a + b> 0).

Nếu số đầu tiên là 0, chương trình sẽ chọn đường dẫn sau để bắt đầu:

Điều này đọc số đầu tiên và các chi nhánh còn lại. Nó đâm vào góc, đi theo con đường từ dọc theo rìa phía tây bắc vì số này là 0 và đọc số thứ hai. Nó kết thúc tốt đẹp, sau đó tăng số thứ hai và in.

Nó bị trả lại so với <, in lại đầu vào thứ hai tăng dần. Nó tăng giá trị và lấy lại cạnh đông bắc một lần nữa, nhưng lần này bởi vì cạnh hiện tại có giá trị không âm tăng gấp đôi, chắc chắn là dương. Sau đó, nó cố gắng để có được đầu vào thứ ba, nhưng thay vào đó nhận được 0.

Cuối cùng, nó kết thúc tốt đẹp và được chuyển hướng bởi mũi tên, sau đó cố gắng đọc đầu vào thứ tư và được 0 lần nữa. Nó kết thúc tốt đẹp và cố gắng đọc đầu vào thứ năm và nhận 0 lần cuối cùng. Cái này nó in ra, và kết thúc tốt đẹp @.

Lưu ý rằng b * (10 ^ k + 1) * 10> 0 + b = b trong đó k là độ dài của b tính bằng chữ số, vì vậy điều này hoạt động.

Bi-a , 11 ký tự = 17 byte

⇲
⇲
+
1
+
↥

Thực hiện x + y + 1 . Khá tiểu học. Nó có các đầu vào trên hai dòng riêng biệt. (Nhân tiện, ngôn ngữ đã được sửa đổi một chút sau thử thách, nhưng chỉ để chặn lời nhắc từ khi nhập, không chắc câu trả lời này có còn hiệu lực không).

7 ký tự = 11 byte, không cạnh tranh

Cái này ngắn hơn nhưng chỉ có thể sau khi cập nhật ngôn ngữ mới:

⇲
⇲
=
$

Việc sử dụng này x == y, đã bị đánh cắp một cách đáng xấu hổ từ giải pháp RProgN của @ ATaco [hy vọng bạn không bận tâm (:]. Khi $thoát ra, sẽ đưa ra bao nhiêu quả bóng đi qua nó.