Inspiriert von Alex 'ruhmreichem Lerne dir ein R für großartiges Wohl, wir werden demütig Alex' "ein wahres R-Programm" nachbilden - aber mit einer Wendung.

Die Alex-Addition funktioniert wie folgt: Sie hat eine Chance von 90%, einfach die Summe der beiden angegebenen Zahlen zurückzugeben, und eine Chance von 10%, Alex rekursiv die erste Zahl und die zweite Zahl + 1 hinzuzufügen. Dies bedeutet möglicherweise, dass kann eine Addition um 1 oder mehr verschoben sein.

Herausforderung

Schreiben Sie ein vollständiges Programm oder eine vollständige Funktion, die zwei Ganzzahlen enthält, und Alex fügt sie wie definiert hinzu. Sie können davon ausgehen, dass Ihr Programm nicht überläuft, wenn Ihre Sprache keine Endrekursion aufweist. (Beachten Sie, dass Sie es nicht rekursiv implementieren müssen, solange die Wahrscheinlichkeiten gleich sind.)

Referenzimplementierung (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;
  }
}

Probieren Sie diese Geige online.

Bestenliste

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

Probieren Sie es online aus

Dies verwendet Pyths zweiten Modus beim Reduzieren, der nach wiederholten Eingaben sucht und dann beendet.

Erläuterung

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

Wenn das zusätzliche alex-add auftritt, wird es erneut ausgeführt, wenn nicht, wird es beendet.

Python 2, 55 Bytes

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

Dies ist eine absolut bizarre Methode.

Die Funktion randomgibt einen Gleitkommawert in [0,1] an, und die Zeichenfolgendarstellung hat standardmäßig 16 Nachkommastellen für insgesamt 18 Zeichen. Da jedoch nachgestellte Nullen weggelassen werden, kann dies kürzer sein. Beim Ablesen der Ziffern vom Ende hat jede eine 1/10-Chance, 0 zu sein, und wir hören auf, wenn wir eine Ziffer ungleich Null treffen. Die Anzahl der nachgestellten Nullen ist also genauso verteilt wie die Anzahl der von Alex durchgeführten Rekursionen, sodass wir aus dieser Verteilung eine Stichprobe von 18 abzüglich der Stringlänge ziehen können.

Tatsächlich zeigt Python mehr als 18 Stellen für kleine Zahlen an, manchmal sogar für wissenschaftliche Notationen. Deshalb fügen wir 1 hinzu, um dies zu beheben.

Dies gibt niemals mehr als 15 mehr als die Summe, aber das ist in Ordnung, da 10 ^ 15 viel weniger ist als die Wahrscheinlichkeit, dass ein kosmischer Strahl die Berechnung stört .

R 60 47 28 Bytes

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

Dies ist ein unbenanntes Funktionsobjekt, das zwei Zahlen akzeptiert und eine Zahl zurückgibt. Es wird keine Rekursion verwendet.

Wie xnor in einem Kommentar hervorhob, kann dieses Problem als einfaches Hinzufügen von zwei Zahlen plus einer geometrischen Zufallsvariablen mit einer Ausfallwahrscheinlichkeit von 1/10 angesehen werden.

Warum ist das so? Denken Sie an die Rekursion, wie in der Post beschrieben. In jeder Iteration haben wir eine 10% ige Chance, eine 1 zu addieren und eine 90% ige Chance, die Funktion ohne weitere Addition zu verlassen. Jede Iteration ist eine eigene unabhängige Bernoulli-Studie mit den Ergebnissen "Addiere 1, Rekurs" (Misserfolg) und "Exit" (Erfolg). Somit beträgt die Ausfallwahrscheinlichkeit 1/10 und die Erfolgswahrscheinlichkeit 9/10.

Bei einer Reihe unabhängiger Bernoulli-Versuche folgt die Anzahl der Versuche, die erforderlich sind, um einen einzelnen Erfolg zu erzielen, einer geometrischen Verteilung . In unserem Fall bedeutet jede Rekursion das Hinzufügen von 1. Wenn wir also die Funktion endgültig beenden, haben wir im Wesentlichen die Anzahl der Fehler gezählt, die vor dem ersten Erfolg aufgetreten sind. Das bedeutet, dass der Betrag, um den das Ergebnis verschoben wird, zufällig von einer geometrischen Verteilung abweicht.

Hier können wir Rs expansive Suite von eingebauten und verwendeten Wahrscheinlichkeitsverteilungen nutzen rgeom, die einen Zufallswert aus einer geometrischen Verteilung zurückgibt.

Ungolfed:

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

Minkolang 0,14 , 19 11 12 Bytes

Dies ist die "Funktions" -Version; es wird davon ausgegangen aund bist bereits auf dem Stapel, knallt sie ab und schiebt die modifizierte Version a+b. Die nächste äquivalente Funktionen zu in Minkolang zu bedienen ist F, die aus öffnet b, aund springt zu (a,b)der codebox. Wenn dann der Programmzähler auf einen trifft f, springt er zurück zu der Stelle, an Fder er benutzt wurde.

(+$01$h`d)xf

Dies ist die Vollversion des Programms, 15 Bytes . ( nnNimmt zwei Zahlen von der Eingabe und N.gibt das Ergebnis aus und stoppt.)

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

Ich habe den Algorithmus aus Doorknobs Antwort gestohlen . Die while-Schleife wird wiederholt, solange die generierte Zufallszahl kleiner als 0,1 ist, wobei jedes Mal 1 addiert wird. Probieren Sie es hier aus (Vollversion) und führen Sie es hier 100 Mal aus .

Erläuterung

(              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

Der klügste Teil hier ist d. Die Spitze des Stapels zu diesem Zeitpunkt ist entweder 0 oder 1. Wenn sie 0 ist, wird die while-Schleife beendet. Ansonsten geht es weiter. Wenn ich den oberen Teil des Stapels dupliziere, wird [a+b,1]die Schleife zum zweiten Mal durchlaufen, sodass +am Anfang die 1 hinzugefügt wird (und ebenfalls für nachfolgende Trips).

CJam, 12 11 Bytes

{{+Amr!}h;}

Vielen Dank an @ MartinBütter für das Speichern eines Bytes mit diesem super cleveren Trick!

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

Alte Antwort:

{+({)Amr!}g}

Probieren Sie es online aus .

Erläuterung:

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

Der grundlegende Algorithmus ist "while (0.1 chance), erhöhe die Zahl", wodurch die Notwendigkeit einer Rekursion entfällt.

Javascript ES6, 38 Bytes

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

MATL , 14 13 12 Bytes

is`r.1<tb+w]

Dies ist nur die Schleifenmethode. [a b]Addieren Sie die Eingänge (eingegeben als ) und addieren Sie dann einen, während eine einheitliche Zufallszahl zwischen 0 und 1 kleiner als 0,1 ist. Vollständige Beschreibung unten:

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    

1 Byte durch Ändern der Eingangsspezifikation (von ii+nach is) entfernt.

Die alte Methode basierte auf der Ermittlung des zu addierenden Betrags anhand des Basis-10-Protokolls einer Zufallszahl zwischen 0 und 1 a+b, konnte jedoch aufgrund der Gleitkommagenauigkeit nur bis zu 15 Wiederholungen ausführen .

iir10,2$YlZo-+

Führt in diesem Code einen 10,2$YlZo-Logarithmus zur Basis 10 der Zufallszahl aus und rundet auf die nächste Ganzzahl auf.

Binary-Encoded Golfical , 32 29 + 1 ( -xFlag) = 30 Bytes

Hexdump (manuell bearbeitet, um einen Fehler im Image-to-Binary-Teil des Transpilers zu korrigieren, der inzwischen behoben wurde):

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

Diese Codierung kann mit dem mitgelieferten Dienstprogramm Encoder wieder in die ursprüngliche grafische Darstellung konvertiert oder direkt mit dem -xFlag ausgeführt werden.

Original Bild:

50x vergrößert:

Erläuterung: Die obere Reihe ist der Hauptblock. Es liest eine Zahl, kopiert sie nach rechts, liest eine andere Zahl, fügt sie hinzu, kopiert das Ergebnis nach rechts, erledigt einige RNG-Aufgaben und druckt mit einer Wahrscheinlichkeit von 90% das Ergebnis der Addition. In der restlichen Zeit wird es in die unterste Reihe gesendet, wo es eine Eins in die erste Zelle setzt und kurz vor der Additionsanweisung in die Hauptreihe zurückkehrt (mit einer Nordkurve und einer Ostkurve).

Python, 66 65 64 63 Bytes

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

Probieren Sie es online aus

Vielen Dank an Sherlock9 für die Korrekturen und das Byte gespeichert.

Vielen Dank an Mathias Ettinger für ein weiteres Byte.

Danke an mbomb007 für ein Byte.

Julia, 30 Bytes

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

Dies ist eine rekursive Funktion f, die zwei Zahlen akzeptiert und eine Zahl desselben Typs zurückgibt. Es sollte für jeden numerischen Typ gut funktionieren.

Zuerst prüfen wir, ob ein zufälliger Float zwischen 0 und 1 größer als 0,9 ist. Wenn ja, greifen wir auf ein bisschen mehr zurück, sonst fügen wir nur noch hinzu.

TI-BASIC, 15 Bytes

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

Damit wird die Eingabe als Liste mit zwei Elementen übernommen Ans. Während eine Zufallszahl kleiner als ist 0.1, wird 0.5die Liste vektorisiert ergänzt . Durch Erhöhen jedes Elements 0.5um wird die Summe um 1 erhöht. Ich glaube, dies ist die kürzeste TI-BASIC-Lösung.

Das 9-Byte-Programm sum(Ans)-int(log(10randfunktioniert nicht, da es randnur eine Genauigkeit von 14 Stellen hat und daher keine Zahl unter ^{10-14 geben kann} .

APL, 17 Bytes

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

Dies ist eine unbenannte dyadische Funktion.

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 Bytes

KsQW!OT=hK;K

Mein erstes richtiges Pythgolf!

Übernimmt die Eingabe für STDIN im Format a,b.

Erläuterung:

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

Vielen Dank an @FryAmTheEggman, der mir die Möglichkeit gegeben hat, eine Variable auf kürzere Weise zu inkrementieren.

Vitsy , 12 10 Bytes

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.

Probieren Sie es online!

_{Beachten Sie, dass das Risiko eines Stapelüberlauffehlers sehr gering ist. Wir reden über (.1)^400Zufall. Es wird auch durch einen Fehler beendet, der darauf zurückzuführen ist, dass ich eine Rekursion verursacht habe.}

Lisp, 58 Bytes

Das erste Mal, dass ich Lisp schreibe!

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

Sie können diesen speziellen Zusatz genau so verwenden, wie Sie ihn normalerweise in Lisp hinzufügen würden:

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

Ich würde gerne Vorschläge hören, da ich brandneu in der Sprache bin.

Im Ernst, 10 Bytes

,Σ1±╤_G_\+

Dieses Programm generiert eine Zufallsvariable aus einer geometrischen Verteilung, indem es eine gleichmäßige Verteilung transformiert. Die Eingabe erfolgt als Liste: [2,3](geschweifte Klammern optional). Probieren Sie es online aus .

Erläuterung:

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

Bei einer Zufallsvariablen X ~ Uniform(0, 1)kann diese Y ~ Geometric(p)mit der Formel in eine Zufallsvariable umgewandelt werden Y = floor(log(X)/log(p)).

Mathematica, 32 Bytes

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

Erläuterung:

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

Beachten Sie, dass diese Funktion für eine beliebige Anzahl von Eingängen funktioniert.

TeaScript , 18 Bytes 21

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

Dies ist eine TeaScript-Funktion. Weisen Sie es einer Variablen zu oder führen Sie es direkt aus.

Probieren Sie es online aus

Süßigkeit , 11 Bytes

+#10H{.}10g

Die lange Form ist:

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 Bytes

Erste Code-Golf, in C gemacht ... Ich glaube nicht, dass es irgendetwas schlagen wird, und kann viel Golf gespielt werden

EDIT 3: 2 Bytes dank @Mego gekürzt, indem .1 anstelle von 0.1 geschrieben und der ternäre Operator neu geschrieben wurde

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

EDIT 2: 12 Bytes nach gnu99, jede Variable ist ein Int, wenn nicht anders angegeben. Gleiches gilt für den Rückgabetyp der Funktion

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

BEARBEITEN: 20 Bytes gekürzt, vergessen, dass grundlegende .h in C99 nicht erforderlich sind (zum Beispiel mit gcc). Es wird eine Warnung geben :)

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

71 Bytes Lösung:

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

Wenn Sie viele Ausgaben sehen möchten, können Sie den folgenden Code verwenden

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

r.1H$YlY[ihs

Die Eingabe hat die Form [3 4]eines Zeilenvektors mit den beiden Zahlen.

Beispiel

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

Erläuterung

Dies erzeugt die geometrische Zufallsvariable ohne Schleifen, indem eine Transformation direkt auf eine einheitliche Zufallsvariable angewendet wird. Beachten Sie, dass log _0.1 a anstelle von log a / log 0.1 verwendet wird, um 1 Byte zu sparen.

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

Microscript , 29 21 Bytes

isi+vzr10!{l1vzr10!}l

Ich habe versucht, eine Microscript II-Antwort zu erstellen, aber aus irgendeinem Grund konnte die Additionsschleife nicht richtig funktionieren :(

Mouse-2002 , 41 39 38 Bytes

Keine Rekursion.

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

Erklärt:

&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

Oder, wenn Sie ein Fan der funktionalen Programmierung sind und Rekursion Ihr Geschäft ist, dann 57 Bytes :

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

Erklärt:

&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

Jelly , 7 Bytes (nicht konkurrierend)

‘⁵XỊ¤¿+

Probieren Sie es online!

Wie es funktioniert

‘⁵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 Bytes ^SBCS

Grundsätzlich das gleiche wie die Pyth-Lösung von FryAmTheEggman . -1 Danke an Erik den Outgolfer.

Anonyme stillschweigende Infix-Funktion.

{⍵+1=?10}⍣=+

Probieren Sie es online!

+ Fügen Sie die Argumente hinzu

{... }⍣= gilt die folgende Funktion , bis zwei aufeinanderfolgende Anwendungen das gleiche Ergebnis:

 ?10 zufällige ganze Zahl im Bereich von 1 bis 10

 1= ist man dem gleich? (dh ¹ / ₁₀ ^th Chance)

 ⍵+ Fügen Sie das Argument hinzu

Perl 6 , 26 Bytes

Eigentlich rekursiv:

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

Erstellen Sie eine möglicherweise leere Folge von 1s, gefolgt von den Argumenten, und addieren Sie sie dann alle.

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

(es kann tatsächlich eine beliebige Anzahl von Argumenten annehmen)

Verwendungszweck:

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

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

Pyth, 11 Bytes

+sQ-18l`hO0

Ein direkter Pyth-Port meiner Python-Antwort .

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

Oktave, 20 Bytes

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

Summe der Eingaben plus Zufallsstichprobe aus der geometrischen Verteilung mit Parameter 0.9.

Im Ernst, 13 Bytes

,,1W+9uJYWDkΣ

Verwendet eine ähnliche Strategie wie Doorknobs CJam-Antwort (Inkrementzahl bei einem zufälligen Float von weniger als 0,1), außer dass Ganzzahlen verwendet werden und Inkremente bei einem zufälligen Integer von [0,9]weniger als 1. Das Fehlen einer einfachen Rekursion schadet.

Online ausprobieren (manuelle Eingabe erforderlich)

Erläuterung:

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

Die while-Schleife verlässt den Stapel folgendermaßen:

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

Eine Verschiebung num 1 ist notwendig, um die while-Schleife zum Laufen zu bringen, da dies 0falsch ist. Es kann leicht durch Dekrementieren nnach der while-Schleife behoben werden. Das Endergebnis ist also a + b + (n - 1).

MATLAB, 51 Bytes

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

Das Ergebnis wird in der automatischen Variablen 'ans' gefunden