दो नंबर जोड़ें

Question

इनपुट: दो पूर्णांक। अधिमानतः दशमलव पूर्णांक, लेकिन संख्याओं के अन्य रूपों का उपयोग किया जा सकता है। इन्हें प्रोग्राम या फ़ंक्शन के तर्क के रूप में या सूची के रूप में मानक इनपुट में कोड को दिया जा सकता है।

आउटपुट: उनकी राशि। इनपुट पूर्णांक के रूप में आउटपुट पूर्णांकों के लिए एक ही प्रारूप का उपयोग करें। उदाहरण के लिए, इनपुट 5 16आउटपुट पर ले जाएगा 21।

प्रतिबंध: कोई मानक खामियों कृपया। यह कोड-गोल्फ है , सबसे कम मात्रा में बाइट्स जीतता है।

नोट्स: यह काफी तुच्छ होना चाहिए, हालांकि मुझे यह देखने में दिलचस्पी है कि इसे कैसे लागू किया जा सकता है। जवाब एक पूरा कार्यक्रम या एक समारोह हो सकता है, लेकिन कृपया पहचानें कि यह कौन सा है।

परीक्षण के मामलों:

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

या सीएसवी के रूप में:

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

लीडरबोर्ड

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>

Comments

यह काफी तुच्छ है, लेकिन वास्तव में आसान नहीं है, उदाहरण के लिए, हैलो वर्ल्ड कैटलॉग। यह देखते हुए कि पूर्णांक जोड़ने की क्षमता प्रोग्रामिंग भाषाओं के लिए हमारी दो आवश्यकताओं में से एक है, मैं कहूंगा कि अगर यह ठीक से निर्दिष्ट किया गया है तो यह सार्थक है।

— डेनिस

क्या उत्तर डिफ़ॉल्ट के रूप में पूर्ववर्ती शून्य के साथ इनपुट ले सकता है? उदाहरण के 5 16लिए इनपुट किया जाता है005 016

— FinW

@ फ़िनवेल श्योर। जब तक उन्हें अष्टक के रूप में व्याख्या नहीं मिलती।

— dkudriavtsev

Answer 1

जेली , 1 बाइट

+

इसे ऑनलाइन आज़माएं!

05AB1E में भी काम करता है, वास्तव में, APL, ब्रिंगोल्फ,,, (Commata), फैक्टर, फोर्थ, इंप्लांट, जे, जूलिया, के, kdb +, Keg, Ly, MATL, Pyke, Deorst, और Q.

Comments

स्विफ्ट में भी काम करता है।

— Zacharý

साथ ही पाइथ @ ज़ाचारि

— स्टेन

Answer 2

Minecraft 1.10, 221 अक्षर (गैर-प्रतिस्पर्धात्मक)

देखें, यह तब होता है जब हम Minecraft नक्शे बनाते हैं।

एक तरफ: Minecraft में एक स्ट्रिंग इनपुट लेने का कोई तरीका नहीं है, इसलिए मैं आपको प्रोग्राम में संख्याओं को इनपुट करके थोड़ा धोखा दे रहा हूं। (यह कुछ हद तक उचित है क्योंकि Lorgon111 के Minecraft बिंगो जैसे कुछ नक्शे, आपको एक नंबर इनपुट करने के लिए आदेशों को चैट में कॉपी और पेस्ट करने की आवश्यकता है।)

ब्लॉक लेबल्स MCEdit फ़िल्टर के लिए abrightmoore धन्यवाद ।

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"}}

इनपुट में कठिनाइयों के कारण गैर-प्रतिस्पर्धा, और मुझे नहीं पता कि इस चीज़ में बाइट्स कैसे गिनें (बाइट्स सिस्टम कमांड ब्लॉक के लिए त्रुटिपूर्ण है)।

Comments

यह अब तक का सर्वश्रेष्ठ है। गजब का।

— dkudriavtsev

मुझे नहीं लगता कि इनपुट को हार्डकोड करना मान्य है, लेकिन मुझे मिनेक्राफ्ट में कमांड ब्लॉक के बारे में पर्याप्त नहीं पता है कि अगर जार्डिंग को हार्डकॉडिंग के अलावा इनपुट लेने का कोई तरीका है तो उसे जज करने में सक्षम होना चाहिए। शायद हमारे निवासी Minecraft विशेषज्ञों में से एक का वजन कर सकते हैं।

— Mego

हाँ, MC में शून्य पाठ इनपुट है, इसके अलावा "कृपया इस कमांड को कॉपी और पेस्ट करें"। एक नंबर कीपैड एक / टेलर के साथ संभव है, लेकिन सभी गोल्फ के लिए मुश्किल से उपयोग करने योग्य होगा, 500kb / / टेलर के अश्लील सख्त वाक्यविन्यास के लिए धन्यवाद का उल्लेख नहीं करने के लिए। मुझे लगता है कि एक विकल्प यह होगा कि इसके लिए दुनिया में कुछ गिना जाए, जैसे सूअर + गाय, या लाल ऊन + नीला ऊन।

— क्वाट

@quat जैसा कि हम आमतौर पर मिनीक्राफ्ट में चीजों को गिनने के लिए हॉपर का उपयोग करते हैं, मुझे लगता है कि यह जाने का रास्ता होगा। इससे निपटने का एक अन्य तरीका लीवर का उपयोग करके शुद्ध रेडस्टोन में भी उल्लेखनीय होगा। जैसा कि हमारे पास कोई प्रतिबंध नहीं है, और बिटकॉइन Minecraft में उपलब्ध होने वाला सबसे बड़ा प्राकृतिक मूल्य है, जिसके परिणामस्वरूप बस दो बिट्स को दो बिट्स के आउटपुट के साथ जोड़ा जाएगा (संभावना:: 0,1,2एक अन्य समाधान 2 बाइट्स में लेना होगा। 9 तार पर आउटपुट, लेकिन बहुत कम गोल्फ होगा।

— काटनेंको

अब बायटेकाउंट के लिए एक एमसी स्टैंडर्ड है।

— mbomb007

Answer 3

बाइनरी लैम्ब्डा कैलकुलस , 4.125 बाइट्स

चर्च अंकों के रूप में इनपुट और आउटपुट ।

00000000 01011111 01100101 11101101 0

में लैम्ब्डा पथरी , यह λ है मी । λ एन । λ च । λ x । m f ( n f x )।

डी ब्रूजन इंडेक्स : λ λ λ λ 4 2 (3 2 1)

---

लैम्ब्डा कैलकुलस एक मैपिंग (फ़ंक्शन) का वर्णन करने का एक संक्षिप्त तरीका है।

उदाहरण के लिए, इस कार्य को λ x के रूप में लिखा जा सकता है । λ y । x + y

ध्यान देने वाली बात यह है, कि यह लंबोदर (फंक्शन) नहीं है, जो दो तर्क देता है। यह वास्तव में एक नेस्टेड लैम्ब्डा है। हालांकि, यह एक लंबोदर की तरह व्यवहार करता है जो दो तर्क लेता है, इसलिए इसे अनौपचारिक रूप से इस तरह के रूप में वर्णित किया जा सकता है। हर लम्बा औपचारिक रूप से केवल एक तर्क लेता है।

उदाहरण के लिए, यदि हम इस लैम्ब्डा को 3 और 4 पर लागू करते हैं:

(λ x । λ y । x + y ) 3 4 (λ y । 3 + y ) 4 7 3 + 4 = 7

तो, पहला लैंबडा वास्तव में एक और लैम्ब्डा लौटाता है।

---

चर्च अंक केवल लैम्ब्डा प्रतीकों और चर के साथ छोड़कर, अतिरिक्त संकेतों के साथ दूर करने का एक तरीका है।

चर्च प्रणाली में प्रत्येक संख्या वास्तव में एक लैम्ब्डा है जो निर्दिष्ट करती है कि आइटम को कितनी बार फ़ंक्शन लागू किया जाता है।

फ़ंक्शन को f होने दें और आइटम x हो ।

तो, नंबर 1 λ च के अनुरूप होगा । λ x । f x , जिसका अर्थ है एक बार f से x पर लागू होना ।

उदाहरण के लिए नंबर 3, λ f होगा । λ x । f ( f ( f x )), जिसका अर्थ है f से x को तीन बार लगाना।

---

इसलिए, दो चर्च अंक (जैसे, मी और एन ) को एक साथ जोड़ने के लिए, यह एक्स , एम + एन बार एफ को लागू करने के समान है।

हम देख सकते हैं कि यह पहली लागू करने के रूप में ही है च के लिए एक्स , एन बार, और फिर लागू करने के च जिसके परिणामस्वरूप आइटम पर मीटर बार।

उदाहरण के लिए, 2 का अर्थ होगा f(f(x))और 3 का अर्थ होगा f(f(f(x))), इसलिए 2 + 3 होगा f(f(f(f(f(x)))))।

F को x , n समय पर लागू करने के लिए , हमारे पास n f x है ।

आप अनौपचारिक रूप से दो तर्क लेते हुए m और n कार्यों को देख सकते हैं ।

फिर, हम इस परिणामी आइटम पर फिर से एफ लागू करते हैं , एम बार: एम एफ ( एन एफ एक्स )।

फिर, हम λ m को प्राप्त करने के लिए बॉयलरप्लेट को वापस जोड़ते हैं । λ एन । λ च । λ x । m f ( n f x )।

---

अब, हमें इसे डी ब्रूजन इंडेक्स में बदलना होगा ।

सबसे पहले, हम लैम्बडा घोषणा के प्रत्येक चर के बीच "सापेक्ष दूरी" की गणना करते हैं। उदाहरण के लिए, मी की दूरी 4 होगी, क्योंकि इसे 4 लंबोदा "पहले" घोषित किया गया है। इसी तरह, n की दूरी 3 होगी, f की दूरी 2 होगी, और x की दूरी 1 होगी।

तो, हम इसे इस मध्यवर्ती रूप में लिखते हैं: λ m । λ एन । λ च । λ x । 4 2 (3 2 1)

फिर, हम चर घोषणाओं को हटा देते हैं, हमें छोड़कर: λ λ λ λ 4 2 (3 2 1)

---

अब, हम इसे बाइनरी लैम्ब्डा कैलकुलस में बदल देते हैं ।

नियम हैं:

• λ बन जाता है 00।
• m n (समूहीकरण) बन जाता है 01 m n।
• संख्या मैं 1 i बार + बन जाता है 0, उदाहरण के लिए 4 बन जाता है 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

Comments

मैं 4.125 बाइट स्रोत फ़ाइल देखना चाहूंगा जिसे आप दुभाषिया / संकलक को पास करते हैं।

— मार्टिन एंडर

@MartinEnder यहां हर उत्तर के लिए कहें ।

— लीक नून

मैं एक 0.875 बाइट समाधान कृपया देखना चाहते हैं।

— मिस्टर लिस्टर

मेटा सर्वसम्मति से , जब तक आप प्रोग्राम को बाइट्स की एक आंशिक राशि के साथ फ़ाइल के रूप में संग्रहीत नहीं कर सकते, आपको गोल करना होगा।

— पावेल

Answer 4

आम लिस्प, 15 बाइट्स

(+(read)(read))

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है!

— डेनिस

मैं CLisp से अपेक्षाकृत अपरिचित हूं, लेकिन क्या रिक्त स्थान को निकालना संभव होगा? (+(read)(read))

— मेगो

@ मेगो तुम सही हो, यह संभव है। मुझे नहीं पता था कि क्योंकि मैं आम लिस्प में भी नया हूँ, जानकारी के लिए धन्यवाद! मैंने स्रोत का संपादन किया

— ब्योंगगन ली जूल

मुझे लगता है कि हम दोनों ने यहां कुछ सीखा है! PPCG में आपका स्वागत है!

— मेगो

Answer 5

स्टैक कैट्स , 8 + 4 = 12 बाइट्स

]_:]_!<X

-mnझंडे लेकर दौड़े। इसे ऑनलाइन आज़माएं!

स्टैक कैट्स में गोल्फिंग अत्यधिक प्रतिस्पद्र्धात्मक है, इसलिए ऊपर दिए गए इस कार्यक्रम को कुछ दिनों की क्रूरता के साथ पाया गया। तुलना के लिए, *(...)>टेम्पलेट का उपयोग करते हुए एक अधिक सहज, मानव-लिखित समाधान दो बाइट्स लंबा है

*(>-_:[:)>

-lnइसके बजाय झंडे के साथ (स्पष्टीकरण के लिए इस पोस्ट के नीचे देखें)।

व्याख्या

यहाँ स्टैक बिल्लियों पर एक प्राइमर है:

• स्टैक कैट एक प्रतिवर्ती गूढ़ भाषा है जहां एक स्निपेट का दर्पण मूल स्निपेट के प्रभाव को कम करता है। कार्यक्रम स्वयं की दर्पण छवियां भी होनी चाहिए - आवश्यक रूप से, इसका मतलब यह है कि सम-लंबाई कार्यक्रम या तो नो-ऑप्स या अनंत लूप हैं, और सभी गैर-तुच्छ समाप्ति कार्यक्रम विषम लंबाई के हैं (और अनिवार्य रूप से केंद्रीय ऑपरेटर का एक संयुग्मन हैं)।
• चूंकि आधा कार्यक्रम हमेशा निहित होता है, इसलिए आधे को ध्वज -mया -lध्वज के साथ छोड़ा जा सकता है । यहां -mध्वज का उपयोग किया जाता है, इसलिए ऊपर दिया गया आधा कार्यक्रम वास्तव में फैलता है ]_:]_!<X>!_[:_[।
• जैसा कि इसके नाम से पता चलता है, स्टैक कैट्स स्टैक-आधारित है, स्टैक ज़ीरो के साथ अथाह है (यानी एक अन्यथा खाली स्टैक रिटर्न 0 पर संचालन)। ढेर बिल्लियों वास्तव में ढेर, जैसे की एक टेप का उपयोग करता है <और >सही क्रमशः एक ढेर छोड़ दिया और एक ढेर चलते हैं।
• ढेर के तल पर स्थित जीरो को निगल / हटा दिया जाता है।
• सभी इनपुट को प्रारंभिक इनपुट स्टैक पर धकेल दिया जाता है, जिसमें पहला इनपुट शीर्ष पर होता है और अंतिम इनपुट के नीचे एक अतिरिक्त -1 होता है। वर्तमान स्टैक की सामग्री का उपयोग करके अंत में आउटपुट किया जाता है (नीचे एक वैकल्पिक -1 को अनदेखा किया जा रहा है)। -nसांख्यिक I / O को दर्शाता है।

और यहाँ विस्तारित पूर्ण कार्यक्रम का एक निशान है ]_:]_!<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+bफिर आउटपुट किया जाता है, बेस -1 को नजरअंदाज कर दिया जाता है। ध्यान दें कि इस समाधान के बारे में सबसे मुश्किल हिस्सा यह है कि आउटपुट स्टैक -1में सबसे नीचे होना चाहिए , अन्यथा बस के आउटपुट स्टैक [-1]आधार -1 को अनदेखा कर देगा, और आउटपुट स्टैक के [0]कारण आधार शून्य निगल जाएगा (लेकिन एक आउटपुट [2]उदाहरण के लिए, स्टैक आउटपुट 2ठीक होगा)।

---

बस मज़े के लिए, यहां एक ही लंबाई के संबंधित समाधानों की पूरी सूची मिली (सूची पूरी नहीं हो सकती है):

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

*(>-_:[:)>समाधान लंबे समय तक है, लेकिन अधिक के बाद से इसे इस्तेमाल करता है लिखने के लिए सहज है *(...)>टेम्पलेट। यह टेम्प्लेट ध्वज के <(...)*(...)>साथ उपयोग किए जाने पर फैलता है -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

जैसे, *(...)>टेम्प्लेट का मतलब है कि पहला लूप छोड़ दिया गया है लेकिन दूसरा निष्पादित किया गया है। यह अधिक सरल प्रोग्रामिंग करने की अनुमति देता है, क्योंकि हमें कार्यक्रम के दूसरे भाग में लूप के प्रभावों के बारे में चिंता करने की आवश्यकता नहीं है।

इस मामले में, लूप के अंदर है:

>       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

>टेम्पलेट में अंतिम तो हमें इनपुट स्टैक पर वापस ले जाता है, जहां आउटपुट किया a+bजाता है।

Answer 6

ब्रेन-फ्लैक , 6 बाइट्स

({}{})

इसे ऑनलाइन आज़माएं!

ब्रेन-फ्लैक वास्तव में एक दिलचस्प भाषा है, जिस पर दो प्रमुख प्रतिबंध हैं।

1. केवल मान्य वर्ण कोष्ठक हैं, अर्थात इनमें से कोई भी वर्ण:

   (){}[]<>
   

2. कोष्ठक के हर एक सेट को पूरी तरह से मिलान किया जाना चाहिए, अन्यथा कार्यक्रम अमान्य है।

उनके बीच कुछ नहीं के साथ कोष्ठक का एक सेट "निलाद" कहा जाता है। एक निलाद एक निश्चित संख्यात्मक मूल्य बनाता है, और एक दूसरे के बगल में इन सभी निलाद को जोड़ा जाता है। उनके बीच कुछ के साथ कोष्ठक का एक सेट "मोनड" कहा जाता है। एक मोनाड एक फ़ंक्शन है जो एक संख्यात्मक तर्क लेता है। तो एक भिक्षु के अंदर कोष्ठक का मूल्यांकन किया जाता है, और यह कि भिक्षु का तर्क है। यहाँ एक और अधिक ठोस उदाहरण है।

() Nilad के बराबर होती है 1. तो निम्नलिखित मस्तिष्क आलोचना कोड:

()()()

3. मूल्यांकन किया जाता है। वैश्विक स्टैक पर () मोनाड इसके अंदर के मूल्य को धक्का देता है। तो निम्नलिखित

(()()())

एक धक्का 3. {}निलाद स्टैक के शीर्ष पर मूल्य पॉप करता है। चूंकि लगातार निलाड्स को हमेशा जोड़ा जाता है, {}स्टैक पर सभी शीर्ष तत्वों की एक स्ट्रिंग । तो मेरा कोड अनिवार्य रूप से है:

push(pop() + pop())

Answer 7

Minecraft 1.10.x, 924 512 बाइट्स

@ के लिए धन्यवाद Quat 48 अंकों की blytecount और 412 से bytecount को कम करने के लिए।

ठीक है, इसलिए, मैंने इस उत्तर से कुछ विचार लिए और अपना खुद का एक संस्करण बनाया, सिवाय इसके कि यह गैर-नकारात्मक इनपुट को स्वीकार करने में सक्षम है। एक संस्करण यहां संरचना ब्लॉक प्रारूप में पाया जा सकता है ।

(नया संस्करण थोड़े उबाऊ tbh दिखता है)

अन्य उत्तर के समान आदेश:

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"}}

इनपुट संख्या के लिए, गायों और सूअरों की संख्या में स्पॉन। गाय मूल्य "एन" का प्रतिनिधित्व करेंगी और सूअर मूल्य "एम" का प्रतिनिधित्व करेंगे। कमांड ब्लॉक प्रणाली गायों और सूअरों को उत्तरोत्तर मार डालेगी और आवश्यकतानुसार मान प्रदान करेगी।

यह उत्तर मानता है कि आप एक ऐसी दुनिया में हैं, जिसमें प्राकृतिक रूप से गायों या सूअरों की संख्या नहीं है और प्रत्येक रन पर "n" और "m" में संग्रहीत मान साफ ​​हो जाते हैं।

Comments

नकारात्मक पूर्णांकों के लिए, आप 2 अन्य प्रकार के जानवरों को "नेगनिमल" के रूप में उपयोग कर सकते हैं - उदाहरण के लिए 5 घोड़े -5 का प्रतिनिधित्व कर सकते हैं।

— मेगो

@Mego तो यह चार इनपुट होगा, न कि 2.

— एडिसन क्रम्प

यह अभी भी दो इनपुट होगा - यह नकारात्मक संख्याओं के लिए दो के पूरक का उपयोग करने के बराबर है। थोड़ा अलग प्रारूप, लेकिन अभी भी एक इनपुट। कम से कम, कि मेरे दो सेंट है।

— मेगो

का उपयोग करके ब्लॉकों को बचाने में सक्षम हो सकता है execute @e[type=Pig] ~ ~ ~ scoreboard players add m a 1, इसलिए आपको घड़ी के किसी भी रूप की आवश्यकता नहीं है।

— क्वेट

@quat ऊह। अच्छा लगा।

— Addison Crump

Answer 8

रेटिना , 42 बाइट्स

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

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

इसे ऑनलाइन आज़माएं!

व्याख्या

यूनिरी में संख्याओं को जोड़ना दुनिया की सबसे आसान बात है, लेकिन एक बार जब आप नकारात्मक संख्याओं को पेश करते हैं, तो चीजें पूरी हो जाती हैं ...

\d+
$*

हम संख्याओं को एकता में परिवर्तित करके शुरू करते हैं। यह प्रत्येक संख्या के साथ मिलान करके \d+और उसके साथ प्रतिस्थापित करके किया जाता है $*। यह रेटिना-विशिष्ट प्रतिस्थापन विशेषता है। पूर्ण वाक्य रचना है count$*characterऔर की countप्रतियां सम्मिलित करता है character। उन दोनों को छोड़ दिया जा सकता है जहां countचूक $&(यानी मैच ही) और characterचूक हो सकती है 1। इसलिए प्रत्येक इनपुट के लिए nहम प्राप्त करते nहैं, और हमारे पास अभी भी संभावित शून्य संकेत हैं, साथ ही साथ अंतरिक्ष विभाजक भी। जैसे इनपुट 8 -5देता है:

11111111 -11111

अब नकारात्मक संख्याओं से निपटने के लिए एक अलग -1अंक का उपयोग करना सबसे आसान है । हम -उस उद्देश्य के लिए उपयोग करेंगे ।

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

यह अवस्था दो काम करती है। यह अंतरिक्ष से छुटकारा दिलाता है, प्रमुख ऋण चिह्न, और खुद 1में एक ऋण चिह्न के बाद एस बदल जाता है -। यह मिलान |-1+(यानी या तो एक स्थान या एक नकारात्मक संख्या) द्वारा किया जाता है और इस पर लिप्यंतरण किया जाता है। लिप्यंतरण से जाता 1pहै -_, लेकिन यहाँ, pसभी मुद्रण योग्य ASCII वर्णों का _अर्थ है और हटाएं। तो 1उन मैचों में s s में बदल जाते हैं -और minuses और रिक्त स्थान निकल जाते हैं। हमारा उदाहरण अब इस तरह दिखता है:

11111111-----

+`.\b.

यह चरण उस मामले को संभालता है जहां इनपुट में एक सकारात्मक और एक नकारात्मक संख्या होती है। यदि ऐसा है, तो स्ट्रिंग में 1एस और -एस होंगे और हम उन्हें रद्द करना चाहते हैं। यह उनके बीच एक शब्द-सीमा के साथ दो वर्णों का मिलान करके किया जाता है (क्योंकि 1s को एक वर्ण वर्ण माना जाता है और -ऐसा नहीं किया जाता है), और मैच की जगह कुछ भी नहीं है। +रेटिना को बार-बार ऐसा करने का निर्देश देता है जब तक कि स्ट्रिंग बदलना बंद न हो जाए।

अब हम केवल 1 s या केवल - s के साथ बचे हैं ।

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

इसे वापस दशमलव में बदलने के लिए, हम पूरे इनपुट से मेल खाते हैं, लेकिन यदि संभव हो तो हम -समूह में कब्जा कर लेते हैं 1। हम वापस समूह लिखते हैं 1(एक -नकारात्मक संख्याओं के लिए) और फिर हम मैच की लंबाई के साथ वापस लिखते हैं $.&(एक रेटिना-विशिष्ट प्रतिस्थापन विशेषता भी)।

Comments

यह बहुत चालाक है।

— मेगो

अब यदि केवल rangeरेटिना को लागू करने का एक आसान तरीका था । मैंने कुछ बार कोशिश की है, लेकिन नकारात्मक एक दर्द है।

— mbomb007

इस भाषा में दो नंबर जोड़ने के लिए 40 से अधिक बाइट्स लगते हैं ??

— dkudriavtsev

@DmitryKudriavtsev अच्छी तरह से, रेटिना में संख्याओं की कोई अवधारणा नहीं है ...

— मार्टिन

@DmitryKudriavtsev, और यह सिर्फ पूर्णांक है ....

— msh210

Answer 9

डोमिनोज़ , 38,000 बाइट्स या 37 टाइलें

यह टैबलेटटॉप सिम्युलेटर में बनाया गया है । यहाँ एक वीडियो है और यहाँ फ़ाइल है । यह एक मानक आधा योजक है, जो स्थान मूल्य के andलिए एक गेट से बना है 2^1और स्थान मूल्य के xorलिए एक गेट है 2^0।

विवरण

• आई / ओ
  • प्रारंभ - यह स्पष्टता के लिए शामिल है (कुल की ओर नहीं गिना जाता है) और यह 'कॉल' या फ़ंक्शन को 'निष्पादित' करता है। इनपुट [येलो] दिए जाने के बाद 'दबाया' जाना चाहिए ।
  • इनपुट ए - यह स्पष्टता के लिए शामिल है (कुल की ओर नहीं गिना जाता है) और संकेतित करने के लिए 'दबाया जाता है' और ' ग्रीन ' के लिए 1अप्रकाशित है ।0
  • इनपुट बी - यह स्पष्टता के लिए शामिल है (कुल की ओर गिना नहीं गया है) और ' ब्लू ' के लिए ए 1और अनप्रेस्ड को 'दबाया' जाता है ।0
  • आउटपुट - यह कुल की ओर गिना जाता है। ये डोमिनोज़ राशि घोषित करते हैं। बाईं 2^1और दाईं ओर 2^0 [ब्लैक] है ।
• दबाना
  • इनपुट देने या श्रृंखला शुरू करने के लिए, धातु संगमरमर को स्पॉन करें
  • करने के लिए लिफ्ट ताकत सेट करें 100%
  • वांछित डोमिनोज के ऊपर संगमरमर उठाएं
  • संगमरमर गिरा दो

Comments

... कैसे?

— dkudriavtsev

@ मेंडेलीव एक बार जब आपके पास सभी बाइनरी लॉजिक गेट होते हैं , तो बाकी सब जगह एक्सडी में गिर जाता है।

— नॉनलाइनयरफ्रूट

Answer 10

हास्केल, 3 बाइट्स

(+)

कोष्ठक यहाँ हैं क्योंकि इसे एक उपसर्ग कार्य करने की आवश्यकता है। यह + फ़ंक्शन के एक सेक्शन को लेने के समान है, लेकिन कोई तर्क लागू नहीं किया जाता है। यह कई प्रकारों पर भी काम करता है, जैसे कि ठीक से लागू किए गए वैक्टर, मैट्रिक, कॉम्प्लेक्स नंबर, फ़्लोट्स, डबल्स, रैशनल और निश्चित रूप से इंटेगर।

क्योंकि यह हास्केल है, यहां यह बताया गया है कि यह टाइप-लेवल पर कैसे किया जाता है। यह रन टाइम के बजाय संकलन समय पर किया जाएगा:

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

कोड हास्केल विकी से अनुकूलित

Comments

मजेदार तथ्य: यह चेडर के साथ एक

— बहुभुज है

Answer 11

गणितज्ञ, 4 2 बाइट्स

Tr

_{4 पार किया गया अभी भी नियमित 4 है ...} Tr एक-आयामी सूची पर लागू होने पर, सूची के तत्वों का योग होता है।

Answer 12

डीसी, 2 बाइट्स

+f

स्टैक पर शीर्ष दो आइटम जोड़ता है (पहले से लिया गया है stdin), फिर स्टैक की सामग्री को डंप करता है stdout।

संपादित करें: आगे विचार करने पर, ऐसा लगता है कि इसे लागू करने के कई तरीके हैं, जो वांछित I / O व्यवहार पर निर्भर करता है।

+        # 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

मुझे लगता है कि राशि के लिए सबसे पूर्ण रूप यह होगा:

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

रुको! एक स्थान से अलग होने पर एक ही लाइन पर दो नंबर लिए जा सकते हैं! यह हमें देता है:

?+p

Comments

मैं यह नहीं देख सकता कि पहले उदाहरण का उपयोग कैसे करें +f, dc -e "?+p"यहाँ ठीक काम करता है।

— जैसन

@Jasen +fसंस्करण काम करता है यदि आप पहले से ही (बिल्कुल दो) संख्याएँ स्टैक पर रखते हैं। मैं वास्तव में नहीं जानता था कि dcमैं / ओ माना जाता हूं std(in|out)या स्टैक। रेट्रोस्पेक्ट में, पोस्ट के शीर्ष पर रखने के लिए यह सबसे कम समझदार विकल्प था। : /

— जो

नियम कहते हैं कि स्टैक ठीक है जहां तक ​​मैं बता सकता हूं,

— जैसन

Answer 13

शेक्सपियर प्रोग्रामिंग लैंग्वेज , 155 152 बाइट्स

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

Ungolfed:

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]

मैं इस संकलन के लिए drsam94 के SPL कंपाइलर का उपयोग कर रहा हूं । परीक्षा करना:

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

Answer 14

ब्रेकीलॉग , 2 बाइट्स

+.

इनपुट के रूप में दो नंबरों के साथ एक सूची की अपेक्षा करता है

वैकल्पिक रूप से, यदि आप इसका उत्तर चाहते हैं STDOUT:

+w

Answer 15

जावास्क्रिप्ट (ईएस 6), 9 बाइट्स

a=>b=>a+b

Comments

मुझे नहीं लगता है कि एक नेस्टेड फ़ंक्शन जावास्क्रिप्ट में एक दो-इनपुट फ़ंक्शन के रूप में गिना जाता है

— गर्व हैस्केलर

@proudhaskeller हाँ यह करता है

— पैट्रिक रॉबर्ट्स

यह C # में भी काम करता है।

— ग्रैक्स 32

Answer 16

PHP, 20 बाइट्स

आश्चर्यजनक रूप से इस बार कम:

<?=array_sum($argv);

कमांड लाइन से चलाता है, जैसे:

$ php sum.php 1 2

Comments

यदि आपकी स्क्रिप्ट ठीक है php sum.php 1 2 3 4 5 6तो मैं 100% सुनिश्चित नहीं हूं।

— तैमूरकाल

@timmyRS प्रस्तुत करने के लिए एक विशिष्ट इनपुट प्रारूप के लिए काम करना चाहिए - दो पूर्णांक। मुझे नहीं लगता कि इसे अन्य इनपुट को भी संभालना चाहिए।

— सम्मिलित

क्या होगा अगर स्रोत फ़ाइल नाम एक अंक के साथ शुरू होता है? :)

— एलेक्स हॉवानस्की

@AlexHowansky Psssssssst - किसी को मत बताना। ;) यह क्विक है, जब किसी फ़ाइल से चल रहा है। आप अभी भी इसे -rध्वज का उपयोग करके निष्पादित कर सकते हैं - फिर यह अब कोई समस्या नहीं है।

— सम्मिलित

Answer 17

चेडर, 3 बाइट्स

(+)

यह Cheddar की एक अच्छी विशेषता है जिसे "फंक्शनल ऑपरेटर्स" कहा जाता है। इस विचार का श्रेय @ CᴏɴᴏʀO'B to को जाता है।

यहाँ पर परिचालित ऑपरेटरों के और अधिक उदाहरण हैं:

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

Answer 18

अजगर, 11 3 बाइट्स

sum

---

int.__add__

एक साधारण विशेष ऑपरेटर।

Answer 19

ज्यामिति डैश - 15 वस्तुएं

आख़िरकार हो गया।
15 वस्तुएं बहुत ज्यादा नहीं हैं, लेकिन ऐसा करने के लिए अभी भी एक बुरा सपना था (विशेषकर नकारात्मक संख्याओं के कारण)।

क्योंकि मुझे इसे पुन: पेश करने के लिए 15 चित्र डालने होंगे, मैंने अभी स्तर अपलोड किया है। स्तर आईडी 5216804 है। विवरण आपको बताता है कि इसे कैसे चलाना है और आप इसे कॉपी कर सकते हैं क्योंकि यह प्रतिलिपि योग्य है।

स्पष्टीकरण:

शीर्ष-बायें ट्रिगर (इंस्टेंट काउंट 2) की जाँच की जाती है यदि पहला ऐडिड 0. था। यदि यह था, तो यह जाँच करता है कि दूसरा ऐड पॉजिटिव था या नेगेटिव। यदि यह सकारात्मक था, तो इसने दूसरे परिशिष्ट से मूल्य (बीएफ-शैली, लूप का उपयोग करके) को स्थानांतरित कर दिया और यदि यह नकारात्मक था, तो यह वही काम करेगा।

दूसरा व्यंजक सकारात्मक या नकारात्मक होने के कारण हमें यह जाँचने की आवश्यकता है कि हमें दूसरे व्यसनी से एक घटाना होगा और एक योग जोड़ना होगा या एक दूसरे योजक को जोड़ना होगा और एक योग को क्रमशः जोड़ना होगा।

यदि पहला ऐड शून्य नहीं है, तो यह परीक्षण करता है कि यह ऊपर की प्रक्रिया का उपयोग करके सकारात्मक या नकारात्मक है। जबकि लूप में एक पुनरावृत्ति के बाद, यह देखने के लिए परीक्षण करता है कि क्या पहला जोड़ शून्य है और यदि यह है, तो यह स्पष्टीकरण की शुरुआत में वर्णित प्रक्रिया को करता है।

चूंकि ज्यामिति डैश उल्लेखनीय रूप से BF के समान है, इसलिए आप इसमें से BF समाधान बना सकते हैं।

Answer 20

MATL, 1 बाइट

s

इनपुट के रूप में दो पूर्णांकों की एक सरणी स्वीकार करता है और उन्हें रकम देता है। जबकि सरल कार्यक्रम +भी काम करता है, जो पहले से ही अन्य भाषाओं के लिए दिखाया गया है।

इसे ऑनलाइन आज़माएं

Answer 21

पर्ल 5.10, 8 बाइट्स

जोड़ने के लिए दो नंबरों को एक के लिए 2 अलग-अलग लाइनों पर होना चाहिए:

say<>+<>

यहाँ यह एक कोशिश करो।

उसी लाइन पर इनपुट के साथ एक ( 14 + 1 बाइट्स के लिए -a झंडा )

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

यहाँ यह कोशिश करो!

उसी लाइन पर इनपुट के साथ एक ( 19 + 1 बाइट्स के लिए -a झंडा )

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

यहाँ यह एक कोशिश करो।

एक और एक, ऐरे डिफॉल्ट सेपरेटर को बदलकर ( 19 + 1 बाइट्स के लिए -a फ़्लैग )

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

यह यहाँ एक कोशिश करो!

Comments

अरे, एक और अच्छा उदाहरण (यदि यह एक कैटलॉग चुनौती होगी) तो इस पोस्ट में डेनिस द्वारा बताई गई विधि है: ध्वज का उपयोग करके codegolf.stackexchange.com/q/32884 (ab) -p।

— डोम हेस्टिंग्स

इसके बजाय say$F[0]+$F[1], say pop()+popकाम करता है (स्ट्रॉबेरी में परीक्षण 5.20.2 के साथ -E) और आपको एक बाइट बचाता है।

— msh210

Answer 22

फजी ऑक्टो गुआकामोल , 1 बाइट

a

एक फ़ंक्शन जो स्टैक के शीर्ष से इनपुट लेता है और स्टैक को धक्का देकर आउटपुट करता है।

REPL में चल रहा उदाहरण:

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

Answer 23

बैच, 25 18 16 बाइट्स

@cmd/cset/a%1+%2

संपादित करें: वैकल्पिक साइन अनुक्रम से मेरी चाल का उपयोग करके 7 9 बाइट्स को बचाया ।

Answer 24

PowerShell v2 +, 17 बाइट्स

$args-join'+'|iex

इनपुट को दो अलग-अलग कमांड-लाइन तर्कों के रूप में लेता है, जो विशेष सरणी में पूर्व-आबादी प्राप्त करते हैं $args। हम -joinऑपरेटर +को बीच में एक साथ समेट कर एक स्ट्रिंग बनाते हैं, फिर उस स्ट्रिंग को Invoke-Expression(इसी तरह eval) पाइप करें ।

---

मुझे याद दिलाने के लिए @DarthTwon का धन्यवाद कि इस तरह के न्यूनतम कार्यक्रमों से निपटने के दौरान एक ही बाइट-काउंट पर इनपुट लेने के कई तरीके हैं।

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

पॉवरशेल कुछ भी नहीं है अगर लचीला नहीं है।

Comments

हाँ, मैं यहाँ आपको $args[0]+$args[1]param($a,$b)$a+$b

— घूर

Answer 25

> <> , 7 6 3 बाइट्स

+n;

ऑनलाइन दुभाषिया

या इसे -v ध्वज के साथ TIO पर आज़माएं।

इसे ऑनलाइन आज़माएं

Comments

चूंकि प्रश्न आपको एक फ़ंक्शन को परिभाषित करने देता है, मेरा मानना ​​है कि एक सरल +पर्याप्त होगा: यह स्टैक से दो नंबर पॉप करेगा और स्टैक पर उनके जोड़ का परिणाम वापस डाल देगा। -vफंक्शन इनवोकेशन से पहले नंबरों को पढ़ने से लागत से भी बचा जा सकता था।

— हारून

@ ऐरन: सच। लेकिन उस समाधान के रूप में पहले से ही कई अन्य भाषाओं के लिए पोस्ट किया गया है पहले से ही मैं इसे एक पूर्ण कार्यक्रम के रूप में रखूंगा।

— एमिगा जूल

मैंने सोचा था कि v झंडा अधिकतम +1 बाइट होगा, लेकिन या तो आप fishlanguage.com इंटरप्रेटर का उपयोग कर सकते हैं और आपका कुल 3 बाइट होगा (इसे -v की आवश्यकता नहीं है)।

— रेडस्टारकोडर 15

@redstarcoder: हर कोई हमेशा ध्वज को मछली के लिए 3 बाइट्स (और अन्य सभी भाषाओं के लिए 1 बाइट) के रूप में निर्दिष्ट करता है। यकीन नहीं है कि यह अलग क्यों है, लेकिन मुझे लगता है कि यह एक वैध कारण के लिए है।

— एमिग्ना

भले ही, आप ध्वज की जरूरत नहीं है अगर आप बस fishlanguage.com दुभाषिया का उपयोग करें। क्या आपके पास मेटा का लिंक है? मैंने कोई भी नहीं देखा है <<> प्रारंभिक स्टैक पर पूर्णांक का उपयोग करने के लिए प्रोग्राम बाइट्स मिला (मैंने भी किया है)।

— redstarcoder

Answer 26

सी, 35 बाइट्स

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

मैंने जो यहां किया है वह बूलियन या अंकगणितीय ऑपरेटरों के उपयोग के बिना परिभाषित किया गया है। यह पुनरावर्ती रूप से x को 'xor' द्वारा सम बिट बनाता है, और कैरी बिट्स को 'और' तक ले जाता है जब तक कोई कैरी नहीं होता है। यहाँ ungolfed संस्करण है:

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);
}

Comments

आप सीधे क्यों नहीं जोड़ते हैं?

— फल

मैंने पाया कि उबाऊ होना, पूरी तरह से गोल्फ संस्करण तुच्छ है।

— बिजन

"सभी उत्तरों को बेहतर स्कोर तक पहुंचने के लिए कुछ प्रयास दिखाने चाहिए। उदाहरण के लिए, कोड गोल्फ चुनौतियों के उत्तर यथासंभव (चुने हुए भाषा की बाधाओं के भीतर) कम से कम होने की कोशिश करनी चाहिए।" ( codegolf.meta.stackexchange.com/a/7073/61384 से )

— फल

जाहिर है कि मैंने केवल संख्याओं को जोड़ने के बारे में सोचा था, और मैंने इसे वैकल्पिक संयम के तहत, इसे छोटा बनाने में प्रयास किया। मुझे लगता है कि चूंकि यह एक अपरंपरागत प्रश्न है, यह एक अपरंपरागत उत्तर के योग्य है। शब्द के लिए उस नियम शब्द का अनुसरण करते हुए, कभी कोई जवाब देने का कोई कारण नहीं होगा यदि किसी ने पहले से ही एक छोटा डाल दिया है। यदि आप अपने 20 बाइट अजगर समाधान और किसी को पहले से ही एक 4 बाइट संस्करण है तो आप साबित कर रहे हैं कि आप नहीं जानते कि कैसे कॉपी और पेस्ट करना है। लोग 20 बाइट समाधान करते हैं, क्योंकि हम मौलिकता को महत्व देते हैं।

— बिजन

यह निहित है कि यह उस भाषा में प्रतिस्पर्धी है जिसे आप चुन रहे हैं। हालाँकि, मेटा पर पढ़ने के बाद, ऐसा लगता है कि मैं यह दावा नहीं कर सकता कि आपका उत्तर अमान्य है ("एक उत्तर किसी भी एल्गोरिथ्म को लागू कर सकता है, भले ही गोल्फ खिलाड़ी मौजूद हों"), इसलिए मुझे लगता है कि मैं इसे छोड़ दूँगा।

— एगलैंगिंग फ्रूट

Answer 27

MATLAB, 4 बाइट्स

1 बाइट @LeakyNun के लिए धन्यवाद हटा दिया गया

@sum

यह एक अनाम फ़ंक्शन है जो एक सरणी लेता है और योग देता है। उदाहरण का उपयोग करें:

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

Comments

किस बारे में sum?

— लीक नून

@LeakyNun धन्यवाद, अच्छा विचार!

— लुइस मेंडू

43 बाइट्स? xD BTW: मैंने सोचा कि हमारे पास पूरा कार्यक्रम या एक समारोह होना चाहिए , इसलिए मैं कहूंगा कि केवल @sumएक मान्य उत्तर है। या एक और मेटा आम सहमति है?

— दोष

@flawr मुझे लगता है कि हाँ है। लेकिन मैं इसे नहीं पा सका

— लुइस मेंडो

Wooah, मैंने आपको ४३ से ४ बाइट्स XD तक कम करने में मदद की

— दोष

Answer 28

GoLScript , 1 बाइट (गैर-प्रतिस्पर्धात्मक)

K

स्टैक पर शीर्ष 2 नंबर जोड़ता है। बस।

अब उन्हें स्टैक पर कैसे धकेलना है , मुझे कोई सुराग नहीं है। मुझे नहीं लगता कि यह संभव है .. खांसी @ CᴏɴᴏʀO'B। खांसी

Comments

Explanation soon to be coming.- राइकर जुलाई 3 '16

— एमडी एक्सएफ

जीवन के खेल के लिए +1।

— HighlyRadioactive

Answer 29

शेक्सपियर प्रोग्रामिंग लैंग्वेज (एसपीएल), 137 135 बाइट्स

पूरा कार्यक्रम, गोल्फ:

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

और एक संक्षिप्त विवरण:

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

मुझे यकीन नहीं है कि यह सबसे छोटा है जो यह जा सकता है। अधिक जानकारी के लिए आधिकारिक पृष्ठ देखें।

संपादित करें 1: के :बाद हटा दिया Act Iऔर Scene Iजैसा कि लगता है कि रोमन अंक के बाद सब कुछ नजरअंदाज कर दिया है, इस प्रकार 2 बाइट्स की बचत।

Comments

यह मान्य नहीं है। पात्रों को शेक्सपियर के नाटकों में से होना चाहिए और वहाँ होना चाहिए। इसके अलावा, आपको वर्णन के लिए प्रत्येक वर्ण के नाम के बाद अल्पविराम की आवश्यकता है।

— ओलिवर नी

Answer 30

x86_32 मशीन कोड, 2 बाइट्स

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

मान लें कि दो मान पहले से ही ecx और eax रजिस्टरों में हैं, ऐड इंस्ट्रक्शन का प्रदर्शन करने से दोनों रजिस्टर के वैल्यूज जुड़ेंगे और डेस्टिनेशन रजिस्टर में रिजल्ट स्टोर होगा।

आप यहां C और इनलाइन असेंबली में लिखा पूरा कार्यक्रम देख सकते हैं । C में रैपर लिखने से इनपुट प्रदान करना और परीक्षण करना आसान हो जाता है, लेकिन वास्तविक ऐड फंक्शन को इन दो बाइट्स तक कम किया जा सकता है।

Comments

यह एक फंक्शन नहीं है, सिर्फ एक स्निपेट है। आपको एक retनिर्देश (एक बाइट) भी चाहिए। और वह एक कस्टम कॉलिंग कन्वेंशन मान रहा है जहां eaxएक आर्ग-पासिंग रजिस्टर के रूप में उपयोग किया जाता है। (Irvine32 asm शिक्षण पुस्तकालय ऐसा करता है, लेकिन कोई मानक कॉलिंग कन्वेंशन x86-32 या x86-64 के लिए नहीं करता है, इसके विपरीत ARM पर जहां रिटर्न-वैल्यू रजिस्टर r0भी पहला arg-pass रजिस्टर है।) कस्टम कॉलिंग कन्वेंशन ठीक हैं। asm फ़ंक्शन हालांकि, इसलिए आपको इसे Microsoft या gcc के लिए 3 बाइट lea (%ecx, %edx), %eax+ 1 बाइट में बदलने की आवश्यकता नहीं है । ret__fastcall-mregparm

— पीटर कॉर्ड्स

यद्यपि यह एक स्टैक-आर्ग्स सम्मेलन के लिए एक दिलचस्प चुनौती है। popकेवल 1 बाइट है, लेकिन esp-relative एड्रेसिंग मोड में SIB बाइट की जरूरत होती है। तो एक फोन करने वाले पॉप-कन्वेंशन को कॉल कर सकता है pop %ecx(रिटर्न एड्रेस), pop %eax/ pop %edx/ add %edx, %eax(2 बाइट्स) / jmp *%ecx(2 बाइट्स) = 7 बाइट्स। बनाम mov 4(%esp), %eax(4 बी) / add 8(%esp), %eax(4 बी) / ret= 9 बाइट्स, या का उपयोग करते हुए इस बात का एक फोन करने वाले-पॉप्स संस्करण के लिए 11 बाइट्स ret imm16, अगर मैं यह सही था। यह आधार के रूप में ईएसपी के साथ एसआईबी के लिए एक अतिरिक्त 1 बाइट और प्रत्येक इंस में डिस्पे 8 के लिए एक अतिरिक्त 1 बाइट है।

— पीटर कॉर्ड्स