Inspirés par le glorieux Alex. Apprenez-nous un R de façon géniale, nous allons recréer humblement le "programme One True R" d'Alex, mais avec une touche différente.

Alex-style Addition fonctionne comme ceci: il a 90% de chance de simplement renvoyer la somme des deux nombres donnés et 10% de chance de faire récursivement Alex, en ajoutant le premier nombre et le second nombre + 1. Cela signifie que potentiellement , un ajout peut être désactivé de 1 ou plus.

Défi

Ecrivez un programme complet ou une fonction qui prend deux entiers et Alex les ajoute tels que définis. Vous pouvez supposer que votre programme n'empilera pas le débordement si votre langue n'a pas de récursion de la queue. (Notez que vous n'avez pas à l'implémenter de manière récursive, tant que les probabilités sont les mêmes.)

Implémentation de référence (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;
  }
}

Essayez ce violon en ligne.

Classement

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

Essayez-le en ligne

Cela utilise le second mode de Pyth sur réduire, qui recherche les entrées répétées puis se termine.

Explication

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

Si l'alex-add supplémentaire se produit, il sera exécuté à nouveau, mais sinon, il se fermera.

Python 2, 55 octets

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

C'est une manière absolument bizarre de le faire.

La fonction randomdonne un float dans [0,1) et sa représentation sous forme de chaîne comporte par défaut 16 chiffres après le point décimal, pour un total de 18 caractères. Mais, étant donné que les derniers 0 sont omis, il pourrait être plus court. En lisant les chiffres à partir de la fin, chacun a 1/10 de chance d’être 0 et nous nous arrêtons lorsque nous atteignons un chiffre différent de zéro. Ainsi, le nombre de zéros à la fin est distribué comme le nombre de récursions effectuées par Alex. Nous pouvons ainsi échantillonner cette distribution de 18 moins la longueur de la chaîne.

En fait, Python affichera plus de 18 chiffres pour les petits nombres, parfois même en notation scientifique, nous ajoutons donc 1 pour résoudre ce problème.

Cela ne donnera jamais plus de 15% de plus que la somme, mais ce n'est pas grave, car 10 ^ 15 équivaut beaucoup moins que le risque qu'un rayon cosmique perturbe le calcul .

R, 60 47 28 octets

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

C'est un objet fonction non nommé qui accepte deux nombres et renvoie un nombre. Il n'utilise pas de récursivité.

Comme xnor l'a souligné dans un commentaire, ce problème peut être considéré comme une simple addition de deux nombres plus une variable aléatoire géométrique avec une probabilité d'échec de 1/10.

Pourquoi est-ce vrai? Pensez-y en termes de récursion, comme décrit dans le post. À chaque itération, nous avons 10% de chances d’ajouter 1 et de récurrent, et 90% de quitter la fonction sans autre ajout. Chaque itération est son propre essai indépendant de Bernoulli avec les résultats "add 1, recurse" (échec) et "sortie" (succès). Ainsi, la probabilité d'échec est de 1/10 et la probabilité de succès est de 9/10.

Lorsqu'il s'agit d'une série d'essais indépendants de Bernoulli, le nombre d'essais nécessaires pour obtenir un seul succès suit une distribution géométrique . Dans notre cas, chaque récursivité signifie l'ajout de 1; ainsi, lorsque nous quittons finalement la fonction, nous avons essentiellement compté le nombre d'échecs survenus avant le premier succès. Cela signifie que le résultat obtenu sera une variation aléatoire d'une distribution géométrique.

Ici, nous pouvons tirer parti de la vaste suite de solutions intégrées de distribution de probabilités et d'utilisation de R rgeomqui renvoie une valeur aléatoire à partir d'une distribution géométrique.

Ungolfed:

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

Minkolang 0.14 , 19 11 12 octets

Ceci est la version "function"; il assume aet best déjà sur la pile, les supprime et pousse la version modifiée de a+b. Le plus proche équivalent à des fonctions dans Minkolang est d'utiliser F, qui se soulève b, aet saute (a,b)dans le codebox. Ensuite, lorsque le compteur de programme frappe un f, il revient à l'endroit où il a Fété utilisé.

(+$01$h`d)xf

Ceci est la version complète du programme, 15 octets . ( nnprend deux nombres à partir de l’entrée et N.sort le résultat et s’arrête.)

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

J'ai volé l'algorithme de la réponse de Doorknob ; la boucle while se répète tant que le nombre aléatoire généré est inférieur à 0,1, en ajoutant 1 à chaque fois. Essayez-le ici (version complète du programme) et exécutez-le 100 fois ici .

Explication

(              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

La partie la plus intelligente est ici d. Le haut de la pile à ce moment-là sera 0 ou 1. Si c'est 0, la boucle while se termine. Sinon, ça continue. Au fur et à mesure que je duplique le haut de la pile, ce sera [a+b,1]la deuxième fois dans la boucle. +Le début ajoute le 1 (et de même pour les voyages suivants).

CJam, 12 à 11 octets

{{+Amr!}h;}

Merci à @ MartinBütter d'avoir enregistré un octet grâce à cette astuce super intelligente!

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

Ancienne réponse:

{+({)Amr!}g}

Essayez-le en ligne .

Explication:

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

L'algorithme de base est "while (0.1 chance), incrémente le nombre", ce qui élimine le besoin de récursivité.

Javascript ES6, 38 octets

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

MATL , 14 13 12 octets

is`r.1<tb+w]

Ceci est juste la méthode de la boucle, ajoutez les entrées (entrées en tant que [a b]), puis continuez à en ajouter une tandis qu'un nombre aléatoire uniforme entre 0 et 1 est inférieur à 0,1. Description complète ci-dessous:

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    

Décollé de 1 octet en modifiant les spécifications d'entrée (de ii+à is).

L'ancienne méthode reposait sur l'utilisation du journal en base 10 d'un nombre aléatoire compris entre 0 et 1 pour calculer le montant à ajouter a+b, mais cela ne fonctionnerait que jusqu'à 15 répétitions en raison de la précision de la virgule flottante.

iir10,2$YlZo-+

Dans ce code, 10,2$YlZo-effectue le logarithme en base 10 du nombre aléatoire et arrondit à l'entier le plus proche.

Codé binaire Golfical , 32 29 + 1 ( -xpavillon) = 30 octets

Hexdump (édité manuellement pour corriger un bogue dans la partie image vers binaire du transpiler, qui a été corrigé depuis):

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

Ce codage peut être reconverti dans la représentation graphique d'origine à l'aide de l'utilitaire Encoder inclus ou exécuté directement à l'aide de l' -xindicateur.

Image originale:

Magnifié 50x:

Explication: La rangée supérieure correspond au bloc principal. Il lit un numéro, le copie à droite, en lit un autre, les ajoute, copie le résultat à droite, effectue des opérations de RNG et, avec une probabilité de 90%, imprime le résultat de l'addition. Le reste du temps, il est envoyé à la ligne inférieure, où il en insère un dans la première cellule et revient à la ligne principale juste avant l'instruction d'addition (en utilisant un virage nord puis un virage est).

Python, 66 65 64 63 octets

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

Essayez-le en ligne

Merci à Sherlock9 pour les corrections et l'octet enregistré.

Merci à Mathias Ettinger pour un autre octet.

Merci à mbomb007 pour un octet.

Julia, 30 octets

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

C'est une fonction récursive fqui accepte deux nombres et retourne un nombre du même type. Cela devrait fonctionner correctement pour tout type numérique.

Nous vérifions d’abord si un flottant aléatoire entre 0 et 1 est supérieur à 0,9. Si tel est le cas, nous ajoutons un petit quelque chose en plus, sinon nous ajoutons.

TI-BASIC, 15 octets

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

Cela prend l'entrée sous forme de liste à deux éléments Ans. Bien qu'un nombre aléatoire soit inférieur à 0.1, il est ajouté à 0.5la liste vectorisé . L'augmentation de chaque élément 0.5augmente la somme de 1. Je pense que c'est la solution TI-BASIC la plus courte.

Le programme de 9 octets sum(Ans)-int(log(10randne fonctionne pas, car randil n'a que 14 chiffres de précision et ne peut donc pas donner un nombre inférieur à 10 ^-14 .

APL, 17 octets

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

C'est une fonction dyadique sans nom.

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 octets

KsQW!OT=hK;K

Mon premier vrai golf Pyth!

Prend l'entrée sur STDIN dans le format a,b.

Explication:

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

Merci à @FryAmTheEggman pour avoir rasé deux caractères en me donnant un moyen plus rapide d’incrémenter une variable!

Vitsy , 12 à 10 octets

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.

Essayez-le en ligne!

_{Notez que cela a un risque infime d’erreur de débordement de pile. Nous parlons (.1)^400chance. Il se termine également par erreur en raison de la façon dont j'ai provoqué la récursivité.}

Lisp, 58 octets

Ma première fois en écrivant Lisp!

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

Vous pouvez utiliser cet ajout spécial exactement comme vous le feriez habituellement avec Lisp:

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

J'aimerais entendre des suggestions car je suis nouveau dans la langue.

Sérieusement, 10 octets

,Σ1±╤_G_\+

Ce programme génère une variable aléatoire à partir d'une distribution géométrique en transformant une distribution uniforme. Il prend les entrées sous forme de liste: [2,3](accolades facultatives). Essayez-le en ligne .

Explication:

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

Étant donné une variable aléatoire X ~ Uniform(0, 1), il peut être transformé en une variable aléatoire Y ~ Geometric(p)avec la formule Y = floor(log(X)/log(p)).

Mathematica, 32 octets

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

Explication:

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

Notez que cette fonction fonctionne pour n’importe quel nombre d’entrées.

TeaScript , 18 octets 21

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

Ceci est une fonction TeaScript. Attribuez-le à une variable ou exécutez-le directement.

Essayez-le en ligne

Candy , 11 octets

+#10H{.}10g

La forme longue est:

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 octets

Premier code-golf, fait en C ... Je ne pense pas que ça battra quoi que ce soit, et peut être beaucoup joué au golf

EDIT 3: coupé 2 octets grâce à @Mego, en écrivant .1 au lieu de 0.1 et en réécrivant l'opérateur ternaire

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

EDIT 2: 12 octets coupés, après gnu99, chaque variable est un entier si ce n’est pas indiqué autrement. Il en va de même pour le type de fonction de retour

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

EDIT: coupé 20 octets, oublié que les bases .h ne sont pas nécessaires en C99 (en utilisant gcc par exemple). Cela produira un avertissement :)

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

Solution de 71 octets:

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

Si vous voulez voir beaucoup de résultats, vous pouvez utiliser le code suivant

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

r.1H$YlY[ihs

La saisie est de la forme [3 4], c’est-à-dire un vecteur ligne avec les deux nombres.

Exemple

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

Explication

Cela génère la variable aléatoire géométrique sans boucle, en appliquant directement une transformation à une variable aléatoire uniforme. Notez que log _0.1 a est utilisé à la place de log a / log 0.1 pour enregistrer 1 octet.

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 octets

isi+vzr10!{l1vzr10!}l

J'ai essayé de répondre à Microscript II mais, pour une raison quelconque, la boucle d'addition ne fonctionnait pas correctement :(

Mouse-2002 , 41 39 38 octets

Pas de récursion.

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

A expliqué:

&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

Ou, si vous êtes un fan de programmation fonctionnel, et que la récursivité est votre affaire, alors 57 octets :

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

A expliqué:

&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

Gelée , 7 octets (non concurrente)

‘⁵XỊ¤¿+

Essayez-le en ligne!

Comment ça fonctionne

‘⁵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 ^{SBCS de} 12 octets

Fondamentalement identique à la solution Pyth de FryAmTheEggman . -1 merci à Erik l'Outgolfer.

Fonction infixe tacite anonyme.

{⍵+1=?10}⍣=+

Essayez-le en ligne!

+ ajouter les arguments

{… }⍣= Applique la fonction suivante jusqu'à ce que deux applications successives donnent le même résultat:

 ?10 nombre entier aléatoire compris entre 1 et 10

 1= est-ce qu'on est égal à ça? (ie ¹ ⁄ ₁₀ ^ème chance)

 ⍵+ ajouter l'argument à cela

Perl 6 , 26 octets

En train de le faire récursivement:

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

Créez une séquence de 1s éventuellement vide suivie des arguments, puis additionnez-les.

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

(il peut en réalité prendre n'importe quel nombre d'arguments)

usage:

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

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

Pyth, 11 octets

+sQ-18l`hO0

Un port Pyth direct de ma réponse Python .

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

Octave, 20 octets

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

Somme des entrées, plus un échantillon aléatoire de la distribution géométrique avec paramètre 0.9.

Sérieusement, 13 octets

,,1W+9uJYWDkΣ

Utilise une stratégie similaire à la réponse CJam de Doorknob (numéro d’incrément lorsque float aléatoire est inférieur à 0,1), sauf qu’il utilise des entiers et s’incrémente tandis que nombre entier aléatoire [0,9]est inférieur à 1. Le manque de récursion facile fait mal.

Essayez-le en ligne (nécessite une saisie manuelle)

Explication:

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

La boucle while laisse la pile comme ceci:

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

Déplacer nvers le haut de 1 est nécessaire pour obtenir la boucle while à exécuter, car 0est falsey. Il est facile à gérer en décrémentant naprès la boucle while, le résultat final est donc a + b + (n - 1).

MATLAB, 51 octets

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

Le résultat est trouvé dans la variable automatique 'ans'