Alex'in şanlılarından esinlenerek Sizi iyiliğin için bir R öğrenin, Alex'in "gerçek bir R programını" alçakgönüllülükle yeniden yaratacağız - ama bir twist ile.

Alex tarzı Ekleme bu şekilde çalışır - verilen iki sayının toplamını geri alma şansı% 90'tır ve yinelemeli olarak% 10'luk bir şansı verir Alex, ilk rakamı ve ikinci rakamı + 1 ekler. Bu, potansiyel olarak , bir ek 1 veya daha fazla kapalı olabilir.

Meydan okuma

İki tamsayı alan tam bir program veya fonksiyon yazın ve Alex tanımlandığı şekilde ekler. Dilinizde kuyruk özyineleme yoksa, programınızın taşması olmayacağını varsayabilirsiniz. (Olasılıklar aynı olduğu sürece, tekrarlı olarak uygulamak zorunda olmadığınızı unutmayın.)

Referans Uygulaması (Groovy)

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

Bu kemanı çevrimiçi deneyin.

Liderler Sıralaması

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>

Pyth, 8

u+G!OTsQ

Çevrimiçi deneyin

Bu, Pyth'in azaltılmış ikinci modunu kullanır, tekrarlanan girişleri arar ve çıkar.

açıklama

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

Ekstra alex-add oluşursa, tekrar çalışacaktır, ancak değilse çıkar.

Python 2,55 bayt

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

Bu, bunu yapmak için kesinlikle tuhaf bir yoldur.

İşlev random[0,1] 'de float verir ve varsayılan olarak dizge gösterimi, 18 noktadan sonra toplam 18 karakter için 16 haneye sahiptir. Ancak, takip eden 0'lar ihmal edildiğinden, daha kısa olabilir. Her birinden rakamları okurken, her birinin 1/10 olma şansı vardır ve sıfır olmayan bir haneye çarptığımızda dururuz. Böylece takip eden sıfırların sayısı, Alex'in yaptığı özyineleme sayısı gibi dağıtılır, bu yüzden dize uzunluğunu 18 eksi bu örneklemden alabiliriz.

Aslında, Python küçük sayılar için 18 rakamdan fazlasını, bazen bilimsel gösterimleri gösterecek, bu yüzden bunu düzeltmek için 1 ekleyeceğiz.

Bu asla 15'ten fazla toplamı vermeyecektir, ancak sorun değil çünkü 10 ^ 15 kozmik bir ışının hesaplamayı bozma şansından çok daha az .

R, 60 47 28 bayt

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

Bu, iki sayı kabul eden ve bir sayı döndüren adsız bir işlev nesnesidir. Özyineleme kullanmaz.

Bir yorumda belirtildiği gibi, xnor, bu sorun, basitçe iki sayı ekleyerek başarısızlık olasılığı 1/10 olan geometrik rastgele bir değişken olarak görülebilir.

Bu neden doğru? Yayınında açıklandığı gibi, özyineleme açısından bir düşünün. Her yinelemede,% 1 ekleme ve tekrarlama şansımız ve% 90 daha fazla ekleme yapmadan fonksiyondan çıkma şansımız var. Her yineleme, sonuçları "1 ekle, tekrarla" (başarısızlık) ve "çıkış" (başarı) olan kendi bağımsız Bernoulli denemesidir . Böylece, başarısızlık olasılığı 1 / 10'dur ve başarı olasılığı 9 / 10'dur.

Bir dizi bağımsız Bernoulli denemesiyle uğraşırken, tek bir başarı elde etmek için gereken deneme sayısı geometrik bir dağılımı izler . Bizim durumumuzda, her özyineleme 1 ekleme anlamına gelir, bu nedenle işlevden nihayet çıktığımızda, ilk başarıdan önce meydana gelen arıza sayısını saydık. Bu, sonucun keseceği tutarın geometrik bir dağılımdan rastgele bir değişken olduğu anlamına gelir.

Burada R'nin rgeom, geometrik bir dağılımdan rasgele bir değer döndüren geniş olasılık dağılımı yerleşiklerinden ve kullanımlarından faydalanabiliriz .

Ungolfed:

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

Minkolang 0.14 , 19 11 12 bayt

Bu "fonksiyon" versiyonu; varsayılır ave bzaten yığındadır, çıkarır ve değiştirilmiş halini iter a+b. Minkolang içinde işlevlerine yakın eşdeğer kullanmaktır Fuzakta açılan, hangi b, ave atlar (a,b)Codebox içinde. Ardından program sayacı bir çarptığında , kullanıldığı fyere geri atlar F.

(+$01$h`d)xf

Bu tam program sürümüdür, 15 bayt . ( nngirişten iki sayı alır ve N.sonucu çıkarır ve durur.)

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

Algoritmayı Doorknob'un cevabından çaldım ; while döngüsü, oluşturulan rasgele sayı 0,1'den küçük olduğu sürece, her seferinde 1 ekleyerek tekrar eder. Burada deneyin (tam program sürümü) ve burada 100 kez çalıştırın .

açıklama

(              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

Buradaki en zeki kısım d. O zamanki yığındaki yığının üstü 0 veya 1 olacaktır. 0 ise, while döngüsü çıkar. Aksi takdirde devam eder. Yığının tepesini çoğalttığımda, [a+b,1]döngü boyunca ikinci kez olacak , böylece +başlangıçta 1 eklenir (ve sonraki geziler için de aynı şekilde).

CJam, 12 11 bayt

{{+Amr!}h;}

Bu süper zekice numara ile bir byte tasarrufu için @ MartinBütter için teşekkürler!

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

Eski cevap:

{+({)Amr!}g}

Çevrimiçi deneyin .

Açıklama:

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

Temel algoritma, tekrarlama ihtiyacını ortadan kaldıran "süre (0.1 şans), sayıyı arttırmaktır".

Javascript ES6, 38 bayt

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

MATL , 14 13 12 bayt

is`r.1<tb+w]

Bu sadece döngü metodudur, girişleri ekleyiniz (olarak girilmiştir [a b]) daha sonra 0 ila 1 arasında tekdüze bir rasgele sayı 0.1'den küçükken bir tane eklemeye devam ediniz. Tam açıklama aşağıda:

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    

(Giriş spec değiştirerek 1 bayt çıkardı ii+için is).

Eski yöntem, eklenecek miktarı hesaplamak için 0 ile 1 arasında rastgele bir sayıdaki 10 taban kütüğünün alınmasına dayanmaktaydı a+b, ancak kayan nokta doğruluğu nedeniyle sadece 15 tekrara kadar çalışabiliyordu.

iir10,2$YlZo-+

Bu kodda, 10,2$YlZo-rasgele sayının 10 tabanlı logaritması yapılır ve en yakın tam sayıya yuvarlanır.

İkili Kodlanmış Golf , 32 29 + 1 ( -xbayrak) = 30 bayt

Hexdump (vericinin görüntünün ikili kısmındaki hatayı düzeltmek için düzeltildi, o zamandan beri düzeltildi):

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

Bu kodlama, birlikte verilen Kodlayıcı yardımcı programını kullanarak orijinal grafik gösterime dönüştürülebilir veya doğrudan -xbayrakla çalıştırılabilir .

Orijinal görüntü:

Büyütülmüş 50x:

Açıklama: Üst satır ana bloktur. Bir sayı okur, sağa kopyalar, başka bir sayı okur, ekler, sonucu sağa kopyalar, bazı RNG öğeleri yapar ve% 90 olasılıkla toplama işleminin sonucunu yazdırır. Zamanın geri kalanında, ilk hücreye bir tane koyduğu ve ekleme komutundan hemen önce ana satıra geri döndüğü alt sıraya gönderilir (kuzey dönüşü ve sonra bir doğu dönüşünü kullanarak).

Python, 66 65 64 63 bayt

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

Çevrimiçi deneyin

Düzeltmeler ve kaydedilen bayt için Sherlock9'a teşekkürler.

Başka bir bayt için Mathias Ettinger'a teşekkürler.

Bir bayt için mbomb007'ye teşekkürler.

Julia, 30 bayt

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

Bu, fiki sayı kabul eden ve aynı türden bir sayı döndüren özyinelemeli bir işlevdir . Herhangi bir sayısal tür için iyi çalışması gerekir.

Öncelikle, 0 ile 1 arasındaki rastgele bir değişkenlik değerinin 0,9'dan büyük olup olmadığını kontrol ederiz. Eğer öyleyse, biraz daha fazla bir şeyle tekrarlarız, aksi halde sadece ekleriz.

TI-BASIC, 15 bayt

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

Bu, girişi iki elemanlı bir liste olarak alır Ans. Rastgele bir sayı küçüktür 0.1, ancak 0.5listeye eklenmiş vektörize eder. Her elemanı 0.5arttırmak, toplamı 1 arttırır. Bunun en kısa TI-BASIC çözümü olduğuna inanıyorum.

9 baytlık program sum(Ans)-int(log(10randçalışmıyor, çünkü randyalnızca 14 basamak hassasiyete sahip ve bu nedenle 10 ^-14'ten daha az bir sayı veremiyor .

APL, 17 bayt

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

Bu isimsiz bir ikili fonksiyondur.

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

Pyth, 14 12 bayt

KsQW!OT=hK;K

İlk gerçek Pyth golf'üm!

STDIN'e formatta girdi alır a,b.

Açıklama:

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

Değişkenliği arttırmak için bana daha kısa bir yol vererek iki karakteri tıraş ettiğin için @FryAmTheEggman'a teşekkürler!

Vitsy , 12 10 bayt

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.

Çevrimiçi deneyin!

_{Bu bir var unutmayın küçücük bir yığın taşması hata olasılığını. Şanstan söz ediyoruz (.1)^400. Aynı zamanda özyinelemeye nasıl sebep olduğumdan dolayı hatadan çıkıyor.}

Lisp, 58 bayt

İlk kez Lisp'i yazıyorum!

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

Bu özel ilacı tam olarak Lisp'e ekleyeceğiniz gibi kullanabilirsiniz:

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

Dil için yeni olduğum için önerileri duymak isterim.

Cidden, 10 bayt

,Σ1±╤_G_\+

Bu program, tek biçimli bir dağılımı dönüştürerek geometrik bir dağılımdan rastgele bir değişken üretir. Bir liste olarak girdi alır: [2,3](isteğe bağlı ayraçlar). Çevrimiçi deneyin .

Açıklama:

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

Rastgele bir değişken verildiğinde , formülle X ~ Uniform(0, 1)rastgele bir değişkene dönüştürülebilir .Y ~ Geometric(p)Y = floor(log(X)/log(p))

Mathematica, 32 bayt

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

Açıklama:

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

Bu fonksiyonun herhangi bir sayıda giriş için çalıştığını unutmayın.

TeaScript , 18 bayt 21

#$r<.1?f(l,i¬):l+i

Bu bir TeaScript işlevidir. Bir değişkene atayın veya doğrudan çalıştırın.

Çevrimiçi deneyin

Şeker , 11 bayt

+#10H{.}10g

Uzun biçim:

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

C, 71 51 39 37 bayt

İlk kod-golf, C 'de yapıldı ... Hiçbir şeyi geçeceğini sanmıyorum ve çok fazla golf oynayabilirim.

EDIT 3: @Mego sayesinde 2 byte keser, 0.1 yerine .1 yazarak ve üçlü işleci yeniden yazar

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

EDIT 2: 12 bayt, gnu99'dan sonra kesilir, aksi belirtilmediği takdirde her değişken bir int olur. Aynı fonksiyonun dönüş tipi için de geçerlidir

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

EDIT: 20 byte kesti, C99'da temel. H'nin gerekli olmadığını (örneğin gcc kullanarak) unuttum. Bir uyarı üretecektir :)

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

71 Bayt çözüm:

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

Çok fazla çıktı görmek istiyorsanız, aşağıdaki kodu kullanabilirsiniz.

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

MATL , 12 13 14 bayt

r.1H$YlY[ihs

Giriş [3 4], yani, iki sayıyla bir satır vektörü şeklindedir.

Örnek

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

açıklama

Bu, düzgün bir rastgele değişkene doğrudan bir a dönüşümü uygulayarak, döngüsel olmayan geometrik rastgele değişkeni üretir . 1 bayt kaydetmek için log a / log 0.1 yerine _0.1 a kullanıldığını unutmayın .

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

Mikroscript , 29 21 bayt

isi+vzr10!{l1vzr10!}l

Bir Microscript II yanıtı vermeye çalıştım, ancak bir nedenden dolayı ekleme döngüsünün doğru çalışmasını sağlayamadım :(

Mouse-2002 , 41 39 38 bayt

Özyineleme yok.

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

Açıklaması:

&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

Veya, eğer işlevsel bir programlama meraklısıysanız ve özyineleme işiniz ise 57 bayt :

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

Açıklaması:

&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

Jöle , 7 bayt (yarışmaz)

‘⁵XỊ¤¿+

Çevrimiçi deneyin!

Nasıl çalışır

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

APL (Dyalog Unicode) , 13 12 bayt ^SBCS

Temel olarak FryAmTheEggman's Pyth çözümü ile aynı . -1, Outgolfer Erik'e teşekkürler.

Anonim tam yapıştırma işlevi.

{⍵+1=?10}⍣=+

Çevrimiçi deneyin!

+ argümanları ekle

{… }⍣= Art arda iki uygulama aynı sonuca ulaşana kadar aşağıdaki işlevi uygulayın:

 ?10 1-10 aralığında rasgele tamsayı

 1= biri buna eşit mi? (yani ¹ / ₁₀ ^inci şans)

 ⍵+ argümanı buna ekle

Perl 6 , 26 bayt

Aslında yinelemeli olarak yapıyor:

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

1Bağımsız bir s dizisi ve ardından argümanlar izleyin, sonra hepsini bir araya getirin.

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

(aslında herhangi bir sayıda argüman alabilir)

kullanımı:

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

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

Pyth, 11 bayt

+sQ-18l`hO0

Python cevabımın doğrudan Pyth portu .

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

Oktav, 20 bayt

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

Girişlerin toplamı, artı parametre ile geometrik dağılımdan rastgele bir örnek 0.9.

Cidden, 13 bayt

,,1W+9uJYWDkΣ

Doorknob'un CJam cevabına benzer bir strateji kullanır (rastgele yüzerken artan sayı 0,1'den küçüktür), tamsayı kullanır ve rastgele tamsayı 1'den küçükken artışlar 1'den daha [0,9]az olur.

Çevrimiçi deneyin (manuel giriş gerekiyor)

Açıklama:

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

While döngüsü yığını şu şekilde bırakır:

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

Falsey nolduğundan süre döngüsünün çalışmasını sağlamak için 1 ile yukarı 0kaydırmak gerekir. Bu nsüre döngüsünden sonra azalarak kolayca ele alınabilir , bu yüzden nihai sonuç a + b + (n - 1).

MATLAB, 51 bayt

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

Sonuç 'ans' otomatik değişkeninde bulunur