[Question]
  [
Inspired by Alex's glorious [Learn you an R for great good,](http://chat.stackexchange.com/transcript/message/26140903#26140903) we are going to humbly recreate Alex's "one true R program" -- but with a twist.
Alex-style Addition works like this -- it has a 90% chance of simply returning the sum of the two numbers given and a 10% chance of recursively Alex-adding the first number and the second number + 1. This means that, potentially, an addition could be off by 1 or more.
## Challenge
Write a full program or function that takes two integers and Alex-adds them as defined. You may assume that your program will not stack overflow if your language doesn't have tail recursion. (Note that you do not have to implement it recursively, as long as the probabilities are the same.)
## Reference Implementation (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;
  }
}
```
[Try this fiddle online.](http://ideone.com/fork/raQz47)
## Leaderboard
```
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>
```
  
[Answer]
# Pyth, 8
```
u+G!OTsQ
```
[Try it online](https://pyth.herokuapp.com/?code=u%2BG%21OTsQ&input=3%2C4&debug=0)
This uses Pyth's second mode on reduce, that looks for repeated input then exits.
### Explanation
```
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
```
If the extra alex-add occurs it will run again, but if not then it exits.
[Answer]
# R, ~~60~~ ~~47~~ 28 bytes
```
function(a,b)a+b+rgeom(1,.9)
```
This is an unnamed function object that accepts two numbers and returns a number. It does not use recursion.
As xnor pointed out in a comment, this problem can be viewed as simply adding two numbers plus a geometric random variable with failure probability 1/10.
Why is that true? Think about it in terms of recursion, as it's described in the post. In each iteration we have a 10% chance of adding 1 and recursing, and a 90% chance of exiting the function without further addition. Each iteration is its own independent [Bernoulli trial](https://en.wikipedia.org/wiki/Bernoulli_trial) with outcomes "add 1, recurse" (failure) and "exit" (success). Thus the probability of failure is 1/10 and the probability of success is 9/10.
When dealing with a series of independent Bernoulli trials, the number of trials needed to obtain a single success follows a [geometric distribution](https://en.wikipedia.org/wiki/Geometric_distribution). In our case, each recursion means adding 1, so when we do finally exit the function, we've essentially counted the number of failures that occurred before the first success. That means that the amount that the result will be off by is a random variate from a geometric distribution.
Here we can take advantage of R's expansive suite of probability distribution built-ins and use `rgeom`, which returns a random value from a geometric distribution.
Ungolfed:
```
f <- function(a, b) {
    a + b + rgeom(n = 1, prob = 0.9)
}
```
[Answer]
## [Minkolang 0.14](https://github.com/elendiastarman/Minkolang), ~~19~~ ~~11~~ 12 bytes
This is the "function" version; it assumes `a` and `b` are already on the stack, pops them off and pushes the modified version of `a+b`. The closest equivalent to functions in Minkolang is to use `F`, which pops off `b`,`a` and jumps to `(a,b)` in the codebox. Then when the program counter hits an `f`, it jumps back to where `F` was used.
```
(+$01$h`d)xf
```
This is the full program version, **15 bytes**. (`nn` takes two numbers from input and `N.` outputs the result and stops.)
```
nn(+$01$h`d)xN.
```
I stole the algorithm from [Doorknob's answer](https://codegolf.stackexchange.com/a/66524/12914); the while loop repeats so long as the generated random number is less than 0.1, adding 1 each time. [Try it here](http://play.starmaninnovations.com/minkolang/?code=nn2%7B1%24h%240%603%261%2B%7B%2B%7DN%2E&input=3%205) (full program version) and [run it 100 times here](http://play.starmaninnovations.com/minkolang/?code=%24l%5B35%28%2B%2401%24h%60d%29xNlO%5D%2E&input=3%205).
### Explanation
```
(              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
```
The cleverest part here is `d`. The top of stack at that point in time will be either 0 or 1. If it's 0, the while loop exits. Otherwise, it continues. As I duplicate the top of stack, it will be `[a+b,1]` the second time through the loop, so the `+` at the beginning adds the 1 (and likewise for subsequent trips).
[Answer]
## CJam, ~~12~~ 11 bytes
```
{{+Amr!}h;}
```
Thanks to @MartinBütter for saving a byte with this super clever 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.
```
---
Old answer:
```
{+({)Amr!}g}
```
[Try it online](http://cjam.tryitonline.net/#code=MTAgMTAKeysoeylBbXIhfWd9Cn4).
Explanation:
```
{          }  A "function."
 +            Add the input numbers.
  (           Decrement.
   {     }g   A while loop.
    )         Increment.
     Amr      Random number [0,9).
        !     Boolean NOT.
```
The basic algorithm is "while (0.1 chance), increment the number," which eliminates the need for the recursion.
[Answer]
# Javascript ES6, 38 bytes
```
f=(a,b)=>Math.random()<.1?f(a,b+1):a+b
```
[Answer]
## TI-BASIC, 15 bytes
```
While rand<.1
Ans+.5
End
sum(Ans
```
This takes the input as a two-element list from `Ans`. While a random number is less than `0.1`, it does vectorized addition to `0.5` on the list. Increasing each element by `0.5` increases the sum by 1. I believe this is the shortest TI-BASIC solution.
The 9-byte program `sum(Ans)-int(log(10rand` doesn't work, because `rand` only has 14 digits of precision, and thus it can't give a number less than 10-14.
[Answer]
## [MATL](https://esolangs.org/wiki/MATL), ~~14~~ ~~13~~ 12 bytes
```
is`r.1<tb+w]
```
This is just the loop method, add the inputs (entered as `[a b]`) then keep adding one while a uniform random number between 0 and 1 is less than 0.1. Full description below:
```
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    
```
Took off 1 byte by changing input spec (from `ii+` to `is`).
---
The old way was based on taking the base-10 log of a random number between 0 and 1 to work out the amount to add to `a+b`, however it would only work up to 15 repetitions due to floating point accuracy.
```
iir10,2$YlZo-+
```
In this code, `10,2$YlZo-` does base-10 logarithm of the random number and rounds up to the nearest integer.
[Answer]
# Binary-Encoded [Golfical](https://github.com/SuperJedi224/Golfical), ~~32~~ 29+1 (`-x` flag) = 30 bytes
Hexdump (manually edited to correct for a bug in the image-to-binary part of the transpiler, which has since been fixed):
```
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
```
This encoding can be converted back into the original graphical representation using the included Encoder utility, or run directly using the `-x` flag.
Original image:
![enter image description here](https://i.stack.imgur.com/E60jJ.png)
Magnified 50x:
![enter image description here](https://i.stack.imgur.com/L431i.png)
Explanation: The top row is the main block. It reads a number, copies it to the right, reads another number, adds them, copies the result to the right, does some RNG stuff, and, with probability 90%, prints the result of the addition. The rest of the time, it is sent to the bottom row, where it puts a one in the first cell and goes back to the main row just before the addition instruction (using a north turn then an east turn).
[Answer]
## Python, ~~66~~ ~~65~~ ~~64~~ 63 bytes
```
from random import*
g=lambda*s:randint(0,9)and sum(s)or g(1,*s)
```
[Try it online](https://tio.run/##LYnLCoAgEADvfoXHXfFQdiroYwzJhHyw6qGv3ww6zQxTnnblZJhPylGSTW4gxJKpKeH328bDWVW374TUYNIrDpW1R6iYSXqYtarIhcYeFVLpDVD/RDZieQE)
Thanks to Sherlock9 for the corrections and the byte saved.
Thanks to Mathias Ettinger for another byte.
Thanks to mbomb007 for a byte.
[Answer]
# Julia, 30 bytes
```
f(a,b)=rand()>0.9?f(a,b+1):a+b
```
This is a recursive function `f` that accepts two numbers and returns a number of the same type. It should work fine for any numeric type.
First we check whether a random float between 0 and 1 is greater than 0.9. If so, we recurse with a little extra somethin' somethin', otherwise we just add.
[Answer]
# [Vitsy](https://github.com/VTCAKAVSMoACE/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.
```
[Try it online!](http://vitsy.tryitonline.net/#code=YVIpWzErMG1dK04&input=&args=NA+NQ)
Note that this has a *tiny* chance of a stack overflow error. We're talking `(.1)^400` chance. It also exits on error due to how I caused recursion.
[Answer]
# APL, 17 bytes
```
{1=?10:⍺∇⍵+1⋄⍺+⍵}
```
This is an unnamed dyadic function.
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
```
[Answer]
## Pyth, ~~14~~ 12 bytes
```
KsQW!OT=hK;K
```
My first real Pyth golf!
Takes input on STDIN in the format `a,b`.
Explanation:
```
KsQ       read STDIN, assign sum to variable K
W         while...
  !OT       not rand(10)
  =hK;      increment K
K         implicit-output of K
```
Thanks to @FryAmTheEggman for shaving off two chars by giving me a shorter way to increment a variable!
[Answer]
# Lisp, 58 bytes
My first time writing Lisp!
```
(defun +(a b)(if(<(random 10)9)(- a(- b))(- a(-(+ b 1)))))
```
You can use this special addition exactly as you would usually add in Lisp:
```
> (+ 1 3)
4
> (+ 1 3)
5
```
I would love to hear suggestions as I am brand new to the language.
[Answer]
## Seriously, 10 bytes
```
,Σ1±╤_G_\+
```
This program generates a random variable from a geometric distribution by transforming a uniform distribution. It takes input as a list: `[2,3]` (braces optional). [Try it online](http://seriouslylang.herokuapp.com/link/code=2ce431f1d15f475f5c2b&input=2,2).
Explanation:
```
,Σ1±╤_G_\+
,Σ          get sum of input
  1±╤_      push ln(0.1)
      G_    push ln(random(0,1))
        \   floored division
         +  add
```
Given a random variable `X ~ Uniform(0, 1)`, it can be transformed to a random variable `Y ~ Geometric(p)` with the formula `Y = floor(log(X)/log(p))`.
[Answer]
## Mathematica, 32 bytes
```
If[RandomReal[]<.1,+##,#0@##+1]&
```
Explanation:
```
                               &   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.
```
Note that this function works for any number of inputs.
[Answer]
# [TeaScript](https://github.com/vihanb/TeaScript), 18 bytes ~~21~~
```
#$r<.1?f(l,i¬):l+i
```
This is a TeaScript function. Assign it to a variable or just run it directly.
[Try it online](http://vihanserver.tk/p/TeaScript/#?code=%22f%3D%23$r%3C.1%3Ff(l,i%C2%AC):l%2Bi;%5Cnf(3,4)%22&inputs=%5B%223%22,%224%22%5D&opts=%7B%22int%22:true,%22ar%22:false,%22debug%22:false,%22chars%22:false,%22html%22:false%7D)
[Answer]
# [Candy](https://github.com/dale6john/candy), 11 bytes
```
+#10H{.}10g
```
The long form is:
```
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
```
[Answer]
# C, ~~71~~ ~~51~~ ~~39~~ 37 bytes
First code-golf, done in C... I don't think it will beat anything, and may be golfed down a lot
EDIT 3: cuted 2 bytes thanks to @Mego , by writing .1 instead of 0.1 and rewriting the ternary operator
```
a(x,y){return(rand()<.1?a(1,y):y)+x;}
```
EDIT 2: cuted 12 bytes, following gnu99, every variable is an int if not stated otherwise. Same goes for the return type of function
```
a(x,y){return rand()<0.1?a(x,y+1):x+y;}
```
EDIT : cuted 20 bytes, forgot that basic .h aren't necessary in C99 (using gcc for instance). It will produce a warning :)
```
int a(int x,int y){return rand()<0.1?a(x,y+1):x+y;}
```
71 Bytes solution :
```
#include <stdlib.h>
int a(int x,int y){return rand()<0.1?a(x,y+1):x+y;}
```
If you want to see lots of output, you can use the following code
```
#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;
}
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 12 ~~13~~ ~~14~~ bytes
```
r.1H$YlY[ihs
```
Input is of the form `[3 4]`, that is, a row vector with the two numbers.
### Example
```
>> matl r.1H$YlY[ihs
> [3 4]
7
```
### Explanation
This generates the geometric random variable without loops, by directly applying a a [transformation](https://en.wikipedia.org/wiki/Geometric_distribution#Related_distributions) to a uniform random variable. Note that log0.1 *a* is used instead of log *a* / log 0.1 to save 1 byte.
```
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
```
[Answer]
# [Microscript](https://github.com/SuperJedi224/Microscript), ~~29~~ 21 bytes
```
isi+vzr10!{l1vzr10!}l
```
I tried to make a Microscript II answer but for some reason I couldn't get the addition loop to work right :(
[Answer]
# [Mouse-2002](https://github.com/catb0t/newmouse/blob/master/mouse.c), ~~41~~ ~~39~~ 38 bytes
No recursion.
```
&TIME &SEED ??&RAND k*&INT 9=[+1+!|+!]
```
Explained:
```
&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
```
---
Or, if you're a functional programming fanboy, and recursion is your deal then **57 bytes**:
```
&TIME &SEED #A,?,?;!$A&RAND k*&INT 9=[#A,1%,2%1+;|1%2%+]@
```
Explained:
```
&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
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~13~~ 12 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Basically the same as [FryAmTheEggman's Pyth solution](https://codegolf.stackexchange.com/a/66536/43319). -1 thanks to Erik the Outgolfer.
Anonymous tacit infix function.
```
{⍵+1=?10}⍣=+
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v/pR71ZtQ1t7Q4PaR72LbbX/pz1qm/Cot@9R31RP/0ddzYfWGz9qmwjkBQc5A8kQD8/g/8YKaYdWmBo86t1iovCod65CSVGlQmaJQnlmSYaCsUJiXoqCiUJaZlpJpUJJZm5qMQA "APL (Dyalog Unicode) – Try It Online")
`+` add the arguments
`{`…`}⍣=` apply the following function until two successive applications have the same result:
 `?10` random integer in the range 1–10
 `1=` is one equal to that? (i.e. 1⁄10th chance)
 `⍵+` add the argument to that
[Answer]
# Java 8, ~~57~~ 56 bytes
4 years and no Java answer? Shame.
```
int a(int a,int b){return.1>Math.random()?a(a,b+1):a+b;}
```
[Try it online!](https://tio.run/##LcyxCoMwGEXhPU@RMUEbyFqhfQInR@lwY8TGapTkVyjis6dp6XKWA9@IHZfRvlI3IUZew/mDRQK5jifniUP8Wn5r5BF62oJX@laDnirA22UW8g6B0hRaXlGY6kzrZqYM/J19cZbPWRYNBeeH9oEwRHmw5h2pn9WykVrzoMkLCF1qKSt2nukD)  
-1 byte thanks to ceilingcat
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `RṀ`, 7 bytes
```
+{₀℅¬|›
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=R%E1%B9%80&code=%2B%7B%E2%82%80%E2%84%85%C2%AC%7C%E2%80%BA&inputs=1%0A2&header=&footer=)
# [Vyxal](https://github.com/Vyxal/Vyxal), 8 bytes
```
+{₀ʁ℅¬|›
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%2B%7B%E2%82%80%CA%81%E2%84%85%C2%AC%7C%E2%80%BA&inputs=1%0A2&header=&footer=)
```
+        # Add the two (implicitly input) numbers
 {       # While...
    ℅    # Random choice of...
   ʁ     # range 0 to...     (Unnecessary in flagged version)
  ₀      # 10 (exclusive)
     ¬   # Is 0
      |› # Increment
```
[Answer]
# [Julia 1.0](http://julialang.org/), 27 bytes
```
a\b=rand()<.1 ? 1+a\b : a+b
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/PzEmybYoMS9FQ9NGz1DBXsFQGyiiYKWQqJ30v6AoM68kJ0@juDRXwyDGQCEtv0ghUyEzT8HQytDAwEBTkwumQpOLC1WSSwEIYLImMaaaXKl5Kf8B "Julia 1.0 – Try It Online")
**Bonus: for 2 additionnal bytes, we can overwrite the `+` function for even more fun:**
```
a+b=rand()<.1 ? -~a+b : a- -b
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/P1E7ybYoMS9FQ9NGz1DBXkG3DiiiYKWQqKugm/S/oCgzryQnT6O4NFfDQNtAIS2/SCFTITNPwdDK0MDAQFOTC6ZCk4sLVZJLAQgcijPyyxVMtE25UvNS/gMA "Julia 1.0 – Try It Online")
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
‘⁵XỊ¤¿+
```
[Try it online!](http://jelly.tryitonline.net/#code=4oCY4oG1WOG7isKkwr8r&input=&args=MTM+Mjk)
### How it works
```
‘⁵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.
```
[Answer]
# [Perl 6](http://perl6.org), 26 bytes
Actually doing it recursively:
```
sub f{.1>rand??f |@_,1!![+] @_} # 31 bytes
```
---
Create a possibly empty sequence of `1`s followed by the arguments, then sum them all together.
```
{[+] {1}...^{rand>.1},|@_} # 26 bytes
```
( it can actually take any number of arguments )
usage:
```
# give the lambda a name
my &f = {...}
say f 1,2; # one of 3,4,5 ... *
```
[Answer]
## Pyth, 11 bytes
```
+sQ-18l`hO0
```
A direct Pyth port of my [Python answer](https://codegolf.stackexchange.com/a/66538/20260).
```
+             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)
```
[Answer]
# Octave, 20 bytes
```
@(a,b)a+b+geornd(.9)
```
Sum of the inputs, plus a random sample from the geometric distribution with parameter `0.9`.
]