Addition à la Alex

57

Inspirés par le glorieux Alex. Apprenez-nous un R de façon géniale, nous allons recréer humblement le "programme One True R" d'Alex, mais avec une touche différente.

Alex-style Addition fonctionne comme ceci: il a 90% de chance de simplement renvoyer la somme des deux nombres donnés et 10% de chance de faire récursivement Alex, en ajoutant le premier nombre et le second nombre + 1. Cela signifie que potentiellement , un ajout peut être désactivé de 1 ou plus.

Défi

Ecrivez un programme complet ou une fonction qui prend deux entiers et Alex les ajoute tels que définis. Vous pouvez supposer que votre programme n'empilera pas le débordement si votre langue n'a pas de récursion de la queue. (Notez que vous n'avez pas à l'implémenter de manière récursive, tant que les probabilités sont les mêmes.)

Implémentation de référence (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;
  }
}

Essayez ce violon en ligne.

Classement

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>

un spaghetto
la source
6
Donc, cela donne la somme de deux nombres plus une variable géométrique aléatoire avec une probabilité d’échec de 1/10?
xnor
@xnor Essentiellement, oui. Je l'ai défini de manière récursive pour qu'il soit plus facile à comprendre, mais vous n'avez pas à le faire de manière récursive (la solution CJam ne le fait pas, par exemple)
un spaghetto
10
Pourquoi ce bac à sable a été utilisé pendant 20 minutes? Cela semble manquer le but du bac à sable.
Peter Taylor
3
@PeterTaylor Le problème mineur avec ce problème a été résolu presque immédiatement et la question était si simple que je ne pensais pas qu'il était nécessaire de rester dans le bac à sable aussi longtemps (il avait déjà été examiné par 10 personnes, ce qui me semblait suffisant. examen pour un défi aussi simple). La raison principale pour laquelle je l'avais dans le bac à sable était de voir si les gens pensaient que c'était trop simple.
un spaghetto
2
Je dirais qu’il ya toujours un problème majeur, en ce qu’il n’est pas clair si vous insistez pour que les implémentations soient écrites comme des fonctions récursives ou pour donner simplement la bonne distribution, mais il est beaucoup trop tard pour faire quoi que ce soit.
Peter Taylor

Réponses:

40

Pyth, 8

u+G!OTsQ

Essayez-le en ligne

Cela utilise le second mode de Pyth sur réduire, qui recherche les entrées répétées puis se termine.

Explication

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 l'alex-add supplémentaire se produit, il sera exécuté à nouveau, mais sinon, il se fermera.

FryAmTheEggman
la source
13
Ceci ... est de la pure magie noire. O_o
Doorknob
1
C'est ridicule.
chat
36

Python 2, 55 octets

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

C'est une manière absolument bizarre de le faire.

La fonction randomdonne un float dans [0,1) et sa représentation sous forme de chaîne comporte par défaut 16 chiffres après le point décimal, pour un total de 18 caractères. Mais, étant donné que les derniers 0 sont omis, il pourrait être plus court. En lisant les chiffres à partir de la fin, chacun a 1/10 de chance d’être 0 et nous nous arrêtons lorsque nous atteignons un chiffre différent de zéro. Ainsi, le nombre de zéros à la fin est distribué comme le nombre de récursions effectuées par Alex. Nous pouvons ainsi échantillonner cette distribution de 18 moins la longueur de la chaîne.

En fait, Python affichera plus de 18 chiffres pour les petits nombres, parfois même en notation scientifique, nous ajoutons donc 1 pour résoudre ce problème.

Cela ne donnera jamais plus de 15% de plus que la somme, mais ce n'est pas grave, car 10 ^ 15 équivaut beaucoup moins que le risque qu'un rayon cosmique perturbe le calcul .

Xnor
la source
1
Désolé, cette réponse n’est pas valide car elle a 10% de chances de ne pas fonctionner correctement , ce qui est explicitement interdit par la méta-publication liée.
pppery
22

R, 60 47 28 octets

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

C'est un objet fonction non nommé qui accepte deux nombres et renvoie un nombre. Il n'utilise pas de récursivité.

Comme xnor l'a souligné dans un commentaire, ce problème peut être considéré comme une simple addition de deux nombres plus une variable aléatoire géométrique avec une probabilité d'échec de 1/10.

Pourquoi est-ce vrai? Pensez-y en termes de récursion, comme décrit dans le post. À chaque itération, nous avons 10% de chances d’ajouter 1 et de récurrent, et 90% de quitter la fonction sans autre ajout. Chaque itération est son propre essai indépendant de Bernoulli avec les résultats "add 1, recurse" (échec) et "sortie" (succès). Ainsi, la probabilité d'échec est de 1/10 et la probabilité de succès est de 9/10.

Lorsqu'il s'agit d'une série d'essais indépendants de Bernoulli, le nombre d'essais nécessaires pour obtenir un seul succès suit une distribution géométrique . Dans notre cas, chaque récursivité signifie l'ajout de 1; ainsi, lorsque nous quittons finalement la fonction, nous avons essentiellement compté le nombre d'échecs survenus avant le premier succès. Cela signifie que le résultat obtenu sera une variation aléatoire d'une distribution géométrique.

Ici, nous pouvons tirer parti de la vaste suite de solutions intégrées de distribution de probabilités et d'utilisation de R rgeomqui renvoie une valeur aléatoire à partir d'une distribution géométrique.

Ungolfed:

f <- function(a, b) {
    a + b + rgeom(n = 1, prob = 0.9)
}
Alex A.
la source
13

Minkolang 0.14 , 19 11 12 octets

Ceci est la version "function"; il assume aet best déjà sur la pile, les supprime et pousse la version modifiée de a+b. Le plus proche équivalent à des fonctions dans Minkolang est d'utiliser F, qui se soulève b, aet saute (a,b)dans le codebox. Ensuite, lorsque le compteur de programme frappe un f, il revient à l'endroit où il a Fété utilisé.

(+$01$h`d)xf

Ceci est la version complète du programme, 15 octets . ( nnprend deux nombres à partir de l’entrée et N.sort le résultat et s’arrête.)

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

J'ai volé l'algorithme de la réponse de Doorknob ; la boucle while se répète tant que le nombre aléatoire généré est inférieur à 0,1, en ajoutant 1 à chaque fois. Essayez-le ici (version complète du programme) et exécutez-le 100 fois ici .

Explication

(              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 partie la plus intelligente est ici d. Le haut de la pile à ce moment-là sera 0 ou 1. Si c'est 0, la boucle while se termine. Sinon, ça continue. Au fur et à mesure que je duplique le haut de la pile, ce sera [a+b,1]la deuxième fois dans la boucle. +Le début ajoute le 1 (et de même pour les voyages suivants).

El'endia Starman
la source
Est-ce vraiment une fonction? J'ai rapidement parcouru la documentation linguistique et je n'ai rien trouvé qui décrive les définitions de fonctions. Basé sur l'explication, cela ressemble plus à un fragment de code.
Reto Koradi
@RetoKoradi: Je peux mettre un tel "fragment de code" sur sa propre ligne, y aller avec 0kF (où k est un nombre) et revenir en arrière avec f à la fin. C'est ce qui se rapproche le plus d'une fonction dans Minkolang.
El'endia Starman
2
N’est-ce pas techniquement dire: «mon fragment de code CJam est une fonction; il vous suffit de l’entourer d’accolades». À tout le moins, vous devriez probablement inclure le dernier caractère fdans le nombre de caractères (et, techniquement, la nouvelle ligne précédente si vous vous sentez extra-pédant, mais je ne pense pas que ce soit nécessaire).
Poignée de porte
1
Si la langue n’a pas de fonctions, vous pouvez toujours poster des programmes complets. D'après ce que je comprends, quand on dit "fonction", il faut que ce soit une fonction nommée ou une fonction anonyme (qui est généralement une expression pouvant être affectée à une variable de fonction). Une fois, j’ai posté quelque chose de similaire dans CJam, et Martin m’a rapidement appelé, disant que c’était un fragment de code et non une fonction.
Reto Koradi
@RetoKoradi: D'accord, c'est compréhensible. Que pensez-vous de la suggestion de Doorknob?
El'endia Starman
12

CJam, 12 à 11 octets

{{+Amr!}h;}

Merci à @ MartinBütter d'avoir enregistré un octet grâce à cette astuce super intelligente!

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

Ancienne réponse:

{+({)Amr!}g}

Essayez-le en ligne .

Explication:

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

L'algorithme de base est "while (0.1 chance), incrémente le nombre", ce qui élimine le besoin de récursivité.

Poignée de porte
la source
8

Javascript ES6, 38 octets

f=(a,b)=>Math.random()<.1?f(a,b+1):a+b
SuperJedi224
la source
f=(a,b)=>new Date%10<1?f(a,b+1):a+bpour 35 octets
WallyWest
2
@WallyWest Malheureusement, la probabilité d'utilisation de l' Datehorodatage ne sera pas précise, car si elle est évaluée true, l'ajout se poursuit 1pendant la millième de seconde.
user81655
J'ai essayé la distribution géométrique f=(a,b)=>a+b-~~Math.log10(Math.random())mais c'est 2 octets de plus.
Neil
8

MATL , 14 13 12 octets

is`r.1<tb+w]

Ceci est juste la méthode de la boucle, ajoutez les entrées (entrées en tant que [a b]), puis continuez à en ajouter une tandis qu'un nombre aléatoire uniforme entre 0 et 1 est inférieur à 0,1. Description complète ci-dessous:

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    

Décollé de 1 octet en modifiant les spécifications d'entrée (de ii+à is).


L'ancienne méthode reposait sur l'utilisation du journal en base 10 d'un nombre aléatoire compris entre 0 et 1 pour calculer le montant à ajouter a+b, mais cela ne fonctionnerait que jusqu'à 15 répétitions en raison de la précision de la virgule flottante.

iir10,2$YlZo-+

Dans ce code, 10,2$YlZo-effectue le logarithme en base 10 du nombre aléatoire et arrondit à l'entier le plus proche.

David
la source
Commentaire juste, bien que j'aimerais voir votre génération 15 avec toute autre solution présentée: P Une autre façon, pour 15 octets, est la version en boucle simple ii+`10Yr1=tb+w]:, pas encore jouée au golf.
David
En fait, je peux raccourcir la boucle! Merci à ThomasKwa!
David
Très bien fait!
Luis Mendo
7

Codé binaire Golfical , 32 29 + 1 ( -xpavillon) = 30 octets

Hexdump (édité manuellement pour corriger un bogue dans la partie image vers binaire du transpiler, qui a été corrigé depuis):

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

Ce codage peut être reconverti dans la représentation graphique d'origine à l'aide de l'utilitaire Encoder inclus ou exécuté directement à l'aide de l' -xindicateur.

Image originale: entrez la description de l'image ici

Magnifié 50x:

entrez la description de l'image ici

Explication: La rangée supérieure correspond au bloc principal. Il lit un numéro, le copie à droite, en lit un autre, les ajoute, copie le résultat à droite, effectue des opérations de RNG et, avec une probabilité de 90%, imprime le résultat de l'addition. Le reste du temps, il est envoyé à la ligne inférieure, où il en insère un dans la première cellule et revient à la ligne principale juste avant l'instruction d'addition (en utilisant un virage nord puis un virage est).

SuperJedi224
la source
2
Pouvez-vous ajouter une explication? C'est super cool.
Chat
7

Python, 66 65 64 63 octets

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

Essayez-le en ligne

Merci à Sherlock9 pour les corrections et l'octet enregistré.

Merci à Mathias Ettinger pour un autre octet.

Merci à mbomb007 pour un octet.

Mego
la source
62?
ASCII seulement
@ ASCII-only L'utilisation .9>random()n'est pas tout à fait 9 sur 10, à cause de la répartition inégale des flotteurs
Mego
6

Julia, 30 octets

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

C'est une fonction récursive fqui accepte deux nombres et retourne un nombre du même type. Cela devrait fonctionner correctement pour tout type numérique.

Nous vérifions d’abord si un flottant aléatoire entre 0 et 1 est supérieur à 0,9. Si tel est le cas, nous ajoutons un petit quelque chose en plus, sinon nous ajoutons.

Alex A.
la source
6

TI-BASIC, 15 octets

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

Cela prend l'entrée sous forme de liste à deux éléments Ans. Bien qu'un nombre aléatoire soit inférieur à 0.1, il est ajouté à 0.5la liste vectorisé . L'augmentation de chaque élément 0.5augmente la somme de 1. Je pense que c'est la solution TI-BASIC la plus courte.

Le programme de 9 octets sum(Ans)-int(log(10randne fonctionne pas, car randil n'a que 14 chiffres de précision et ne peut donc pas donner un nombre inférieur à 10 -14 .

lirtosiast
la source
1
Il est à noter que pour qu’il ajoute 14, vous devrez également regarder les cochons voler et l’enfer geler. Et au moment où vous ajoutez 14, j'aurai fait quelque chose de ma vie.
Nic Hartley
5

APL, 17 octets

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

C'est une fonction dyadique sans nom.

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.
la source
5

Pyth, 14 12 octets

KsQW!OT=hK;K

Mon premier vrai golf Pyth!

Prend l'entrée sur STDIN dans le format a,b.

Explication:

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

Merci à @FryAmTheEggman pour avoir rasé deux caractères en me donnant un moyen plus rapide d’incrémenter une variable!

Poignée de porte
la source
5

Vitsy , 12 à 10 octets

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.

Essayez-le en ligne!

Notez que cela a un risque infime d’erreur de débordement de pile. Nous parlons (.1)^400chance. Il se termine également par erreur en raison de la façon dont j'ai provoqué la récursivité.

Addison Crump
la source
4

Lisp, 58 octets

Ma première fois en écrivant Lisp!

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

Vous pouvez utiliser cet ajout spécial exactement comme vous le feriez habituellement avec Lisp:

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

J'aimerais entendre des suggestions car je suis nouveau dans la langue.

sudo rm -rf slash
la source
Serait (- a(- -1 b))travailler? Vous sauve 2 octets si c'est le cas.
Neil
@ Neil, je ne pense pas que cela fonctionne car la fonction doit être récursive
sudo rm -rf slash
Merci d’avoir expliqué pourquoi cette expression semble si encombrante.
Neil
4

Sérieusement, 10 octets

,Σ1±╤_G_\+

Ce programme génère une variable aléatoire à partir d'une distribution géométrique en transformant une distribution uniforme. Il prend les entrées sous forme de liste: [2,3](accolades facultatives). Essayez-le en ligne .

Explication:

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

Étant donné une variable aléatoire X ~ Uniform(0, 1), il peut être transformé en une variable aléatoire Y ~ Geometric(p)avec la formule Y = floor(log(X)/log(p)).

Mego
la source
3

Mathematica, 32 octets

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

Explication:

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

Notez que cette fonction fonctionne pour n’importe quel nombre d’entrées.

LegionMammal978
la source
3

TeaScript , 18 octets 21

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

Ceci est une fonction TeaScript. Attribuez-le à une variable ou exécutez-le directement.

Essayez-le en ligne

Downgoat
la source
3

Candy , 11 octets

+#10H{.}10g

La forme longue est:

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
la source
3

C, 71 51 39 37 octets

Premier code-golf, fait en C ... Je ne pense pas que ça battra quoi que ce soit, et peut être beaucoup joué au golf

EDIT 3: coupé 2 octets grâce à @Mego, en écrivant .1 au lieu de 0.1 et en réécrivant l'opérateur ternaire

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

EDIT 2: 12 octets coupés, après gnu99, chaque variable est un entier si ce n’est pas indiqué autrement. Il en va de même pour le type de fonction de retour

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

EDIT: coupé 20 octets, oublié que les bases .h ne sont pas nécessaires en C99 (en utilisant gcc par exemple). Cela produira un avertissement :)

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

Solution de 71 octets:

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

Si vous voulez voir beaucoup de résultats, vous pouvez utiliser le code suivant

#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
la source
3

MATL , 12 13 14 octets

r.1H$YlY[ihs

La saisie est de la forme [3 4], c’est-à-dire un vecteur ligne avec les deux nombres.

Exemple

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

Explication

Cela génère la variable aléatoire géométrique sans boucle, en appliquant directement une transformation à une variable aléatoire uniforme. Notez que log 0.1 a est utilisé à la place de log a / log 0.1 pour enregistrer 1 octet.

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
la source
3

Microscript , 29 à 21 octets

isi+vzr10!{l1vzr10!}l

J'ai essayé de répondre à Microscript II mais, pour une raison quelconque, la boucle d'addition ne fonctionnait pas correctement :(

SuperJedi224
la source
3

Mouse-2002 , 41 39 38 octets

Pas de récursion.

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

A expliqué:

&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, si vous êtes un fan de programmation fonctionnel, et que la récursivité est votre affaire, alors 57 octets :

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

A expliqué:

&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
chat
la source
3

Gelée , 7 octets (non concurrente)

‘⁵XỊ¤¿+

Essayez-le en ligne!

Comment ça fonctionne

‘⁵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
la source
3

APL (Dyalog Unicode) , 13 SBCS de 12 octets

Fondamentalement identique à la solution Pyth de FryAmTheEggman . -1 merci à Erik l'Outgolfer.

Fonction infixe tacite anonyme.

{⍵+1=?10}⍣=+

Essayez-le en ligne!

+ ajouter les arguments

{}⍣= Applique la fonction suivante jusqu'à ce que deux applications successives donnent le même résultat:

?10 nombre entier aléatoire compris entre 1 et 10

1= est-ce qu'on est égal à ça? (ie 110 ème chance)

⍵+ ajouter l'argument à cela

Adam
la source
Vous pouvez prendre deux entiers comme deux arguments et supprimer le /.
Erik the Outgolfer
@EriktheOutgolfer Ouais.
Adám
2

Perl 6 , 26 octets

En train de le faire récursivement:

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

Créez une séquence de 1s éventuellement vide suivie des arguments, puis additionnez-les.

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

(il peut en réalité prendre n'importe quel nombre d'arguments)

usage:

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

say f 1,2; # one of 3,4,5 ... *
Brad Gilbert b2gills
la source
23 octets
bb94 le
2

Pyth, 11 octets

+sQ-18l`hO0

Un port Pyth direct de ma réponse 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
la source
2

Octave, 20 octets

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

Somme des entrées, plus un échantillon aléatoire de la distribution géométrique avec paramètre 0.9.

Alephalpha
la source
2

Sérieusement, 13 octets

,,1W+9uJYWDkΣ

Utilise une stratégie similaire à la réponse CJam de Doorknob (numéro d’incrément lorsque float aléatoire est inférieur à 0,1), sauf qu’il utilise des entiers et s’incrémente tandis que nombre entier aléatoire [0,9]est inférieur à 1. Le manque de récursion facile fait mal.

Essayez-le en ligne (nécessite une saisie manuelle)

Explication:

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

La boucle while laisse la pile comme ceci:

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

Déplacer nvers le haut de 1 est nécessaire pour obtenir la boucle while à exécuter, car 0est falsey. Il est facile à gérer en décrémentant naprès la boucle while, le résultat final est donc a + b + (n - 1).

Mego
la source
2

MATLAB, 51 octets

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

Le résultat est trouvé dans la variable automatique 'ans'

costrom
la source