受亚历克斯（Alex）光荣的启发，学习R成为一个很好的例子，我们将谦虚地重建亚历克斯（Alex）的“一个真正的R程序”-但要有所作为。

Alex风格的加法就是这样的-它有90％的机会简单地返回给定的两个数字的和，还有10％的机会递归Alex加上第一个数字和第二个数字+1。这意味着，潜在地，则相加可能相差1或更多。

挑战

编写一个完整的程序或函数，该程序或函数需要两个整数并按定义将它们相加。您可以假设如果您的语言没有尾递归，则程序不会堆栈溢出。（请注意，只要概率相同，就不必递归实现它。）

参考实现（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;
  }
}

在线尝试这个小提琴。

排行榜

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>

珀斯8

u+G!OTsQ

在线尝试

这在Pyth的reduce上使用第二种模式，该模式寻找重复的输入然后退出。

说明

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

如果出现额外的alex-add，它将再次运行，但是如果没有，则退出。

Python 2，55个字节

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

这是绝对奇怪的方法。

该函数random在[0,1）中提供浮点数，默认情况下，其字符串表示形式在小数点后具有16位数字，总共18个字符。但是，由于省略了尾随的0，因此它可能会更短。从末尾读取数字，每个数字都有1/10的机会为0，当我们碰到一个非零数字时，我们停止。因此，尾随零的数量的分布与Alex进行的递归次数相同，因此我们可以从该分布中减去18减去字符串长度来进行采样。

实际上，Python会显示18位以上的小数字，有时甚至显示科学计数法，因此我们加1来解决此问题。

这永远不会超过总和15，但这没关系，因为10 ^ 15远小于宇宙射线干扰计算的机会。

R，60 47 28字节

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

这是一个未命名的函数对象，它接受两个数字并返回一个数字。它不使用递归。

正如xnor在评论中指出的那样，这个问题可以看作是简单地将两个数字加一个失败概率为1/10的几何随机变量相加。

为什么会这样呢？就像在帖子中描述的那样，从递归的角度考虑它。在每次迭代中，我们有10％的机会加1并进行递归，还有90％的机会在不进行进一步加法的情况下退出函数。每次迭代都是其自己的独立伯努利试验，其结果为“加1，递归”（失败）和“退出”（成功）。因此，失败的概率为1/10，成功的概率为9/10。

在处理一系列独立的伯努利试验时，获得一次成功所需的试验次数遵循几何分布。在我们的例子中，每次递归意味着加1，所以当我们最终退出函数时，我们实际上已经计算了第一次成功之前发生的失败次数。这意味着结果将偏离的数量是来自几何分布的随机变量。

在这里，我们可以利用R内置的概率分布扩展套件和use rgeom，它从几何分布中返回一个随机值。

取消高尔夫：

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

Minkolang 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，就重复while循环，每次加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，则退出while循环。否则，它将继续。当我复制堆栈的顶部时，这将是[a+b,1]第二次循环，因此+开始时将1加起来（以后的行程也是如此）。

CJam，12 11个字节

{{+Amr!}h;}

感谢@MartinBütter用这个超级聪明的技巧节省了一个字节！

{         }
 {     }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机会），增加数字”，从而消除了递归的需要。

Javascript ES6，38个字节

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

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+到is）以占用1个字节。

旧的方法是基于以0到1之间的随机数的10为底的对数来计算要添加的数量a+b，但是由于浮点精度，最多只能重复15次。

iir10,2$YlZo-+

在此代码中，10,2$YlZo-对随机数执行以10为底的对数，并四舍五入为最接近的整数。

二进制编码的Golfical，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

可以使用随附的Encoder实用程序将此编码转换回原始图形表示形式，也可以使用该-x标志直接运行。

原始图片：

放大50倍：

说明：第一行是主要块。它读取一个数字，将其复制到右侧，读取另一个数字，将其相加，将结果复制到右侧，进行一些RNG填充，并以90％的概率打印出相加的结果。剩下的时间，它被发送到最下面一行，在第一个单元格中放一个，然后在加法指令之前返回主行（先北转然后东转）。

Python，66 65 64 63字节

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

在线尝试

感谢Sherlock9进行的更正和字节的保存。

感谢Mathias Ettinger的另一个帮助。

感谢mbomb007一个字节。

朱莉娅，30个字节

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

这是一个递归函数f，它接受两个数字并返回相同类型的数字。对于任何数字类型，它都应该可以正常工作。

首先，我们检查0和1之间的随机浮点数是否大于0.9。如果是这样，我们递归一些“ somethin”，否则我们只添加。

TI-BASIC，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的数字。

APL，17个字节

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

这是一个未命名的二进位函数。

取消高尔夫：

{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字节

KsQW!OT=hK;K

我的第一个真正的Pyth高尔夫！

在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通过给我一种增加变量的更短方法来减少两个字符！

Vitsy，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机会。由于我如何造成递归，它也会在错误时退出。}

Lisp，58个字节

我第一次写Lisp！

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

您可以像通常在Lisp中添加的那样完全使用此特殊添加项：

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

我很想听听建议，因为我是该语言的新手。

认真地，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))。

Mathematica，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.

请注意，此功能适用于任意数量的输入。

TeaScript，18字节21

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

这是一个TeaScript函数。将其分配给变量或直接运行。

在线尝试

糖果，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

C，71 51 39 37字节

第一个代码高尔夫球，用C语言完成...我认为它不会击败任何东西，并且可能会失败很多

编辑3：通过写.1而不是0.1并重写三元运算符，感谢@Mego削减了2个字节

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

编辑2：在gnu99之后，削减了12个字节，如果没有另外说明，则每个变量都是一个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;
}

MATL，12 13 14字节

r.1H$YlY[ihs

输入的形式为[3 4]，即具有两个数字的行向量。

例

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

说明

通过将a 变换直接应用于统一随机变量，可以生成没有循环的几何随机变量。请注意，使用log _0.1 a代替了log a / log 0.1以节省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

缩图，29 21字节

isi+vzr10!{l1vzr10!}l

我试图做出一个Microscript II答案，但是由于某种原因，我无法使加法循环正常工作:(

鼠标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

果冻，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.

APL（Dyalog Unicode），13 12 字节^SBCS

基本上与FryAmTheEggman的Pyth解决方案相同。-1感谢Outgolfer。

匿名默认隐式函数。

{⍵+1=?10}⍣=+

在线尝试！

+ 添加参数

{… }⍣= 应用以下功能，直到两个连续的应用程序具有相同的结果：

 ?10 1-10范围内的随机整数

 1= 等于那个吗？（即¹ / ₁₀ ^个机会）

 ⍵+ 添加参数

Perl 6、26个字节

实际上以递归方式进行操作：

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

创建一个可能为空的1s后跟参数的序列，然后将它们加在一起。

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

（实际上可以接受任意数量的参数）

用法：

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

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

Pyth，11个字节

+sQ-18l`hO0

我的Python答案的直接Pyth端口。

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

八度，20字节

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

输入的总和，再加上来自带有参数的几何分布的随机样本0.9。

严重的是13个字节

,,1W+9uJYWDkΣ

使用与Doorknob的CJam答案类似的策略（随机浮点数小于0.1时递增，但使用整数），而随机整数in [0,9]小于1则递增。缺少简单递归会造成伤害。

在线尝试（需要手动输入）

说明：

,,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循环像这样离开堆栈：

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

n要运行while循环，必须上移1，因为它0是错误的。通过n在while循环后递减可以很容易地处理它，因此最终结果是a + b + (n - 1)。

MATLAB，51字节

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

结果在“ ans”自动变量中找到