एलेक्स-शैली का जोड़


57

एलेक्स के शानदार से प्रेरित होकर आप बहुत अच्छे के लिए एक आर सीखें, हम विनम्रतापूर्वक एलेक्स के "एक सच्चे आर कार्यक्रम" को फिर से बनाने जा रहे हैं - लेकिन एक मोड़ के साथ।

एलेक्स-शैली का जोड़ इस तरह से काम करता है - इसमें दिए गए दो नंबरों के योग को वापस करने का 90% मौका है और पहले नंबर पर एलेक्सा-जोड़कर 10% मौका और दूसरा नंबर + 1. इसका मतलब है कि, संभवतः , एक जोड़ 1 या उससे अधिक हो सकता है।

चुनौती

एक पूर्ण प्रोग्राम या फ़ंक्शन लिखें जो दो पूर्णांक लेता है और एलेक्स-परिभाषित के रूप में उन्हें जोड़ता है। आप मान सकते हैं कि यदि आपकी भाषा में पूंछ की पुनरावृत्ति नहीं होती है तो आपका कार्यक्रम अतिप्रवाह नहीं होगा। (ध्यान दें कि आपको इसे पुनरावर्ती रूप से लागू करने की आवश्यकता नहीं है, जब तक कि संभावनाएं समान हैं।)

संदर्भ कार्यान्वयन (ग्रूवी)

int alexAdd(int a, int b) {
  int i = new Random().nextInt(11);
  if(i == 1) {
    return alexAdd(a,b+1);
  } else {
    return a + b;
  }
}

इस फिडेल को ऑनलाइन ट्राई करें।

लीडरबोर्ड

var QUESTION_ID=66522,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>


6
तो यह दो संख्याओं का योग देता है और साथ ही एक ज्यामितीय यादृच्छिक चर विफलता संभावना 1/10?
xnor

@xnor अनिवार्य रूप से, हाँ। मैंने इसे पुनरावर्ती रूप से परिभाषित किया ताकि इसे समझना आसान हो, लेकिन आपको इसे पुनरावर्ती रूप से करने की ज़रूरत नहीं है (उदाहरण के लिए CJam समाधान नहीं करता है)
एक

10
इस सैंडबॉक्स को 20 मिनट के लिए क्यों रखा गया था? यह सैंडबॉक्स की बात याद आ रही है।
पीटर टेलर

3
@PeterTaylor इसके साथ एक मामूली समस्या को लगभग तुरंत ठीक कर दिया गया था, और यह प्रश्न इतना आसान था कि मुझे नहीं लगा कि इसे लंबे समय तक सैंडबॉक्स में रहने की आवश्यकता है (यह पहले से ही 10 लोगों द्वारा देखा गया था जो मुझे लगा कि पर्याप्त सहकर्मी था। ऐसी सरल चुनौती के लिए समीक्षा)। सैंडबॉक्स में मेरे पास मुख्य कारण यह देखना था कि क्या लोगों को लगा कि यह बहुत सरल है।
एक

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

जवाबों:


40

अजगर,,

u+G!OTsQ

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

यह कम पर Pyth के दूसरे मोड का उपयोग करता है, जो बार-बार इनपुट के लिए देखता है फिर बाहर निकलता है।

व्याख्या

u+G!OTsQ  ##  Implicit: Q=eval(input())
u     sQ  ##  reduce with 2 arguments, which causes a loop until the reduce gets the
          ##  same argument twice
 +G       ##  lambda G,H: G + ...
   !OT    ##  boolean not of random value from 0 to 9 inclusive

यदि अतिरिक्त एलेक्स-ऐड होता है तो यह फिर से चलेगा, लेकिन यदि नहीं तो यह बाहर निकलता है।


13
यह ... शुद्ध काला जादू है। O_O
दरवाज़े

1
यह मज़ाकीय है।
बिल्ली

36

पायथन 2, 55 बाइट्स

from random import*
lambda a,b:a+b+18-len(`1+random()`)

यह इसे करने के लिए एक बिल्कुल विचित्र तरीका है।

समारोह random[0,1) में एक फ्लोट देता है, और डिफ़ॉल्ट रूप से इसके स्ट्रिंग प्रतिनिधित्व में दशमलव के बाद 16 अंक होते हैं, कुल 18 वर्णों के लिए। लेकिन, क्योंकि 0 से पीछे हटने पर छोड़ दिया जाता है, यह कम हो सकता है। अंत से अंकों को पढ़ना, प्रत्येक के पास 0 होने का 1/10 मौका होता है, और जब हम एक गैर-अंकीय अंक से टकराते हैं तो हम रुक जाते हैं। अलेक्सिंग मेक रिकर्स की संख्या की तरह ही ट्रेलिंग जीरो की संख्या भी वितरित की जाती है, इसलिए हम इस वितरण से 18 माइनस स्ट्रिंग स्ट्रिंग तक का नमूना ले सकते हैं।

दरअसल, पायथन छोटे अंकों के लिए 18 से अधिक अंक प्रदर्शित करेगा, कभी-कभी वैज्ञानिक संकेतन भी, इसलिए हम इसे ठीक करने के लिए 1 जोड़ते हैं।

यह कभी भी राशि से अधिक 15 नहीं देगा, लेकिन यह ठीक है क्योंकि 10 ^ 15 उस अवसर से बहुत कम है जहां एक कॉस्मिक किरण गणना को बाधित करता है


1
क्षमा करें, यह उत्तर अमान्य है, क्योंकि इसमें ठीक से काम न करने का 10 ^ -15 मौका है , जो स्पष्ट रूप से लिंक किए गए मेटा पोस्ट द्वारा निषिद्ध है।
पिपरी

22

आर, 60 47 28 बाइट्स

function(a,b)a+b+rgeom(1,.9)

यह एक अनाम फ़ंक्शन ऑब्जेक्ट है जो दो नंबरों को स्वीकार करता है और एक नंबर लौटाता है। यह पुनरावृत्ति का उपयोग नहीं करता है।

जैसा कि xnor ने एक टिप्पणी में बताया है, इस समस्या को केवल दो नंबरों के साथ जोड़कर देखा जा सकता है साथ ही एक ज्यामितीय यादृच्छिक चर विफलता संभावना 1/10।

क्यों सच है? पुनरावृत्ति के संदर्भ में इसके बारे में सोचें, क्योंकि यह पोस्ट में वर्णित है। प्रत्येक पुनरावृत्ति में हमारे पास 1 जोड़ने और पुनरावृत्ति करने का 10% मौका है, और बिना अतिरिक्त जोड़ के फ़ंक्शन से बाहर निकलने का 90% मौका है। प्रत्येक पुनरावृत्ति का अपना स्वतंत्र बर्नौली परीक्षण है, जिसमें "1 जोड़ें, पुनर्खरीद" (विफलता) और "निकास" (सफलता) के परिणाम हैं। इस प्रकार असफलता की संभावना 1/10 है और सफलता की संभावना 9/10 है।

स्वतंत्र बर्नौली परीक्षणों की एक श्रृंखला के साथ काम करते समय, एकल सफलता प्राप्त करने के लिए आवश्यक परीक्षणों की संख्या एक ज्यामितीय वितरण का अनुसरण करती है । हमारे मामले में, प्रत्येक पुनरावृत्ति का अर्थ है 1 जोड़ना, इसलिए जब हम अंततः फ़ंक्शन से बाहर निकलते हैं, तो हमने अनिवार्य रूप से पहली सफलता से पहले हुई विफलताओं की संख्या गिना है। इसका अर्थ यह है कि परिणाम जिस राशि से बंद होगा वह एक ज्यामितीय वितरण से एक यादृच्छिक चर है।

यहां हम आर के विस्तार योग्य निर्मित वितरण और उपयोग के आर के विस्तृत सूट का लाभ उठा सकते हैं rgeom, जो एक ज्यामितीय वितरण से एक यादृच्छिक मूल्य देता है।

Ungolfed:

f <- function(a, b) {
    a + b + rgeom(n = 1, prob = 0.9)
}

13

मिंकोलंग 0.14 , 19 11 12 बाइट्स

यह "फ़ंक्शन" संस्करण है; यह मानता है aऔर bपहले से ही स्टैक पर हैं, उन्हें बंद करता है और संशोधित संस्करण को धक्का देता है a+b। Minkolang में फ़ंक्शन के सबसे निकटतम समकक्ष का उपयोग करना है F, जो बंद हो जाता है b, aऔर कोडबॉक्स में कूदता है (a,b)। फिर जब प्रोग्राम काउंटर एक हिट करता है f, तो यह वापस कूदता है जहां Fउपयोग किया गया था।

(+$01$h`d)xf

यह पूर्ण प्रोग्राम संस्करण है, 15 बाइट्स । ( nnइनपुट से दो नंबर लेता है और N.परिणाम को आउटपुट देता है और रुक जाता है।)

nn(+$01$h`d)xN.

मैंने Doorknob के उत्तर से एल्गोरिथ्म चुरा लिया ; जबकि लूप दोहराता है जब तक उत्पन्न यादृच्छिक संख्या 0.1 से कम है, प्रत्येक बार 1 जोड़ रहा है। इसे यहाँ (पूरा प्रोग्राम संस्करण) आज़माएँ और इसे 100 बार यहाँ चलाएँ

व्याख्या

(              Open a while loop
 +             Adds the top two items of the stack
  $0           Pushes 0.1
    1$h        Pushes a random number between 0.0 and 1.0, inclusive
       `       Pops b,a and pushes a > b
        d      Duplicate the top of stack
         )     Close the while loop when the top of stack is 0
          x    Dump the extra, leading 0

यहां का सबसे चतुर हिस्सा है d। उस समय स्टैक का शीर्ष 0 या 1 होगा। यदि यह 0 है, जबकि लूप बाहर निकलता है। अन्यथा, यह जारी है। जैसा कि मैंने स्टैक के शीर्ष की नकल की है, यह [a+b,1]दूसरी बार लूप के माध्यम से होगा, इसलिए +शुरुआत में 1 जोड़ता है (और इसी तरह बाद की यात्राओं के लिए)।


क्या यह वास्तव में एक समारोह है? मैं जल्दी से भाषा प्रलेखन के माध्यम से स्कैन किया, और समारोह परिभाषाओं का वर्णन कुछ भी नहीं मिल सका। स्पष्टीकरण के आधार पर, यह कोड के टुकड़े की तरह दिखता है।
रेटो कोराडी

@RetoKoradi: मैं इस तरह के "कोड टुकड़ा" को अपनी लाइन पर रख सकता हूं, इसे 0kF (जहां k कुछ संख्या है) के साथ कूदें, और अंत में f के साथ वापस कूदें। यही कारण है कि आप Minkolang में एक समारोह के लिए निकटतम होंगे।
एलेंडिया स्टट्रान

2
क्या यह तकनीकी रूप से यह कहना पसंद नहीं है कि "मेरा सीजेएम कोड टुकड़ा एक फ़ंक्शन है? आपको बस इसे घुंघराले ब्रेसिज़ के साथ घेरना है"? बहुत कम से कम, आपको संभवतः fचार गिनती में अंत में शामिल होना चाहिए (और तकनीकी रूप से पूर्ववर्ती नई पंक्ति यदि आप अतिरिक्त-पांडित्य महसूस कर रहे हैं, लेकिन मुझे नहीं लगता कि यह आवश्यक है)।
दरवाज़े

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

@RetoKoradi: ठीक है, यह समझ में आता है। Doorknob के सुझाव से आप क्या समझते हैं?
एल'एंडिया स्ट्रैटन

12

सीजेएम, 12 11 बाइट्स

{{+Amr!}h;}

इस सुपर चालाक चाल के साथ एक बाइट को बचाने के लिए @ MartinBtter का धन्यवाद!

{         }
 {     }h    Do-while that leaves the condition on the stack.
  +          Add: this will add the numbers on the first iteration...
   Amr!      ... but a `1` (i.e. increment) on future ones.
         ;   Pop the remaining 0.

पुराना उत्तर:

{+({)Amr!}g}

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

स्पष्टीकरण:

{          }  A "function."
 +            Add the input numbers.
  (           Decrement.
   {     }g   A while loop.
    )         Increment.
     Amr      Random number [0,9).
        !     Boolean NOT.

बुनियादी एल्गोरिथ्म "जबकि (0.1 का मौका) है, संख्या में वृद्धि," जो पुनरावृत्ति की आवश्यकता को समाप्त करता है।


8

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

f=(a,b)=>Math.random()<.1?f(a,b+1):a+b

f=(a,b)=>new Date%10<1?f(a,b+1):a+b35 बाइट्स के लिए
वैलीवेस्ट

2
@WallyWest दुर्भाग्य से Dateटाइमस्टैम्प का उपयोग करते समय संभावना सटीक नहीं होगी क्योंकि अगर यह मूल्यांकन trueकरता है कि यह 1बाकी मिलीसेकंड के लिए जोड़ रहेगा ।
user81655

मैंने ज्यामितीय वितरण की कोशिश की, f=(a,b)=>a+b-~~Math.log10(Math.random())लेकिन यह 2 बाइट्स लंबा है।
नील

8

MATL , 14 13 12 बाइट्स

is`r.1<tb+w]

यह सिर्फ लूप विधि है, इनपुट जोड़ें (जैसा दर्ज किया गया है [a b]) फिर एक जोड़ते रहें जबकि 0 और 1 के बीच एक समान यादृच्छिक संख्या 0.1 से कम है। नीचे पूर्ण विवरण:

i         % input [a b]
s         % sum a and b
`         % do...while loop                                      
  r       % get a uniformly distributed pseudorandom numbers between 0 and 1       
  .1      % push 0.1 onto the stack                                   
  <       % is the random number less than 0.1?
  t       % duplicate the T/F values                                        
  b       % bubble a+b to the top of the stack                       
  +       % add the T/F to a+b     
  w       % swap elements in stack to get the other T/F back to exit/continue the loop                           
]         % end    

इनपुट युक्ति (से ) ii+को बदलकर 1 बाइट लिया is


पुराना तरीका 0 और 1 के बीच एक यादृच्छिक संख्या के आधार -10 लॉग को लेने पर आधारित था ताकि जोड़ने के लिए राशि का काम किया जा सके a+b, हालांकि यह केवल फ्लोटिंग पॉइंट सटीकता के कारण 15 पुनरावृत्ति तक काम करेगा।

iir10,2$YlZo-+

इस कोड में, 10,2$YlZo-यादृच्छिक संख्या का आधार -10 लघुगणक करता है और निकटतम पूर्णांक तक गोल होता है।


उचित टिप्पणी, हालांकि मैं आपको प्रस्तुत किए गए किसी अन्य समाधान के साथ 15 देखना चाहता हूं: पी बाइट्स के लिए एक और तरीका, सरल लूपिंग संस्करण है: ii+`10Yr1=tb+w]अभी तक गोल्फ नहीं हुआ है।
डेविड

वास्तव में मैं पाश कम कर सकते हैं! धन्यवाद @ThomasKwa!
डेविड

बहुत अच्छी तरह से किया!
लुइस मेंडू

7

बाइनरी-एन्कोडेड गोल्फिकल , 32 29 + 1 ( -xध्वज) = 30 बाइट्स

हेक्सडंप (मैन्युअल रूप से ट्रांसपिलर के इमेज-टू-बाइनरी हिस्से में बग के लिए सही करने के लिए संपादित किया गया है, जो तब से तय हो गया है):

00 B0 02 15 14 0C 01 14 15 14 1B 1E 3A 14 0C 01
14 00 0A 14 38 00 01 23 1D 4C 14 17 14

इस एन्कोडिंग को शामिल एनकोडर उपयोगिता का उपयोग करके मूल ग्राफिकल प्रतिनिधित्व में वापस परिवर्तित किया जा सकता है, या सीधे -xध्वज का उपयोग करके चलाया जा सकता है ।

मूल छवि: यहाँ छवि विवरण दर्ज करें

बढ़ाई 50x:

यहाँ छवि विवरण दर्ज करें

स्पष्टीकरण: शीर्ष पंक्ति मुख्य ब्लॉक है। यह एक संख्या पढ़ता है, इसे दाईं ओर कॉपी करता है, एक अन्य संख्या पढ़ता है, उन्हें जोड़ता है, परिणाम को दाईं ओर कॉपी करता है, कुछ RNG सामान करता है, और, संभावना 90% के साथ, इसके परिणाम को प्रिंट करता है। बाकी समय, इसे नीचे की पंक्ति में भेजा जाता है, जहां यह पहली सेल में एक डालता है और अतिरिक्त निर्देश से पहले मुख्य पंक्ति में वापस जाता है (उत्तर की ओर फिर एक पूर्वी मोड़ का उपयोग करके)।


2
क्या आप एक स्पष्टीकरण जोड़ सकते हैं? यह सुपर कूल है।
बिल्ली

7

पायथन, 66 65 64 63 बाइट्स

from random import*
g=lambda*s:randint(0,9)and sum(s)or g(1,*s)

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

सुधार और बाइट को बचाने के लिए शर्लक 9 को धन्यवाद।

एक और बाइट के लिए माथियास एटिंगर को धन्यवाद।

एक बाइट के लिए mbomb007 के लिए धन्यवाद।




@ ASCII-केवल का उपयोग करना .9>random()काफी नहीं 9-बाहर के 10, तैरता के असमान वितरण के कारण है
Mego

6

जूलिया, 30 बाइट्स

f(a,b)=rand()>0.9?f(a,b+1):a+b

यह एक पुनरावर्ती फ़ंक्शन है fजो दो संख्याओं को स्वीकार करता है और एक ही प्रकार के कई नंबर लौटाता है। यह किसी भी संख्यात्मक प्रकार के लिए ठीक काम करना चाहिए।

पहले हम जांचते हैं कि 0 और 1 के बीच एक यादृच्छिक फ्लोट 0.9 से अधिक है या नहीं। यदि ऐसा है, तो हम थोड़ा अतिरिक्त सोमेथिन 'सोमेथिन' के साथ पुनरावृत्ति करते हैं, अन्यथा हम बस जोड़ते हैं।


6

टीआई-बेसिक, 15 बाइट्स

While rand<.1
Ans+.5
End
sum(Ans

यह इनपुट को दो-तत्व सूची से के रूप में लेता है Ans। जबकि एक यादृच्छिक संख्या की तुलना में कम है 0.1, यह 0.5सूची में शामिल नहीं करता है। प्रत्येक तत्व में 0.5वृद्धि से योग बढ़ता है 1. मेरा मानना ​​है कि यह सबसे छोटा TI-BASIC समाधान है।

9-बाइट प्रोग्राम sum(Ans)-int(log(10randकाम नहीं करता है, क्योंकि इसमें randकेवल 14 अंको की सटीकता है, और इस प्रकार यह 10 -14 से कम संख्या नहीं दे सकता है ।


1
यह देखते हुए कि 14 को जोड़ने के लिए, आपको सूअरों को उड़ने और हेल फ्रीज को भी देखना होगा। और जब तक आप 14 जोड़ते हैं, तब तक मैंने अपने जीवन के साथ कुछ किया होगा।
निक हार्टले

5

एपीएल, 17 बाइट्स

{1=?10:⍺∇⍵+1⋄⍺+⍵}

यह एक अनाम डायैडिक फ़ंक्शन है।

Ungolfed:

{1=?10:            ⍝ If a random number between 1 and 10 is 1,
       ⍺∇⍵+1       ⍝ Recurse on the inputs with one incremented
            ⋄⍺+⍵}  ⍝ Otherwise return the sum of the inputs

5

पायथ, 14 12 बाइट्स

KsQW!OT=hK;K

मेरा पहला असली पायथ गोल्फ!

प्रारूप में STDIN पर इनपुट लेता है a,b

स्पष्टीकरण:

KsQ       read STDIN, assign sum to variable K
W         while...
  !OT       not rand(10)
  =hK;      increment K
K         implicit-output of K

धन्यवाद @FryAmTheEggman एक चर बढ़ाने के लिए मुझे एक छोटा रास्ता देकर दो चार्ट से शेविंग करने के लिए!


5

विटसी , 12 10 बाइट्स

aR)[1+0m]+
aR          Get a random number in [0,10)
  )[    ]   If its truncated int is 0, do the stuff in brackets.
    1+0m    Add 1 to one of the items and execute the 0th index of code.
         +  Add the numbers together.

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

ध्यान दें कि इसमें स्टैक ओवरफ़्लो त्रुटि का एक छोटा मौका है। हम बात कर रहे हैं (.1)^400मौका। यह भी त्रुटि के कारण बाहर निकलता है कि मैंने कैसे पुनरावृत्ति का कारण बना।


4

लिस्प, 58 बाइट्स

मेरा पहली बार लिस्प लेखन!

(defun +(a b)(if(<(random 10)9)(- a(- b))(- a(-(+ b 1)))))

आप इस विशेष जोड़ का उपयोग ठीक वैसे ही कर सकते हैं जैसा आप आमतौर पर लिस्प में करते हैं:

> (+ 1 3)
4
> (+ 1 3)
5

मुझे सुझाव सुनना अच्छा लगेगा क्योंकि मैं भाषा के लिए बिल्कुल नया हूं।


चाहेंगे (- a(- -1 b))काम करते हैं? यदि आप ऐसा करता है तो आप 2 बाइट्स बचाता है।
नील

@ नहीं, मुझे नहीं लगता कि वह काम करता है क्योंकि फ़ंक्शन को पुनरावर्ती होना चाहिए
sudo rm -rf slash

यह समझाने के लिए धन्यवाद कि अभिव्यक्ति इतनी बोझिल क्यों लग रही है।
नील

4

गंभीरता से, 10 बाइट्स

,Σ1±╤_G_\+

यह कार्यक्रम एक समान वितरण को परिवर्तित करके ज्यामितीय वितरण से एक यादृच्छिक चर उत्पन्न करता है। यह एक सूची के रूप में इनपुट लेता है: [2,3](वैकल्पिक ब्रेसिज़)। इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

,Σ1±╤_G_\+
,Σ          get sum of input
  1±╤_      push ln(0.1)
      G_    push ln(random(0,1))
        \   floored division
         +  add

एक यादृच्छिक चर को देखते हुए X ~ Uniform(0, 1), इसे Y ~ Geometric(p)सूत्र के साथ यादृच्छिक चर में परिवर्तित किया जा सकता है Y = floor(log(X)/log(p))


3

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

If[RandomReal[]<.1,+##,#0@##+1]&

स्पष्टीकरण:

                               &   A function returning
If[                           ]     if
   RandomReal[]                       a random number in [0,1)
               <                     is less than
                .1                    .1
                  ,                 , then
                   +                 the sum of
                    ##                all arguments
                      ,             , otherwise,
                       #0@            this function applied to
                          ##           all arguments
                            +        plus
                             1        one.

ध्यान दें कि यह फ़ंक्शन किसी भी संख्या में इनपुट के लिए काम करता है।



3

कैंडी , 11 बाइट्स

+#10H{.}10g

लंबा रूप है:

add          # add two numbers on the stack
number digit1 digit0 rand  # random int from 0 to 9         
if           # if non-zero
  retSub     # terminate loop
endif
digit1       # push 1 to stack
digit0 goto  # loop to start

3

सी, 71 51 39 37 बाइट्स

पहला कोड-गोल्फ, सी में किया गया ... मुझे नहीं लगता कि यह कुछ भी हराएगा, और बहुत नीचे गोल्फ हो सकता है

EDIT 3: कटे हुए 2 बाइट्स

a(x,y){return(rand()<.1?a(1,y):y)+x;}

EDIT 2: 12 बाइट्स काटे गए, gnu99 का अनुसरण करते हुए, हर वैरिएबल एक int है यदि अन्यथा नहीं कहा गया है। एक ही प्रकार के फंक्शन के लिए जाता है

a(x,y){return rand()<0.1?a(x,y+1):x+y;}

संपादित करें: 20 बाइट्स काटे गए, यह भूल गए कि C99 में मूल .h आवश्यक नहीं है (उदाहरण के लिए gcc का उपयोग करके)। यह एक चेतावनी का उत्पादन करेगा :)

int a(int x,int y){return rand()<0.1?a(x,y+1):x+y;}

71 बाइट्स समाधान:

#include <stdlib.h>
int a(int x,int y){return rand()<0.1?a(x,y+1):x+y;}

यदि आप बहुत सारे आउटपुट देखना चाहते हैं, तो आप निम्न कोड का उपयोग कर सकते हैं

#include <stdio.h> 
#include <stdlib.h>
int a(int x,int y){return rand()<0.1?a(x,y+1):x+y;}

int main(void) 
{
    int i,j;
    for(i=0;i<10;i++)
        for(j=0;j<10;j++)
            printf("%d + %d = %d\n",i,j,a(i,j));
    return 0;
}

3

MATL , 12 13 14 बाइट्स

r.1H$YlY[ihs

इनपुट फॉर्म का है [3 4], यानी दो नंबरों के साथ एक पंक्ति वेक्टर।

उदाहरण

>> matl r.1H$YlY[ihs
> [3 4]
7

व्याख्या

यह बिना किसी यादृच्छिक रैंडम वैरिएबल के एए परिवर्तन को सीधे लागू करके, बिना छोरों के ज्यामितीय यादृच्छिक चर उत्पन्न करता है । ध्यान दें कि लोग इन 0.1 एक लॉग के बजाय प्रयोग किया जाता है एक 1 बाइट को बचाने के लिए / log 0.1।

r        % random number with uniform distribution in (0,1)
.1       % number 0.1
H$       % specify two inputs for next function
Yl       % logarithm in specified base (0.1)
Y[       % floor. This produces the geometric random variable with parameter 0.1
i        % input vector of two numbers
h        % concatenate horizontally with the previously generated random value
s        % sum of vector elements

3

माइक्रोसेप्टिक , 29 21 बाइट्स

isi+vzr10!{l1vzr10!}l

मैंने एक माइक्रोसॉफ़्ट II उत्तर देने की कोशिश की, लेकिन किसी कारण से मुझे सही काम करने के लिए अतिरिक्त लूप नहीं मिल सका :(


3

माउस-2002 , 41 39 38 बाइट्स

कोई पुनरावृत्ति नहीं।

&TIME &SEED ??&RAND k*&INT 9=[+1+!|+!]

व्याख्या की:

&TIME &SEED               ~ painfully obvious

? ?                       ~ get some input
&RAND 10 * &INT 8 >       ~ get a random number 0-1 * 10, make it an int & check if >8
[                         ~ if true
  + 1 + !                 ~ add the input then add 1 and print
|                         ~ else
  + !                     ~ add and print
]                         ~ endif
$                         ~ (implicit) end of program

या, यदि आप एक कार्यात्मक प्रोग्रामिंग फैनबॉय हैं, और पुनरावृत्ति आपका सौदा है तो 57 बाइट्स हैं :

&TIME &SEED #A,?,?;!$A&RAND k*&INT 9=[#A,1%,2%1+;|1%2%+]@

व्याख्या की:

&TIME &SEED            ~ painfully obvious

#A, ?, ?; !            ~ call with input & print

$A                     ~ begin a definition of a function A

  &RAND 10 * &INT 8 >  ~ same as above
  [
    #A, 1%, 2% 1 +;    ~ call with args and add 1
  |
    1% 2% +            ~ else just add
  ]
@                      ~ end func
$                      ~ as above

3

जेली , 7 बाइट्स (गैर-प्रतिस्पर्धात्मक)

‘⁵XỊ¤¿+

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

यह काम किस प्रकार करता है

‘⁵XỊ¤¿+  Main link. Arguments: n, m (integers)

    ¤    Combine the three atoms to the left into a niladic chain.
 ⁵       Yield 10.
  X      Pseudo-randomly generate a positive integer not greater than 10.
   Ị     Insignificant; test if the generated integer is 1 (or less).
     ¿   While chain yields 1:
‘          Increment n.
      +  Add m to the result.

3

एपीएल (डायलॉग यूनिकोड) , 13 12 बाइट्स एसबीसीएस

मूल रूप से FryAmTheEggman के Pyth समाधान के समान है । -1 धन्यवाद एग्री द आउटगॉल्फ।

बेनामी tacit infix फ़ंक्शन।

{⍵+1=?10}⍣=+

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

+ तर्कों को जोड़ें

{}⍣= जब तक दो क्रमिक अनुप्रयोगों का एक ही परिणाम नहीं होता है तब तक निम्नलिखित फ़ंक्शन लागू करें:

?10 रेंज 1-10 में यादृच्छिक पूर्णांक

1= उस के बराबर है? (यानी 1 / 10 वें मौका)

⍵+ उस से तर्क जोड़ें


आप दो पूर्णांकों को दो तर्कों के रूप में ले सकते हैं और हटा सकते हैं /
एग्रीकल्चर से एरिक

@EriktheOutgolfer हाँ।
एडम

2

पर्ल 6 , 26 बाइट्स

वास्तव में इसे पुनरावर्ती करना:

sub f{.1>rand??f |@_,1!![+] @_} # 31 bytes

1तर्कों के बाद संभवत: खाली क्रम बनाएं , फिर उन सभी को एक साथ जोड़ दें।

{[+] {1}...^{rand>.1},|@_} # 26 bytes

(यह वास्तव में किसी भी तर्क ले सकता है)

उपयोग:

# give the lambda a name
my &f = {...}

say f 1,2; # one of 3,4,5 ... *


2

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

+sQ-18l`hO0

मेरे पायथन जवाब का एक सीधा पायथ पोर्ट ।

+             Add up
 sQ            the sum of the input and
   -           the difference of
    18          18 and
      l`         the string length of
        hO0       one plus a random number in [0,1)

2

ऑक्टेव, 20 बाइट्स

@(a,b)a+b+geornd(.9)

इनपुट के योग, साथ ही पैरामीटर के साथ ज्यामितीय वितरण से एक यादृच्छिक नमूना 0.9


2

गंभीरता से, 13 बाइट्स

,,1W+9uJYWDkΣ

Doorknob के CJam उत्तर (वेतन वृद्धि संख्या जबकि यादृच्छिक फ्लोट 0.1 से कम है) के लिए एक समान रणनीति का उपयोग करता है, सिवाय इसके कि पूर्णांक का उपयोग करता है, और वेतन वृद्धि जबकि यादृच्छिक पूर्णांक 1 [0,9]से कम है। आसान पुनरावृत्ति की कमी से दर्द होता है।

इसे ऑनलाइन आज़माएं (मैन्युअल इनपुट की आवश्यकता है)

स्पष्टीकरण:

,,1W+9uJYWDkΣ
,,1            get input, push 1
   W     W     while loop:
    +            add top two elements
     9uJ         push a random integer in [0, 9]
        Y        push 1 if random value is falsey (0) else 0
          DkΣ  decrement top value and add everything together

जबकि लूप इस तरह से स्टैक छोड़ देता है:

n: the # of times the random value was < 0.1, plus 1
b: the second input
a: the first input

स्थानांतरण n1 से चलाने के लिए है, जबकि पाश पाने के लिए आवश्यक है, के बाद से 0falsey है। यह आसानी से है n, जबकि लूप के बाद गिरावट के साथ निपटा जाता है , इसलिए अंतिम परिणाम है a + b + (n - 1)


2

MATLAB, 51 बाइट्स

function f(a,b)
if rand > .1;a+b;else;f(a,b+1);end

परिणाम 'ans' स्वचालित चर में पाया जाता है

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.