Đầu vào: Hai số nguyên. Tốt nhất là số nguyên thập phân, nhưng các dạng số khác có thể được sử dụng. Chúng có thể được cung cấp cho mã trong đầu vào tiêu chuẩn, làm đối số cho chương trình hoặc chức năng hoặc dưới dạng danh sách.

Đầu ra: Tổng của họ. Sử dụng định dạng tương tự cho số nguyên đầu ra như số nguyên đầu vào. Ví dụ, đầu vào 5 16sẽ dẫn đến đầu ra 21.

Hạn chế: Không có sơ hở tiêu chuẩn xin vui lòng. Đây là mã golf , trả lời với số lượng byte thắng thấp nhất.

Lưu ý: Điều này khá tầm thường, tuy nhiên tôi quan tâm để xem làm thế nào nó có thể được thực hiện. Câu trả lời có thể là một chương trình hoàn chỉnh hoặc một chức năng, nhưng vui lòng xác định đó là chương trình nào.

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

1 2 -> 3
14 15 -> 29
7 9 -> 16
-1 8 -> 7
8 -9 -> -1
-8 -9 -> -17

Hoặc dưới dạng CSV:

a,b,c
1,2,3
14,15,29
7,9,16
-1,8,7
8,-9,-1
-8,-9,-17

Bảng xếp hạng

var QUESTION_ID=84260,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Thạch , 1 byte

+

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

Cũng hoạt động trong 05AB1E, Trên thực tế, APL, Braingolf, ,,, (Commata), Factor, Forth, Implicit, J, Julia, K, kdb +, Keg, Ly, MATL, Pyke, Deorst và Q.

Minecraft 1.10, 221 ký tự (không cạnh tranh)

Hãy xem, đây là những gì chúng ta phải đối phó khi chúng ta tạo bản đồ Minecraft.

Ngoài ra: Không có cách nào để nhận đầu vào chuỗi trong Minecraft, vì vậy tôi gian lận một chút bằng cách bắt bạn nhập số vào chính chương trình. (Điều này hơi hợp lý vì có khá nhiều bản đồ, như Minecraft Bingo của Lorgon111, yêu cầu bạn sao chép và dán các lệnh vào trò chuyện để nhập số.)

Cảm ơn bạn abrightmoore cho bộ lọc MCEdit Khối Nhãn .

scoreboard objectives add a dummy
scoreboard players set m a 6
scoreboard players set n a 8
scoreboard players operation r a += m a
scoreboard players operation r a += n a
tellraw @a {"score":{"name":"r","objective":"a"}}

Không cạnh tranh do khó khăn trong đầu vào và tôi không biết làm thế nào để đếm byte trong điều này (hệ thống blytes bị thiếu sót cho các khối lệnh).

Phép tính lambda nhị phân , 4.125 byte

Đầu vào và đầu ra là số nhà thờ .

00000000 01011111 01100101 11101101 0

Trong phép tính lambda , nó là λ m . λ n . λ f . λ x . m f ( n f x ).

Chỉ số De Bruijn : λ λ λ 4 2 (3 2 1)

Phép tính Lambda là một cách ngắn gọn để mô tả một ánh xạ (hàm).

Ví dụ, tác vụ này có thể được viết là λ x . λ y . x + y

Điều cần lưu ý là, đây không phải là lambda (hàm) có hai đối số. Đây thực sự là một lambda lồng nhau. Tuy nhiên, nó hoạt động giống như một lambda có hai đối số, vì vậy nó có thể được mô tả không chính thức như vậy. Mỗi lambda chính thức chỉ mất một đối số.

Ví dụ: nếu chúng tôi áp dụng lambda này cho 3 và 4:

(λ x . λ y . X + y ) 3 4 (λ y . 3 + y ) 4 ≡ 3 + 4 = 7

Vì vậy, lambda đầu tiên thực sự trả lại một lambda khác.

Chữ số nhà thờ là một cách để loại bỏ các dấu hiệu phụ, chỉ còn lại các biểu tượng và biến lambda.

Mỗi số trong hệ thống Giáo hội thực sự là một lambda chỉ định số lần chức năng được áp dụng cho một mục.

Đặt hàm là f và mục là x .

Vì vậy, số 1 sẽ tương ứng với λ f . λ x . f x , có nghĩa là áp dụng f cho x chính xác một lần.

Số 3, ví dụ, sẽ là λ f . λ x . f ( f ( f x )), có nghĩa là áp dụng f cho x chính xác ba lần.

Do đó, để cộng hai chữ số Church (giả sử m và n ) với nhau, nó giống như áp dụng f cho x , m + n lần.

Chúng ta có thể quan sát rằng điều này giống như lần đầu tiên áp dụng f cho x , n lần, và sau đó áp dụng f cho mục kết quả m lần.

Ví dụ: 2 có nghĩa là f(f(x))và 3 có nghĩa là f(f(f(x))), vì vậy 2 + 3 sẽ là f(f(f(f(f(x))))).

Để áp dụng f cho x , n lần, ta có n f x .

Bạn có thể xem m và n là các hàm lấy hai đối số, không chính thức.

Sau đó, chúng tôi áp dụng lại f cho mục kết quả này, m lần: m f ( n f x ).

Sau đó, chúng tôi thêm lại bản tóm tắt để thu được λ m . λ n . λ f . λ x . m f ( n f x ).

Bây giờ, chúng ta phải chuyển đổi nó thành chỉ số De Bruijn .

Đầu tiên, chúng tôi đếm "khoảng cách tương đối" giữa mỗi biến với khai báo lambda. Ví dụ: m sẽ có khoảng cách là 4, vì nó được khai báo là 4 lambdas "trước đây". Tương tự, n sẽ có khoảng cách là 3, f sẽ có khoảng cách là 2 và x sẽ có khoảng cách là 1.

Vì vậy, chúng tôi viết nó dưới dạng trung gian này: λ m . λ n . λ f . λ x . 4 2 (3 2 1)

Sau đó, chúng tôi xóa các khai báo biến, để lại cho chúng tôi: λ λ λ 4 2 (3 2 1)

Bây giờ, chúng tôi chuyển đổi nó để tính toán lambda nhị phân .

Các quy tắc là:

• trở thành 00.
• m n (nhóm) trở thành 01 m n.
• số i trở thành 1 i lần + 0, ví dụ 4 trở thành 11110.

λ λ λ λ 4 2 (3 2 1)

≡ λ λ λ λ 11110 110( 1110 110 10)

Λ λ λ 11110 110 0101 111011010

Λ λ λ 0101 111101100101111011010

≡ 00 00 00 00 0101 111101100101 111011010

≡ 000000000101111101100101111011010

Lisp thông thường, 15 byte

(+(read)(read))

Mèo xếp chồng , 8 + 4 = 12 byte

]_:]_!<X

Chạy với -mncờ. Hãy thử trực tuyến!

Chơi gôn trong Stack Mèo rất phản trực giác, vì vậy chương trình này ở trên đã được tìm thấy với một vài ngày cưỡng bức. Để so sánh, một giải pháp bằng văn bản, trực quan hơn bằng cách sử dụng *(...)>mẫu dài hơn hai byte

*(>-_:[:)>

với các -lncờ thay thế (xem phần dưới của bài đăng này để được giải thích).

Giải trình

Đây là một mồi trên Stack Mèo:

• Stack Mèo là một ngôn ngữ bí truyền có thể đảo ngược, trong đó gương của một đoạn trích làm mất tác dụng của đoạn trích gốc. Các chương trình cũng phải là hình ảnh phản chiếu của chính nó - nhất thiết, điều này có nghĩa là các chương trình có độ dài chẵn là các vòng lặp không có op hoặc vô hạn và tất cả các chương trình kết thúc không tầm thường đều có độ dài lẻ (và về cơ bản là sự kết hợp của toán tử trung tâm).
• Vì một nửa chương trình luôn được ngụ ý, một nửa có thể bị bỏ lại với -mhoặc -lcờ. Ở đây -mcờ được sử dụng, vì vậy nửa chương trình trên thực sự mở rộng ra ]_:]_!<X>!_[:_[.
• Như tên gọi của nó, Stack Mèo dựa trên ngăn xếp, với các ngăn xếp không có đáy với các số 0 (nghĩa là các thao tác trên một ngăn xếp trống khác trả về 0). Mèo xếp chồng thực sự sử dụng một cuộn băng ngăn xếp, ví dụ <và >di chuyển một chồng sang trái và một chồng phải tương ứng.
• Số không ở dưới cùng của ngăn xếp được nuốt / loại bỏ.
• Tất cả đầu vào được đẩy đến ngăn xếp đầu vào ban đầu, với đầu vào đầu tiên ở trên cùng và thêm -1 dưới đầu vào cuối cùng. Đầu ra được thực hiện ở cuối, sử dụng nội dung của ngăn xếp hiện tại (với -1 tùy chọn ở dưới cùng bị bỏ qua). -nbiểu thị I / O số.

Và đây là một dấu vết của chương trình đầy đủ mở rộng , ]_:]_!<X>!_[:_[:

    Initial state (* denotes current stack):
      ... [] [-1 b a]* [] [] ...
]   Move one stack right, taking the top element with you
      ... [] [-1 b] [a]* [] ...
_   Reversible subtraction, performing [x y] -> [x x-y] (uses an implicit zero here)
      ... [] [-1 b] [-a]* [] ...
:   Swap top two
      ... [] [-1 b] [-a 0]* [] ...
]   Move one stack right, taking the top element with you
      ... [] [-1 b] [-a] []* ...
_   Reversible subtraction (0-0, so no-op here)
!   Bit flip top element, x -> -x-1
      ... [] [-1 b] [-a] [-1]* ...
<   Move one stack left
      ... [] [-1 b] [-a]* [-1] ...
X   Swap the stack to the left and right
      ... [] [-1] [-a]* [-1 b] ...
>   Move one stack right
      ... [] [-1] [-a] [-1 b]* ...
!   Bit flip
      ... [] [-1] [-a] [-1 -b-1]* ...
_   Reversible subtraction
      ... [] [-1] [-a] [-1 b]* ...
[   Move one stack left, taking the top element with you
      ... [] [-1] [-a b]* [-1] ...
:   Swap top two
      ... [] [-1] [b -a]* [-1] ...
_   Reversible subtraction
      ... [] [-1] [b a+b]* [-1] ...
[   Move one stack left, taking the top element with you
      ... [] [-1 a+b]* [b] [-1] ...

a+bsau đó được xuất ra, với cơ sở -1 bị bỏ qua. Lưu ý rằng phần khó nhất về giải pháp này là ngăn xếp đầu ra phải có -1đáy ở dưới cùng, nếu không, ngăn xếp đầu ra [-1]sẽ bỏ qua cơ sở -1 và ngăn xếp đầu ra [0]sẽ khiến cơ sở không bị nuốt (nhưng đầu ra [2]ví dụ như stack sẽ 2chỉ xuất ra tốt).

Để giải trí, đây là danh sách đầy đủ các giải pháp liên quan có cùng độ dài được tìm thấy (danh sách có thể không đầy đủ):

]_:]^!<X
]_:]_!<X
]_:]!^<X
]_:!]^<X
[_:[^!>X
[_:[_!>X
[_:[!^>X
[_:![^>X

Các *(>-_:[:)>giải pháp dài hơn, nhưng là trực quan hơn để viết vì nó sử dụng các *(...)>mẫu. Mẫu này mở rộng <(...)*(...)>khi được sử dụng với -lcờ, có nghĩa là:

<       Move one stack left
(...)   Loop - enter if the top is positive and exit when the top is next positive again
        Since the stack to the left is initially empty, this is a no-op (top is 0)
*       XOR with 1 - top of stack is now 1
(...)   Another loop, this time actually run
>       Move one stack right

Như vậy, *(...)>mẫu có nghĩa là vòng lặp đầu tiên bị bỏ qua nhưng vòng lặp thứ hai được thực thi. Điều này cho phép lập trình đơn giản hơn diễn ra, vì chúng ta không cần phải lo lắng về tác động của vòng lặp trong nửa kia của chương trình.

Trong trường hợp này, bên trong của vòng lặp là:

>       Move one stack right, to the input stack
-       Negate top, [-1 b a] -> [-1 b -a]
_       Reversible subtraction, [-1 b -a] -> [-1 b a+b]
:       Swap top two, [-1 b a+b] -> [-1 a+b b]
[       Move one stack left, taking top of stack with you (removing the top b)
:       Swap top two, putting the 1 on this stack on top again

Cuối cùng >trong mẫu sau đó di chuyển chúng ta trở lại ngăn xếp đầu vào, nơi a+bđược xuất ra.

Brain-flak , 6 byte

({}{})

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

Brain-flak là một ngôn ngữ thực sự thú vị với hai hạn chế chính đối với nó.

1. Các ký tự hợp lệ duy nhất là dấu ngoặc, tức là bất kỳ ký tự nào trong số này:

   (){}[]<>
   

2. Mỗi bộ dấu ngoặc đơn phải được khớp hoàn toàn, nếu không chương trình không hợp lệ.

Một tập hợp các dấu ngoặc không có gì giữa chúng được gọi là "nilad". Một nilad tạo ra một giá trị số nhất định và tất cả các nilad này nằm cạnh nhau được thêm vào. Một tập hợp các dấu ngoặc có một cái gì đó giữa chúng được gọi là "đơn nguyên". Một đơn vị là một hàm có một đối số số. Vì vậy, dấu ngoặc trong một đơn nguyên được đánh giá, và đó là đối số cho đơn nguyên. Dưới đây là một ví dụ cụ thể hơn.

Số () nilad bằng 1. Vì vậy, mã não sau đây:

()()()

Được ước tính là 3. Đơn () nguyên đẩy giá trị bên trong của nó trên ngăn xếp toàn cầu. Vì vậy, sau đây

(()()())

đẩy một 3. {}Nilad bật giá trị lên trên cùng của ngăn xếp. Vì các nilad liên tiếp luôn được thêm vào, một chuỗi {}tổng tất cả các phần tử hàng đầu trên ngăn xếp. Vì vậy, mã của tôi về cơ bản là:

push(pop() + pop())

Minecraft 1.10.x, 924 512 byte

Cảm ơn @ quat vì đã giảm blytecount 48 điểm và bytecount bằng 412.

Được rồi, vì vậy, tôi đã lấy một số ý tưởng từ câu trả lời này và tạo một phiên bản của riêng tôi, ngoại trừ cái này có khả năng chấp nhận đầu vào không âm. Một phiên bản có thể được tìm thấy ở đây trong định dạng khối cấu trúc.

(phiên bản mới có vẻ tbh nhàm chán)

Các lệnh tương tự như câu trả lời khác:

scoreboard objectives add a dummy
execute @e[type=Pig] ~ ~ ~ scoreboard players add m a 1
execute @e[type=Cow] ~ ~ ~ scoreboard players add n a 1
scoreboard players operation n a += m a
tellraw @a {"score":{"name":"n","objective":"a"}}

Để nhập số, sinh sản ở một số bò và lợn. Bò sẽ đại diện cho giá trị "n" và lợn sẽ đại diện cho giá trị "m". Hệ thống khối lệnh sẽ dần dần giết chết bò và lợn và gán giá trị khi cần thiết.

Câu trả lời này giả định rằng bạn đang ở trong một thế giới không có bò hoặc lợn xuất hiện tự nhiên và các giá trị được lưu trữ trong "n" và "m" sẽ bị xóa trong mỗi lần chạy.

Võng mạc , 42 byte

\d+
$*
T`1p`-_` |-1+
+`.\b.

^(-)?.*
$1$.&

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

Giải trình

Thêm số vào unary là điều dễ nhất trên thế giới, nhưng một khi bạn giới thiệu số âm, mọi thứ trở nên khó khăn ...

\d+
$*

Chúng tôi bắt đầu bằng cách chuyển đổi các số thành đơn nguyên. Điều này được thực hiện bằng cách khớp từng số với \d+và thay thế nó bằng $*. Đây là một tính năng thay thế cụ thể của Retina. Cú pháp đầy đủ là count$*charactervà chèn các countbản sao của character. Cả hai đều có thể được bỏ qua trong đó countmặc định $&(tức là chính trận đấu) và charactermặc định 1. Vì vậy, đối với mỗi đầu vào, nchúng ta có một đầu vào nvà chúng ta vẫn có các dấu trừ tiềm năng trong đó, cũng như dấu phân cách không gian. Ví dụ: đầu vào 8 -5cho:

11111111 -11111

Bây giờ để đối phó với các số âm, dễ nhất là sử dụng một -1chữ số riêng . Chúng tôi sẽ sử dụng -cho mục đích đó.

T`1p`-_` |-1+

Giai đoạn này làm hai việc. Nó được loại bỏ khoảng trống, các dấu trừ hàng đầu và biến 1s sau một dấu trừ thành -chính chúng. Điều này được thực hiện bằng cách khớp |-1+(tức là một khoảng trắng hoặc số âm) và thực hiện chuyển ngữ trên đó. Việc chuyển ngữ đi từ 1pđến -_, nhưng ở đây, pmở rộng ra tất cả các ký tự ASCII có thể in và _có nghĩa là xóa. Vì vậy, 1s trong các trận đấu đó được chuyển thành -s và minuses và khoảng trắng bị xóa. Ví dụ của chúng tôi bây giờ trông như thế này:

11111111-----

+`.\b.

Giai đoạn này xử lý trường hợp có một số dương và một số âm trong đầu vào. Nếu vậy, sẽ có 1s và -s trong chuỗi và chúng tôi muốn chúng hủy bỏ. Điều này được thực hiện bằng cách khớp hai ký tự có ranh giới từ giữa chúng (vì 1s được coi là một ký tự từ và -không) và thay thế từ khớp bằng không có gì. Các +hướng dẫn Retina làm điều này nhiều lần cho đến khi chuỗi ngừng thay đổi.

Bây giờ chúng tôi chỉ còn lại 1 s hoặc chỉ - s.

^(-)?.*
$1$.&

Để chuyển đổi này thành số thập phân, chúng tôi khớp toàn bộ đầu vào, nhưng nếu có thể, chúng tôi sẽ bắt một -nhóm 1. Chúng tôi viết lại nhóm 1(để thêm một -số âm) và sau đó chúng tôi viết lại độ dài của trận đấu với $.&(cũng là một tính năng thay thế dành riêng cho Retina).

Đô-mi-nô , 38.000 byte hoặc 37 ô

Điều này được tạo ra trong Tabletop Simulator . Đây là một video và đây là tập tin . Nó là một nửa cộng chuẩn, bao gồm một andcổng cho 2^1giá trị địa điểm và một xorcổng cho 2^0giá trị địa điểm.

Chi tiết

• Tôi / O
  • Bắt đầu - Điều này được bao gồm cho sự rõ ràng (không được tính vào tổng số) và là những gì 'gọi' hoặc 'thực thi' chức năng. Nên được 'nhấn' sau khi nhập liệu [Vàng] .
  • Đầu vào A - Điều này được bao gồm để rõ ràng (không được tính vào tổng số) và được 'nhấn' để chỉ ra a 1và không được nhấn cho 0 [Xanh] .
  • Đầu vào B - Điều này được bao gồm để rõ ràng (không được tính vào tổng số) và được 'nhấn' để chỉ ra a 1và không được nhấn cho 0 [Blue] .
  • Đầu ra - Điều này được tính vào tổng số. Những domino tuyên bố tổng. Bên trái là 2^1và bên phải là 2^0 [Đen] .
• Nhấn
  • Để cung cấp đầu vào hoặc bắt đầu chuỗi, sinh ra đá cẩm thạch kim loại
  • Đặt cường độ nâng thành 100%
  • Nâng đá cẩm thạch lên trên domino mong muốn
  • Thả đá cẩm thạch

Haskell, 3 byte

(+)

Các dấu ngoặc đơn ở đây vì nó cần phải là một hàm tiền tố. Điều này giống như lấy một phần của hàm +, nhưng không có đối số nào được áp dụng. Nó cũng hoạt động trên một loạt các loại, chẳng hạn như vectơ, ma trận, số phức, số nổi, số nhân đôi, số liệu và tất nhiên là số nguyên.

Bởi vì đây là Haskell, đây là cách thực hiện ở cấp độ loại. Điều này sẽ được thực hiện tại thời gian biên dịch thay vì thời gian chạy:

-- This *type* represents Zero
data Zero
-- This *type* represents any other number by saying what number it is a successor to.
-- For example: One is (Succ Zero) and Two is (Succ (Succ Zero))
data Succ a

-- a + b = c, if you have a and b, you can find c, and if you have a and c you can find b (This gives subtraction automatically!)
class Add a b c | a b -> c, a c -> b

-- 0 + n = n 
instance Add Zero n n
-- If (a + b = c) then ((a + 1) + b = (c + 1))
instance (Add a b c) => Add (Succ a) b (Succ c)

Mã được điều chỉnh từ Haskell Wiki

Toán học, 4 2 byte

Tr

_{Crossed out 4 vẫn là 4 thông thường ...} Tr được áp dụng cho danh sách một chiều lấy tổng các phần tử của danh sách đã nói.

dc, 2 byte

+f

Thêm hai mục trên cùng vào ngăn xếp (được lấy trước đó stdin), sau đó bỏ nội dung của ngăn xếp vào stdout.

EDIT: Sau khi xem xét thêm, có vẻ như có một số cách có thể được thực hiện, tùy thuộc vào hành vi I / O mong muốn.

+        # adds top two items and pushes on stack
+n       # adds top two and prints it, no newline, popping it from stack
+dn      # ditto, except leaves result on stack
??+      # takes two inputs from stdin before adding, leaving sum on stack

Tôi cho rằng hình thức đầy đủ nhất cho tổng sẽ là:

??+p     # takes two inputs, adds, 'peeks'
         #  (prints top value with newline and leaves result on stack)

Chờ đợi! Hai số có thể được thực hiện trên cùng một dòng, cách nhau bởi một khoảng trắng! Điều này cho chúng ta:

?+p

Ngôn ngữ lập trình Shakespeare , 155 152 byte

.
Ajax,.
Ford,.
Act I:.
Scene I:.
[Enter Ajax and Ford]
Ajax:
Listen to thy heart
Ford:
Listen to THY heart!You is sum you and I.Open thy heart
[Exeunt]

Ung dung:

Summing Two Numbers in Verona.

Romeo, a numerical man.
Juliet, his lover and numerical counterpart.

Act I: In which Italian addition is performed.

Scene I: In which our two young lovers have a short chat.

[Enter Romeo and Juliet]

Romeo:
  Listen to thy heart.

Juliet:
  Listen to THY heart! Thou art the sum of thyself and I. Open thy heart.

[Exeunt]

Tôi đang sử dụng trình biên dịch SPL của drsam94 để biên dịch cái này. Để kiểm tra:

$ python splc.py sum.spl > sum.c
$ gcc sum.c -o sum.exe
$ echo -e "5\n16" | ./sum
21

Brachylog , 2 byte

+.

Yêu cầu một danh sách với hai số làm đầu vào

Ngoài ra, nếu bạn muốn câu trả lời cho STDOUT:

+w

JavaScript (ES6), 9 byte

a=>b=>a+b

PHP, 20 byte

Đáng ngạc nhiên là thời gian ngắn này:

<?=array_sum($argv);

Chạy từ dòng lệnh, như:

$ php sum.php 1 2

Cheddar, 3 byte

(+)

Đây là một tính năng thú vị của Cheddar có tên là "toán tử có chức năng". Tín dụng cho ý tưởng này được gửi tới @ CᴏɴᴏʀO'Bʀɪᴇɴ.

Dưới đây là nhiều ví dụ về các toán tử có chức năng:

(+)(1,2) // 3
(/)(6,2) // 3
(-)(5)   // -5

Python, 11 3 byte

sum

int.__add__

Một toán tử đặc biệt đơn giản.

Dash hình học - 15 đối tượng

Cuối cùng cũng xong.
15 đối tượng không nhiều, nhưng vẫn là một cơn ác mộng khi làm điều này (đặc biệt là vì các số âm).

Bởi vì tôi sẽ phải chèn 15 hình ảnh ở đây để làm thế nào để tái tạo nó, tôi chỉ cần tải lên cấp độ. ID cấp độ là 5216804. Mô tả cho bạn biết cách chạy nó và bạn có thể sao chép nó vì nó có thể sao chép.

Giải trình:

Trình kích hoạt trên cùng bên trái (Số đếm tức thời 2) đã kiểm tra nếu phần bổ sung đầu tiên là 0. Nếu đúng, thì nó sẽ kiểm tra xem phần bổ sung thứ hai là dương hay âm. Nếu nó là số dương, nó đã chuyển giá trị từ phần bổ sung thứ hai sang tổng (kiểu BF, sử dụng các vòng lặp) và nếu nó âm, nó sẽ làm điều tương tự.

Lý do tại sao chúng ta cần kiểm tra xem phần bổ sung thứ hai là dương hay âm là vì chúng ta sẽ cần phải trừ một phần bổ sung thứ hai và thêm một phần vào tổng hoặc thêm một phần vào phần bổ sung thứ hai và trừ một phần tương ứng.

Nếu phần bổ sung đầu tiên không bằng 0, nó sẽ kiểm tra xem nó là dương hay âm bằng cách sử dụng quy trình trên. Sau một lần lặp trong vòng lặp while, nó sẽ kiểm tra xem phần bổ sung đầu tiên có bằng không hay không và nếu có, nó thực hiện quy trình được mô tả ở đầu phần giải thích.

Vì Geometry Dash khá giống với BF, bạn có thể tạo ra giải pháp BF từ việc này.

MATL, 1 byte

s

Chấp nhận một mảng gồm hai số nguyên làm đầu vào và tính tổng chúng. Trong khi chương trình đơn giản +cũng hoạt động, điều đó đã được hiển thị cho các ngôn ngữ khác.

Dùng thử trực tuyến

Perl 5.10, 8 byte

Hai số cần thêm phải nằm trên 2 dòng riêng biệt để số này hoạt động:

say<>+<>

Hãy thử cái này ở đây.

Một với đầu vào trên cùng một dòng ( 14 + 1 byte cho cờ -a )

say$F[0]+$F[1]

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

Một với đầu vào trên cùng một dòng ( 19 + 1 byte cho cờ -a )

map{$s+=$_}@F;say$s

Hãy thử cái này ở đây.

Một số khác, bằng cách thay đổi dấu phân cách mặc định mảng ( 19 + 1 byte cho cờ -a )

$"="+";say eval"@F"

Hãy thử cái này ở đây!

Fuzzy Octo Guacamole , 1 byte

a

Một hàm lấy đầu vào từ đầu ngăn xếp và đầu ra bằng cách đẩy lên ngăn xếp.

Ví dụ chạy trong REPL:

>>> 8 9 :
[8,9]
>>> a :
17

Mẻ, 25 18 16 byte

@cmd/cset/a%1+%2

Chỉnh sửa: đã lưu 7 9 byte bằng cách sử dụng thủ thuật của tôi từ Chuỗi ký hiệu xen kẽ .

PowerShell v2 +, 17 byte

$args-join'+'|iex

Đưa đầu vào thành hai đối số dòng lệnh riêng biệt, được điền trước vào mảng đặc biệt $args. Chúng ta tạo thành một chuỗi với -jointoán tử bằng cách nối chúng với nhau +ở giữa, sau đó nối chuỗi đó thành Invoke-Expression(tương tự eval).

Cảm ơn @DarthTwon đã nhắc nhở tôi rằng khi xử lý các chương trình tối thiểu như vậy, có nhiều phương thức lấy tất cả đầu vào ở cùng một số byte.

$args[0]+$args[1]
param($a,$b)$a+$b

PowerShell không là gì nếu không linh hoạt.

> <> , 7 6 3 byte

+n;

Phiên dịch trực tuyến

Hoặc thử nó trên TIO với cờ -v.

Dùng thử trực tuyến

C, 35 byte

s(x,y){return y?s(x^y,(x&y)<<1):x;}

Những gì tôi đã làm ở đây được xác định bổ sung mà không sử dụng các toán tử boolean hoặc số học. Điều này đệ quy làm cho x các bit tổng bằng 'xor' và y các bit mang theo 'và' cho đến khi không có carry. Đây là phiên bản chưa được chỉnh sửa:

int sum(int x,int y){
    if(y==0){
        //anything plus 0 is itself
        return x;
    }
    //if it makes you happier imagine there's an else here
    int sumBits=x^y;
    int carryBits=(x&y)<<1;
    return sum(sumBits,carryBits);
}

MATLAB, 4 byte

Đã xóa 1 byte nhờ @LeakyNun

@sum

Đây là một hàm ẩn danh lấy một mảng và đưa ra tổng. Ví dụ sử dụng:

>> f = @sum
f = 
    @sum
>> f([3 4])
ans =
     7

GoLScript , 1 byte (không cạnh tranh)

K

Thêm 2 số trên cùng vào ngăn xếp. Đó là nó.

Bây giờ làm thế nào để đẩy chúng vào stack, tôi không có manh mối. Tôi không nghĩ là có thể .. ho @ CᴏɴᴏʀO'Bʀɪᴇɴ ho

Ngôn ngữ lập trình Shakespeare (SPL), 137 135 byte

Hoàn thành chương trình, chơi gôn:

.
A.
B.
Act I
Scene I
[Enter A and B]
A: Listen to your heart!
B: Listen to your heart! You are the sum of me and you. Open your heart! 

Và một lời giải thích ngắn gọn:

----
.                                 <- Title, everything before the first 
                                     full stop is considered as the tittle and treated as a comment
----
A.                                <- Dramatis personae. Here are introduced the characters in the play.
                                     |Characters are treated as variables.   
B.                                <--
----
Act I                             <- Acts and scenes are used to divide a program into smaller
                                     chunks in order to be able to refer to them later.
                                     |
Scene I                           <--
----
[Enter A and B]                   <- Characters on stage in the current scene, which are the              
                                     variables the program will have access to.
----
A: Listen to your heart!          <- Line of code. All of them have the same structure
                                     Variable: code. In this case, the concrete sentence
                                    "Listen to your heart!" reads an input number and stores it
                                     on the character (variable) refered to.
B: Listen to your heart!          <- Same as above 
   You are the sum of me and you. <- Sum the values of itself and the caharacter (variable)
                                     refered to.
   Open your heart!               <- Output the value of the character (value) refered to.

Tôi không thực sự chắc chắn rằng đây là ngắn nhất nó có thể đi. Kiểm tra trang chính thức để biết thêm.

Chỉnh sửa 1: Đã xóa phần :sau Act Ivà Scene Idường như mọi thứ sau chữ số La Mã đều bị bỏ qua, do đó tiết kiệm được 2 byte.

mã máy x86_32, 2 byte

08048540 <add7>:
 8048540:   01 c8                   add    %ecx,%eax

Giả sử hai giá trị đã có trong các thanh ghi ecx và eax, thực hiện lệnh add sẽ thêm các giá trị của hai thanh ghi và lưu kết quả vào thanh ghi đích.

Bạn có thể xem toàn bộ chương trình được viết bằng C và lắp ráp nội tuyến tại đây . Viết trình bao bọc trong C giúp cung cấp đầu vào và kiểm tra dễ dàng hơn, nhưng chức năng thêm thực tế có thể được giảm xuống hai byte này.