Inspirado por el glorioso Alex's Learn you an R for great good, vamos a recrear humildemente el "único programa de R verdadero" de Alex, pero con un giro.

La adición al estilo Alex funciona así: tiene un 90% de posibilidades de devolver simplemente la suma de los dos números dados y un 10% de posibilidades de que Alex agregue recursivamente el primer número y el segundo número + 1. Esto significa que, potencialmente , una adición podría estar desactivada en 1 o más.

Desafío

Escriba un programa o función completa que tome dos enteros y Alex los agrega como se define. Puede suponer que su programa no se apilará si su idioma no tiene una recursión de cola. (Tenga en cuenta que no tiene que implementarlo de forma recursiva, siempre que las probabilidades sean las mismas).

Implementación de referencia (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;
  }
}

Prueba este violín en línea.

Tabla de clasificación

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

Pruébalo en línea

Utiliza el segundo modo de Pyth en reducción, que busca entradas repetidas y luego sale.

Explicación

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 se produce el complemento adicional de alex, se ejecutará nuevamente, pero si no, se cerrará.

Python 2, 55 bytes

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

Esta es una forma absolutamente extraña de hacerlo.

La función randomda un flotante en [0,1), y su representación de cadena por defecto tiene 16 dígitos después del punto decimal, para un total de 18 caracteres. Pero, debido a que se omiten los ceros finales, puede ser más corto. Leyendo dígitos desde el final, cada uno tiene una probabilidad de 1/10 de ser 0, y nos detenemos cuando tocamos un dígito distinto de cero. Entonces, el número de ceros al final se distribuye de la misma manera que el número de recursiones que hace Alex, por lo que podemos tomar muestras de esta distribución en 18 menos la longitud de la cadena.

En realidad, Python mostrará más de 18 dígitos para números pequeños, a veces incluso notación científica, por lo que agregamos 1 para solucionar esto.

Esto nunca dará más de 15 más que la suma, pero está bien porque 10 ^ 15 es mucho menos que la posibilidad de que un rayo cósmico interrumpa el cálculo .

R, 60 47 28 bytes

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

Este es un objeto de función sin nombre que acepta dos números y devuelve un número. No usa recursividad.

Como xnor señaló en un comentario, este problema se puede ver simplemente agregando dos números más una variable aleatoria geométrica con probabilidad de falla 1/10.

¿Por qué es eso cierto? Piénselo en términos de recursividad, como se describe en la publicación. En cada iteración tenemos un 10% de posibilidades de sumar 1 y recurrir, y un 90% de posibilidades de salir de la función sin más adiciones. Cada iteración es su propio ensayo independiente de Bernoulli con resultados "agregar 1, recurse" (falla) y "salir" (éxito). Por lo tanto, la probabilidad de falla es 1/10 y la probabilidad de éxito es 9/10.

Cuando se trata de una serie de ensayos independientes de Bernoulli, el número de ensayos necesarios para obtener un único éxito sigue una distribución geométrica . En nuestro caso, cada recursión significa sumar 1, así que cuando finalmente salimos de la función, esencialmente hemos contado la cantidad de fallas que ocurrieron antes del primer éxito. Eso significa que la cantidad por la cual el resultado estará apagado es una variante aleatoria de una distribución geométrica.

Aquí podemos aprovechar el amplio conjunto de aplicaciones y uso de distribución de probabilidad de R rgeom, que devuelve un valor aleatorio de una distribución geométrica.

Sin golf:

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

Minkolang 0.14 , 19 11 12 bytes

Esta es la versión de "función"; asume ay bya está en la pila, los saca y empuja la versión modificada de a+b. El equivalente más cercano a las funciones en Minkolang es utilizar F, que se dispara b, ay salta a (a,b)la CODEBOX. Luego, cuando el contador del programa golpea un f, salta de nuevo a donde Fse utilizó.

(+$01$h`d)xf

Esta es la versión completa del programa, 15 bytes . ( nntoma dos números de entrada y da N.salida al resultado y se detiene).

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

Robé el algoritmo de la respuesta de Doorknob ; el ciclo while se repite siempre que el número aleatorio generado sea menor que 0.1, agregando 1 cada vez. Pruébelo aquí (versión completa del programa) y ejecútelo 100 veces aquí .

Explicación

(              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 parte más inteligente aquí es d. La parte superior de la pila en ese momento será 0 o 1. Si es 0, el ciclo while sale. De lo contrario, continúa. Al duplicar la parte superior de la pila, será [a+b,1]la segunda vez a través del ciclo, por lo que +al principio agrega el 1 (y lo mismo para los viajes posteriores).

CJam, 12 11 bytes

{{+Amr!}h;}

¡Gracias a @ MartinBütter por guardar un byte con este truco súper 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.

Vieja respuesta:

{+({)Amr!}g}

Pruébalo en línea .

Explicación:

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

El algoritmo básico es "while (0.1 chance), increment the number", lo que elimina la necesidad de recurrencia.

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 es solo el método de bucle, agregue las entradas (ingresadas como [a b]) y luego continúe agregando una mientras un número aleatorio uniforme entre 0 y 1 es menor que 0.1. Descripción completa a continuación:

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    

Despegó 1 byte cambiando la especificación de entrada (de ii+a is).

La forma antigua se basaba en tomar el registro de base 10 de un número aleatorio entre 0 y 1 para calcular la cantidad a agregar a+b, sin embargo, solo funcionaría hasta 15 repeticiones debido a la precisión del punto flotante.

iir10,2$YlZo-+

En este código, 10,2$YlZo-hace el logaritmo en base 10 del número aleatorio y se redondea al entero más cercano.

Binario-codificado Golfical , 32 29 + 1 ( -xbandera) = 30 bytes

Hexdump (editado manualmente para corregir un error en la parte de imagen a binaria del transpiler, que desde entonces se ha solucionado):

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

Esta codificación se puede volver a convertir en la representación gráfica original usando la utilidad Encoder incluida, o ejecutarla directamente usando la -xbandera.

Imagen original:

Magnificado 50x:

Explicación: La fila superior es el bloque principal. Lee un número, lo copia a la derecha, lee otro número, los agrega, copia el resultado a la derecha, hace algunas cosas RNG y, con una probabilidad del 90%, imprime el resultado de la suma. El resto del tiempo, se envía a la fila inferior, donde coloca un uno en la primera celda y vuelve a la fila principal justo antes de la instrucción de adición (usando un giro al norte y luego al este).

Python, 66 65 64 63 bytes

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

Pruébalo en línea

Gracias a Sherlock9 por las correcciones y el byte guardado.

Gracias a Mathias Ettinger por otro byte.

Gracias a mbomb007 por un byte.

Julia, 30 bytes

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

Esta es una función recursiva fque acepta dos números y devuelve un número del mismo tipo. Debería funcionar bien para cualquier tipo numérico.

Primero verificamos si un flotante aleatorio entre 0 y 1 es mayor que 0.9. Si es así, recurrimos con un poco de algo extra, de lo contrario solo agregamos.

TI-BASIC, 15 bytes

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

Esto toma la entrada como una lista de dos elementos de Ans. Si bien un número aleatorio es menor que 0.1, hace una adición vectorizada 0.5en la lista. Aumentar cada elemento 0.5aumenta la suma en 1. Creo que esta es la solución TI-BASIC más corta.

El programa de 9 bytes sum(Ans)-int(log(10randno funciona, porque randsolo tiene 14 dígitos de precisión y, por lo tanto, no puede dar un número menor que ^10-14 .

APL, 17 bytes

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

Esta es una función diádica sin nombre.

Sin golf:

{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 bytes

KsQW!OT=hK;K

Mi primer verdadero Pyth golf!

Toma entrada en STDIN en el formato a,b.

Explicación:

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

¡Gracias a @FryAmTheEggman por eliminar dos caracteres al darme una forma más corta de incrementar una variable!

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.

Pruébalo en línea!

_{Tenga en cuenta que esto tiene una pequeña posibilidad de un error de desbordamiento de pila. Estamos hablando de (.1)^400oportunidad. También sale por error debido a cómo causé la recursión.}

Lisp, 58 bytes

¡La primera vez que escribo Lisp!

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

Puede usar esta adición especial exactamente como normalmente agregaría en Lisp:

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

Me encantaría escuchar sugerencias ya que soy nuevo en el idioma.

En serio, 10 bytes

,Σ1±╤_G_\+

Este programa genera una variable aleatoria a partir de una distribución geométrica transformando una distribución uniforme. Toma la entrada como una lista: [2,3](llaves opcionales). Pruébalo en línea .

Explicación:

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

Dada una variable aleatoria X ~ Uniform(0, 1), se puede transformar en una variable aleatoria Y ~ Geometric(p)con la fórmula Y = floor(log(X)/log(p)).

Mathematica, 32 bytes

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

Explicación:

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

Tenga en cuenta que esta función funciona para cualquier cantidad de entradas.

TeaScript , 18 bytes 21

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

Esta es una función TeaScript. Asignarlo a una variable o simplemente ejecutarlo directamente.

Pruébalo en línea

Candy , 11 bytes

+#10H{.}10g

La forma larga es:

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

Primer código de golf, hecho en C ... No creo que vaya a vencer a nada, y puede ser mucho menos.

EDIT 3: recortó 2 bytes gracias a @Mego, escribiendo .1 en lugar de 0.1 y reescribiendo el operador ternario

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

EDIT 2: recortado 12 bytes, después de gnu99, cada variable es un int si no se indica lo contrario. Lo mismo ocurre con el tipo de función de retorno

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

EDITAR: recortó 20 bytes, olvidé que .h básico no es necesario en C99 (usando gcc por ejemplo). Producirá una advertencia :)

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

Solución de 71 bytes:

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

Si desea ver muchos resultados, puede usar el siguiente 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

La entrada es de la forma [3 4], es decir, un vector de fila con los dos números.

Ejemplo

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

Explicación

Esto genera la variable aleatoria geométrica sin bucles, aplicando directamente una transformación a una variable aleatoria uniforme. Tenga en cuenta que se utiliza log _0.1 a en lugar de log a / log 0.1 para guardar 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

Traté de hacer una respuesta Microscript II, pero por alguna razón no pude hacer que el ciclo de suma funcionara correctamente :(

Mouse-2002 , 41 39 38 bytes

Sin recursión

&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

O, si eres un fanático de la programación funcional, y la recursión es tu oferta, entonces 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 (no competitiva)

‘⁵XỊ¤¿+

Pruébalo en línea!

Cómo 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

Básicamente lo mismo que la solución Pyth de FryAmTheEggman . -1 gracias a Erik the Outgolfer.

Función de infijo tácito anónimo.

{⍵+1=?10}⍣=+

Pruébalo en línea!

+ agrega los argumentos

{... }⍣= aplique la siguiente función hasta que dos aplicaciones sucesivas tengan el mismo resultado:

 ?10 entero aleatorio en el rango 1–10

 1= es uno igual a eso? (es decir, ¹ / ₁₀ ^º oportunidad)

 ⍵+ agregue el argumento a eso

Perl 6 , 26 bytes

Realmente haciéndolo recursivamente:

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

Cree una secuencia de 1s posiblemente vacía seguida de los argumentos, luego sume todos juntos.

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

(en realidad puede tomar cualquier cantidad de argumentos)

uso:

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

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

Pyth, 11 bytes

+sQ-18l`hO0

Un puerto Pyth directo de mi respuesta 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)

Octava, 20 bytes

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

Suma de las entradas, más una muestra aleatoria de la distribución geométrica con parámetro 0.9.

En serio, 13 bytes

,,1W+9uJYWDkΣ

Utiliza una estrategia similar a la respuesta CJam de Doorknob (el número de incremento mientras el flotante aleatorio es menor que 0.1), excepto que usa números enteros e incrementa mientras que el entero aleatorio [0,9]es menor que 1. La falta de recursión fácil duele.

Pruébelo en línea (necesita entrada manual)

Explicación:

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

El ciclo while deja la pila de esta manera:

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

El cambio npor 1 es necesaria para obtener el bucle while a plazo, ya que 0es Falsey-. Se trata fácilmente disminuyendo ndespués del ciclo while, por lo que el resultado final es a + b + (n - 1).

MATLAB, 51 bytes

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

El resultado se encuentra en la variable automática 'ans'