Adição no estilo Alex

57

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>

um spaghetto
fonte
6
Então, dá a soma de dois números mais uma variável aleatória geométrica com probabilidade de falha de 1/10?
xnor
@ xnor Essencialmente, sim. I definiu recursivamente de modo que é mais fácil de entender, mas você não tem que fazê-lo de forma recursiva (solução CJam não faz, por exemplo)
um Spaghetto
10
Por que essa caixa de proteção foi bloqueada por 20 minutos? Parece que está faltando o ponto da caixa de areia.
Peter Taylor
3
@PeterTaylor O único pequeno problema foi resolvido quase imediatamente, e a pergunta era tão simples que não achei que fosse necessário permanecer na caixa de areia por tanto tempo (ela já havia sido analisada por 10 pessoas e achava suficiente revisão para um desafio tão simples). A principal razão pela qual eu o coloquei na sandbox foi ver se as pessoas pensavam que era muito simples.
a spaghetto
2
Eu diria que ainda tem um problema importante, pois não está claro se você insiste em que as implementações sejam escritas como funções recursivas ou apenas dando a distribuição correta, mas é tarde demais para esclarecer isso agora.
Peter Taylor

Respostas:

40

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.

FryAmTheEggman
fonte
13
Isso ... é pura magia negra. O_o
Maçaneta da porta
11
Isto é ridículo.
gato
36

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 .

xnor
fonte
11
Desculpe, esta resposta é inválida, pois tem 10 ^ -15 de chance de não funcionar corretamente , o que é explicitamente proibido pelo meta post vinculado.
precisa saber é
22

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)
}
Alex A.
fonte
13

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

El'endia Starman
fonte
Isso é realmente uma função? Examinei rapidamente a documentação do idioma e não consegui encontrar nada que descrevesse as definições de função. Com base na explicação, parece mais um fragmento de código.
Reto Koradi
@RetoKoradi: Eu posso colocar um "fragmento de código" em sua própria linha, pular para 0kF (onde k é algum número) e voltar com f no final. É o mais próximo que você vai conseguir de uma função em Minkolang.
El'endia Starman
2
Não é tecnicamente o mesmo que dizer "meu fragmento de código CJam é uma função; você só precisa cercá-lo com chaves"? No mínimo, você provavelmente deve incluir o fno final da contagem de caracteres (e tecnicamente a nova linha anterior, se estiver se sentindo extremamente pedante, mas acho que não é necessário).
Maçaneta da porta
11
Se o idioma não tiver funções, você sempre poderá publicar programas completos. Meu entendimento é que, quando diz "função", ela precisa ser uma função nomeada ou uma função anônima (que normalmente é uma expressão que pode ser atribuída a uma variável de função). Certa vez, publiquei algo semelhante a isso no CJam, e Martin rapidamente me chamou, dizendo que era um fragmento de código, e não uma função.
Reto Koradi
@RetoKoradi: Tudo bem, isso é compreensível. O que você acha da sugestão de Maçaneta de porta?
El'endia Starman
12

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.

Maçaneta da porta
fonte
8

Javascript ES6, 38 bytes

f=(a,b)=>Math.random()<.1?f(a,b+1):a+b
SuperJedi224
fonte
f=(a,b)=>new Date%10<1?f(a,b+1):a+bpara 35 bytes
WallyWest
2
@WallyWest Infelizmente, a probabilidade de usar o Datecarimbo de data e hora não será precisa, porque, se avaliar true, continuará adicionando 1o restante do milissegundo.
user81655
Eu tentei a distribuição geométrica, f=(a,b)=>a+b-~~Math.log10(Math.random())mas é 2 bytes mais.
Neil
8

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.

David
fonte
Comentário justo, embora eu gostaria de ver você gerar 15 com qualquer outra solução apresentada: P Outra maneira, por 15 bytes, é a versão de loop simples ii+`10Yr1=tb+w]:, ainda não jogada.
David
Na verdade, eu posso fazer o loop mais curto! Obrigado @ThomasKwa!
David
Muito bem feito!
Luis Mendo
7

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: insira a descrição da imagem aqui

Ampliado 50x:

insira a descrição da imagem aqui

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

SuperJedi224
fonte
2
Você pode adicionar uma explicação? Isso é super legal.
gato
7

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.

Mego
fonte
62?
somente ASCII
O uso apenas de ASCII .9>random()não é exatamente 9 de 10, por causa da distribuição desigual de flutuadores
Mego
6

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.

Alex A.
fonte
6

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 .

lirtosiast
fonte
11
Vale ressaltar que para adicionar 14, você também terá que assistir porcos voar e o inferno congelar. E quando você adicionar 14, eu terei feito algo com a minha vida.
Nic Hartley
5

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
Alex A.
fonte
5

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!

Maçaneta da porta
fonte
5

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.

Addison Crump
fonte
4

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.

barra sudo rm -rf
fonte
Funcionaria (- a(- -1 b))? Economiza 2 bytes, se houver.
Neil
@ Neil, eu não acho que isso funcione porque a função deve ser recursiva
sudo rm -rf slash
Obrigado por explicar por que a expressão parece tão complicada.
Neil
4

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

Mego
fonte
3

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.

LegionMammal978
fonte
3

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

Downgoat
fonte
3

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
Dale Johnson
fonte
3

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;
}
Katenkyo
fonte
3

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
Luis Mendo
fonte
3

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 :(

SuperJedi224
fonte
3

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
gato
fonte
3

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.
Dennis
fonte
3

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, 1 / 10 th acaso)

⍵+ adicione o argumento a isso

Adão
fonte
Você pode usar dois números inteiros como dois argumentos e remover o /.
Erik the Outgolfer
@EriktheOutgolfer Yeah.
Adám
2

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 ... *
Brad Gilbert b2gills
fonte
23 bytes
bb94 14/04
2

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)
xnor
fonte
2

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.

alefalpha
fonte
2

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

Mego
fonte
2

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'

costrom
fonte