Inspirados no glorioso aprendizado de Alex para você, para o bem, vamos recriar humildemente o "único programa de verdade R" de Alex - mas com uma reviravolta.

A adição no estilo Alex funciona assim - tem 90% de chance de retornar a soma dos dois números fornecidos e 10% de chance de recursivamente Alex adicionar o primeiro número e o segundo número + 1. Isso significa que, potencialmente , uma adição pode ser desativada em 1 ou mais.

Desafio

Escreva um programa ou função completo que use dois números inteiros e Alex os adicione conforme definido. Você pode presumir que o seu programa não excederá a pilha se o seu idioma não tiver recursão de cauda. (Observe que você não precisa implementá-lo recursivamente, desde que as probabilidades sejam as mesmas.)

Implementação de referência (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;
  }
}

Experimente este violino online.

Entre os melhores

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>

Pitão, 8

u+G!OTsQ

Experimente online

Isso usa o segundo modo de Pyth em reduzir, que procura por entradas repetidas e sai.

Explicação

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

Se o alex-add extra ocorrer, ele será executado novamente, mas, se não, será encerrado.

Python 2, 55 bytes

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

Esta é uma maneira absolutamente bizarra de fazer isso.

A função randomfornece um ponto flutuante em [0,1) e sua representação de cadeia por padrão possui 16 dígitos após o ponto decimal, com um total de 18 caracteres. Mas, como os zeros à direita são omitidos, pode ser mais curto. Lendo dígitos do final, cada um tem uma chance de 1/10 de ser 0, e paramos quando atingimos um dígito diferente de zero. Portanto, o número de zeros à direita é distribuído exatamente como o número de recursões que Alex faz, para que possamos amostrar nessa distribuição em 18 menos o comprimento da string.

Na verdade, o Python exibirá mais de 18 dígitos para números pequenos, às vezes até notação científica, então adicionamos 1 para corrigir isso.

Isso nunca dará mais que 15 a mais do que a soma, mas tudo bem, porque 10 ^ 15 é muito menor que a chance de um raio cósmico interromper a computação .

R, 60 47 28 bytes

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

Este é um objeto de função sem nome que aceita dois números e retorna um número. Não usa recursão.

Como o xnor apontou em um comentário, esse problema pode ser visto como simplesmente adicionando dois números mais uma variável aleatória geométrica com probabilidade de falha 1/10.

Por que isso é verdade? Pense nisso em termos de recursão, conforme descrito no post. Em cada iteração, temos 10% de chance de adicionar 1 e recorrente e 90% de sair da função sem adição adicional. Cada iteração é seu próprio teste independente de Bernoulli, com os resultados "adicione 1, recorra" (falha) e "saia" (êxito). Assim, a probabilidade de falha é 1/10 e a probabilidade de sucesso é 9/10.

Ao lidar com uma série de ensaios independentes de Bernoulli, o número de ensaios necessários para obter um único sucesso segue uma distribuição geométrica . No nosso caso, cada recursão significa adicionar 1; portanto, quando finalmente saímos da função, contamos essencialmente o número de falhas que ocorreram antes do primeiro sucesso. Isso significa que a quantidade pela qual o resultado será calculado é uma variável aleatória de uma distribuição geométrica.

Aqui, podemos tirar proveito do amplo conjunto de R de embutidos e uso de distribuição de probabilidade rgeom, que retorna um valor aleatório de uma distribuição geométrica.

Ungolfed:

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

Minkolang 0.14 , 19 11 12 bytes

Esta é a versão "function"; assume ae bjá está na pilha, abre e empurra a versão modificada de a+b. O mais próximo equivalente a funções em Minkolang é usar F, que aparece fora b, ae salta para (a,b)no codebox. Então, quando o contador de programa atinge um f, ele volta para onde Ffoi usado.

(+$01$h`d)xf

Esta é a versão completa do programa, 15 bytes . ( nnpega dois números da entrada e N.gera o resultado e para.)

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

Eu roubei o algoritmo da resposta da maçaneta da porta ; o loop while se repete desde que o número aleatório gerado seja menor que 0,1, adicionando 1 a cada vez. Experimente aqui (versão completa do programa) e execute-o 100 vezes aqui .

Explicação

(              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

A parte mais inteligente aqui é d. A parte superior da pilha nesse momento será 0 ou 1. Se for 0, o loop while será encerrado. Caso contrário, continua. Como eu duplico o topo da pilha, será [a+b,1]a segunda vez no loop, então +o começo adiciona o 1 (e da mesma forma para as viagens subseqüentes).

CJam, 12 11 bytes

{{+Amr!}h;}

Agradecemos a @ MartinBütter por salvar um byte com este truque super inteligente!

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

Resposta antiga:

{+({)Amr!}g}

Experimente online .

Explicação:

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

O algoritmo básico é "while (0.1 chance), incrementa o número", o que elimina a necessidade de recursão.

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]

Este é apenas o método do loop, adicione as entradas (inseridas como [a b]) e continue adicionando uma enquanto um número aleatório uniforme entre 0 e 1 é menor que 0,1. Descrição completa abaixo:

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    

Retirou 1 byte alterando as especificações de entrada (de ii+para is).

A maneira antiga era baseada no registro da base 10 de um número aleatório entre 0 e 1 para calcular a quantidade a ser adicionada a+b, no entanto, só funcionaria até 15 repetições devido à precisão do ponto flutuante.

iir10,2$YlZo-+

Nesse código, 10,2$YlZo-o logaritmo de base 10 do número aleatório é arredondado para o número inteiro mais próximo.

Golfical codificado em binário , 32 29 + 1 ( -xsinalizador) = 30 bytes

Hexdump (editado manualmente para corrigir um erro na parte da imagem para o binário do transpiler, que foi corrigida desde então):

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

Essa codificação pode ser convertida novamente na representação gráfica original usando o utilitário Encoder incluído ou executada diretamente usando o -xsinalizador.

Imagem original:

Ampliado 50x:

Explicação: A linha superior é o bloco principal. Ele lê um número, copia para a direita, lê outro número, os adiciona, copia o resultado para a direita, faz algumas coisas de RNG e, com probabilidade de 90%, imprime o resultado da adição. No restante do tempo, ele é enviado para a linha inferior, onde coloca uma na primeira célula e volta para a linha principal pouco antes da instrução de adição (usando uma curva norte e uma curva leste).

Python, 66 65 64 63 bytes

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

Experimente online

Obrigado a Sherlock9 pelas correções e pelo byte salvo.

Obrigado a Mathias Ettinger por outro byte.

Obrigado a mbomb007 por um byte.

Julia, 30 bytes

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

Essa é uma função recursiva fque aceita dois números e retorna um número do mesmo tipo. Deve funcionar bem para qualquer tipo numérico.

Primeiro, verificamos se um flutuador aleatório entre 0 e 1 é maior que 0,9. Nesse caso, recorremos a algo extra, caso contrário, apenas adicionamos.

TI-BASIC, 15 bytes

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

Isso leva a entrada como uma lista de dois elementos Ans. Embora um número aleatório seja menor que 0.1, ele adiciona vetorizado à 0.5lista. Aumentar cada elemento 0.5aumenta a soma em 1. Acredito que esta seja a solução TI-BASIC mais curta.

O programa de 9 bytes sum(Ans)-int(log(10randnão funciona, porque randpossui apenas 14 dígitos de precisão e, portanto, não pode fornecer um número menor que 10 ^-14 .

APL, 17 bytes

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

Esta é uma função diádica sem nome.

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

Pitão, 14 12 bytes

KsQW!OT=hK;K

Meu primeiro verdadeiro golfe Pyth!

Recebe entrada em STDIN no formato a,b.

Explicação:

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

Obrigado a @FryAmTheEggman por cortar dois caracteres, oferecendo uma maneira mais curta de incrementar uma variável!

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.

Experimente online!

_{Observe que isso tem uma pequena chance de um erro de estouro de pilha. Estamos falando de (.1)^400chance. Ele também sai por erro devido a como eu causei recursão.}

Lisp, 58 bytes

Minha primeira vez escrevendo Lisp!

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

Você pode usar esta adição especial exatamente como você normalmente adicionaria no Lisp:

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

Gostaria muito de ouvir sugestões, pois sou novo no idioma.

Sério, 10 bytes

,Σ1±╤_G_\+

Este programa gera uma variável aleatória a partir de uma distribuição geométrica, transformando uma distribuição uniforme. Ele recebe a entrada como uma lista: [2,3](chaves opcionais). Experimente online .

Explicação:

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

Dada uma variável aleatória X ~ Uniform(0, 1), ela pode ser transformada em uma variável aleatória Y ~ Geometric(p)com a fórmula Y = floor(log(X)/log(p)).

Mathematica, 32 bytes

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

Explicação:

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

Observe que esta função funciona para qualquer número de entradas.

TeaScript , 18 bytes 21

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

Esta é uma função TeaScript. Atribua-o a uma variável ou apenas execute-o diretamente.

Experimente online

Doces , 11 bytes

+#10H{.}10g

A forma longa é:

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

Primeiro código-golfe, feito em C ... Eu não acho que ele vai bater em nada, e pode ser muito jogado para baixo

EDIT 3: cortou 2 bytes graças a @Mego, escrevendo 0,1 em vez de 0,1 e reescrevendo o operador ternário

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

EDIT 2: cortado 12 bytes, seguindo o gnu99, toda variável é um int se não declarado de outra forma. O mesmo vale para o tipo de retorno de função

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

EDIT: cortou 20 bytes, esqueceu que o .h básico não é necessário no C99 (usando o gcc por exemplo). Isso produzirá um aviso :)

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

Solução de 71 bytes:

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

Se você deseja ver muita saída, pode usar o seguinte código

#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

A entrada é do formato [3 4], ou seja, um vetor de linha com os dois números.

Exemplo

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

Explicação

Isso gera a variável aleatória geométrica sem loops, aplicando diretamente uma transformação a uma variável aleatória uniforme. Observe que o log _0.1 a é usado em vez do log a / log 0.1 para salvar 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

Microscript , 29 21 bytes

isi+vzr10!{l1vzr10!}l

Tentei fazer uma resposta do Microscript II, mas por algum motivo não consegui fazer o loop de adição funcionar corretamente :(

Mouse-2002 , 41 39 38 bytes

Sem recursão.

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

Explicado:

&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, se você é um fanboy da programação funcional, e a recursão é sua, então 57 bytes :

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

Explicado:

&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

Gelatina , 7 bytes (não concorrente)

‘⁵XỊ¤¿+

Experimente online!

Como funciona

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

Basicamente, o mesmo que a solução Pyth de FryAmTheEggman . -1 graças a Erik, o Outgolfer.

Função de infixo tácito anônimo.

{⍵+1=?10}⍣=+

Experimente online!

+ adicione os argumentos

{… }⍣= Aplique a seguinte função até que dois aplicativos sucessivos tenham o mesmo resultado:

 ?10 número inteiro aleatório no intervalo de 1 a 10

 1= é igual a isso? (ou seja, ¹ / ₁₀ ^th acaso)

 ⍵+ adicione o argumento a isso

Perl 6 , 26 bytes

Na verdade, fazer isso recursivamente:

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

Crie uma sequência possivelmente vazia de 1s seguida pelos argumentos e depois some todos eles.

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

(na verdade, pode levar qualquer número de argumentos)

uso:

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

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

Pitão, 11 bytes

+sQ-18l`hO0

Uma porta Pyth direta da minha resposta 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)

Oitava, 20 bytes

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

Soma das entradas, além de uma amostra aleatória da distribuição geométrica com parâmetro 0.9.

Sério, 13 bytes

,,1W+9uJYWDkΣ

Usa uma estratégia semelhante à resposta CJam da maçaneta da porta (número de incremento enquanto a flutuação aleatória é menor que 0,1), exceto que ele usa números inteiros e incrementa enquanto o número inteiro aleatório [0,9]é menor que 1. A falta de recursão fácil é prejudicial.

Experimente on-line (precisa de entrada manual)

Explicação:

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

O loop while deixa a pilha assim:

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

Mudar npara 1 é necessário para que o loop while seja executado, pois 0é falsey. É fácil lidar com isso, diminuindo napós o loop while, portanto o resultado final é a + b + (n - 1).

MATLAB, 51 bytes

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

O resultado é encontrado na variável automática 'ans'