Ispirato dal glorioso Alex, Impararti una R per l'ottimo bene, ricreamo umilmente "l'unico vero programma R" di Alex, ma con una svolta.

L'aggiunta in stile Alex funziona in questo modo: ha una probabilità del 90% di restituire semplicemente la somma dei due numeri indicati e una probabilità del 10% di aggiungere ricorsivamente Alex aggiungendo il primo numero e il secondo numero + 1. Ciò significa che, potenzialmente , un'aggiunta potrebbe essere disattivata di 1 o più.

Sfida

Scrivi un programma o una funzione completa che richiede due numeri interi e Alex li aggiunge come definito. Puoi presumere che il tuo programma non impilerà overflow se la tua lingua non ha ricorsività della coda. (Si noti che non è necessario implementarlo in modo ricorsivo, purché le probabilità siano le stesse.)

Implementazione di riferimento (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;
  }
}

Prova questo violino online.

Classifica

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

Provalo online

Questo utilizza la seconda modalità di Pyth per ridurre, che cerca input ripetuti e poi esce.

Spiegazione

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 si verifica l'aggiunta di alex-add, verrà eseguita di nuovo, ma in caso contrario verrà chiusa.

Python 2, 55 byte

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

Questo è un modo assolutamente bizzarro per farlo.

La funzione randomfornisce un float in [0,1) e la sua rappresentazione di stringa di default ha 16 cifre dopo il punto decimale, per un totale di 18 caratteri. Tuttavia, poiché gli 0 finali sono omessi, potrebbe essere più breve. Leggendo le cifre dalla fine, ognuna ha una probabilità 1/10 di essere 0 e ci fermiamo quando colpiamo una cifra diversa da zero. Quindi il numero di zero finali è distribuito esattamente come il numero di ricorsioni che Alex fa, quindi possiamo campionare da questa distribuzione di 18 meno la lunghezza della stringa.

In realtà, Python mostrerà più di 18 cifre per piccoli numeri, a volte anche notazione scientifica, quindi aggiungiamo 1 per risolvere questo problema.

Questo non darà mai più di 15 in più della somma, ma va bene perché 10 ^ 15 è molto inferiore alla possibilità che un raggio cosmico interrompa il calcolo .

R, 60 47 28 byte

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

Questo è un oggetto funzione senza nome che accetta due numeri e restituisce un numero. Non utilizza la ricorsione.

Come ha sottolineato xnor in un commento, questo problema può essere visto semplicemente aggiungendo due numeri più una variabile casuale geometrica con probabilità di fallimento 1/10.

Perché è vero? Pensaci in termini di ricorsione, come è descritto nel post. In ogni iterazione abbiamo una probabilità del 10% di aggiungere 1 e ricorrere, e una probabilità del 90% di uscire dalla funzione senza ulteriore aggiunta. Ogni iterazione è il proprio processo indipendente di Bernoulli con esiti "aggiungi 1, recurse" (fallimento) e "exit" (successo). Quindi la probabilità di fallimento è 1/10 e la probabilità di successo è 9/10.

Quando si tratta di una serie di prove indipendenti di Bernoulli, il numero di prove necessarie per ottenere un singolo successo segue una distribuzione geometrica . Nel nostro caso, ogni ricorsione significa aggiungere 1, quindi quando finalmente abbandoniamo la funzione, abbiamo essenzialmente contato il numero di guasti verificatisi prima del primo successo. Ciò significa che la quantità da cui il risultato sarà disattivato è una variabile casuale da una distribuzione geometrica.

Qui possiamo trarre vantaggio dalla vasta suite di R di built-in e utilizzo della distribuzione di probabilità rgeom, che restituisce un valore casuale da una distribuzione geometrica.

Ungolfed:

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

Minkolang 0,14 , 19 11 12 byte

Questa è la versione "funzione"; presuppone ae bsono già in pila, le espelle e spinge la versione modificata di a+b. L'equivalente più di funzioni in Minkolang è utilizzare F, che appare spento b, ae salta (a,b)in codebox. Quindi, quando il contatore del programma colpisce an f, torna al punto in cui è Fstato utilizzato.

(+$01$h`d)xf

Questa è la versione completa del programma, 15 byte . ( nnprende due numeri dall'input e N.genera il risultato e si ferma.)

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

Ho rubato l'algoritmo dalla risposta di Doorknob ; il ciclo while si ripete finché il numero casuale generato è inferiore a 0,1, aggiungendo 1 ogni volta. Provalo qui (versione completa del programma) ed eseguilo 100 volte qui .

Spiegazione

(              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 più intelligente qui è d. Il massimo dello stack in quel momento sarà 0 o 1. Se è 0, il ciclo while termina. Altrimenti, continua. Mentre duplico la parte superiore dello stack, sarà [a+b,1]la seconda volta attraverso il ciclo, quindi +all'inizio aggiunge l'1 (e allo stesso modo per i viaggi successivi).

CJam, 12 11 byte

{{+Amr!}h;}

Grazie a @ MartinBütter per aver salvato un byte con questo trucco 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.

Vecchia risposta:

{+({)Amr!}g}

Provalo online .

Spiegazione:

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

L'algoritmo di base è "while (0.1 chance), incrementa il numero", il che elimina la necessità della ricorsione.

Javascript ES6, 38 byte

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

MATL , 14 13 12 byte

is`r.1<tb+w]

Questo è solo il metodo loop, aggiungi gli input (immessi come [a b]) quindi continua ad aggiungerne uno mentre un numero casuale uniforme compreso tra 0 e 1 è inferiore a 0,1. Descrizione completa di seguito:

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    

Si è spento 1 byte modificando le specifiche di input (da ii+a is).

Il vecchio metodo si basava sul prendere il registro base-10 di un numero casuale compreso tra 0 e 1 per calcolare la quantità da aggiungere a+b, tuttavia avrebbe funzionato solo fino a 15 ripetizioni a causa della precisione in virgola mobile.

iir10,2$YlZo-+

In questo codice, 10,2$YlZo-esegue il logaritmo in base 10 del numero casuale e arrotonda per eccesso al numero intero più vicino.

Binario con codifica golfica , 32 29 + 1 ( -xbandiera) = 30 byte

Hexdump (modificato manualmente per correggere un bug nella parte immagine-binaria del transpiler, che da allora è stato corretto):

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

Questa codifica può essere riconvertita nella rappresentazione grafica originale utilizzando l'utilità Encoder inclusa oppure eseguirla direttamente utilizzando il -xflag.

Immagine originale:

Ingrandito 50x:

Spiegazione: La riga superiore è il blocco principale. Legge un numero, lo copia a destra, legge un altro numero, li aggiunge, copia il risultato a destra, esegue alcune operazioni RNG e, con una probabilità del 90%, stampa il risultato dell'aggiunta. Il resto del tempo, viene inviato alla riga inferiore, dove inserisce uno nella prima cella e torna alla riga principale appena prima dell'istruzione di aggiunta (utilizzando una svolta a nord e una a est).

Python, 66 65 64 63 byte

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

Provalo online

Grazie a Sherlock9 per le correzioni e il byte salvato.

Grazie a Mathias Ettinger per un altro byte.

Grazie a mbomb007 per un byte.

Julia, 30 byte

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

Questa è una funzione ricorsiva fche accetta due numeri e restituisce un numero dello stesso tipo. Dovrebbe funzionare bene per qualsiasi tipo numerico.

Per prima cosa controlliamo se un float casuale tra 0 e 1 è maggiore di 0,9. In tal caso, ricerchiamo con qualcosa in più "qualcosa", altrimenti aggiungiamo semplicemente.

TI-BASIC, 15 byte

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

Questo prende l'input come un elenco di due elementi da Ans. Mentre un numero casuale è inferiore a 0.1, fa un'aggiunta vettoriale 0.5nell'elenco. Aumentando ogni elemento 0.5aumentando la somma di 1. Credo che questa sia la soluzione TI-BASIC più breve.

Il programma a 9 byte sum(Ans)-int(log(10randnon funziona, perché randha solo 14 cifre di precisione e quindi non può fornire un numero inferiore a 10 ^-14 .

APL, 17 byte

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

Questa è una funzione diadica senza 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

Pyth, 14 12 byte

KsQW!OT=hK;K

Il mio primo vero golf Pyth!

Accetta input su STDIN nel formato a,b.

Spiegazione:

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

Grazie a @FryAmTheEggman per aver rasato due caratteri dandomi un modo più breve per incrementare una variabile!

Vitsy , 12 10 byte

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.

Provalo online!

_{Si noti che ciò ha una piccola possibilità di errore di overflow dello stack. Stiamo parlando di (.1)^400possibilità. Esce anche in caso di errore a causa di come ho causato la ricorsione.}

Lisp, 58 byte

La mia prima volta a scrivere Lisp!

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

Puoi usare questa aggiunta speciale esattamente come in Lisp:

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

Mi piacerebbe ricevere suggerimenti dato che sono nuovo di zecca per la lingua.

Scherzi a parte, 10 byte

,Σ1±╤_G_\+

Questo programma genera una variabile casuale da una distribuzione geometrica trasformando una distribuzione uniforme. Prende l'input come un elenco: [2,3](parentesi graffe facoltative). Provalo online .

Spiegazione:

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

Data una variabile casuale X ~ Uniform(0, 1), può essere trasformata in una variabile casuale Y ~ Geometric(p)con la formula Y = floor(log(X)/log(p)).

Mathematica, 32 byte

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

Spiegazione:

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

Questa funzione è disponibile per qualsiasi numero di ingressi.

TeaScript , 18 byte 21

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

Questa è una funzione TeaScript. Assegnalo a una variabile o eseguilo direttamente.

Provalo online

Candy , 11 byte

+#10H{.}10g

La forma lunga è:

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 byte

Primo golf di codice, fatto in C ... Non penso che batterà nulla e potrebbe essere molto scartato

EDIT 3: tagliato 2 byte grazie a @Mego, scrivendo .1 invece di 0.1 e riscrivendo l'operatore ternario

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

EDIT 2: tagliato 12 byte, seguendo gnu99, ogni variabile è un int se non diversamente indicato. Lo stesso vale per il tipo di funzione di ritorno

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

EDIT: tagliato 20 byte, dimenticato che .h di base non sono necessari in C99 (usando gcc per esempio). Produrrà un avviso :)

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

Soluzione di 71 byte:

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

Se vuoi vedere un sacco di output, puoi usare il seguente codice

#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 byte

r.1H$YlY[ihs

L'input ha la forma [3 4], ovvero un vettore di riga con i due numeri.

Esempio

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

Spiegazione

Questo genera la variabile casuale geometrica senza loop, applicando direttamente una trasformazione a una variabile casuale uniforme. Si noti che viene utilizzato il registro _0.1 a anziché il registro a / log 0.1 per salvare 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 byte

isi+vzr10!{l1vzr10!}l

Ho provato a dare una risposta a Microscript II ma per qualche motivo non sono riuscito a far funzionare correttamente il ciclo di addizione :(

Mouse-2002 , 41 39 38 byte

Nessuna ricorsione.

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

Ha spiegato:

&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

Oppure, se sei un fanatico della programmazione funzionale e la ricorsione è il tuo affare, allora 57 byte :

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

Ha spiegato:

&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 byte (non competitiva)

‘⁵XỊ¤¿+

Provalo online!

Come funziona

‘⁵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 byte ^SBCS

Praticamente lo stesso della soluzione Pyth di FryAmTheEggman . -1 grazie a Erik the Outgolfer.

Funzione anonimo di tacita infissione.

{⍵+1=?10}⍣=+

Provalo online!

+ aggiungi gli argomenti

{... }⍣= applica la seguente funzione fino a quando due applicazioni successive hanno lo stesso risultato:

 ?10 numero intero casuale nell'intervallo 1–10

 1= è uguale a quello? (ovvero ¹ ⁄ ₁₀ ^° possibilità)

 ⍵+ aggiungere l'argomento a questo

Perl 6 , 26 byte

Effettivamente facendo in modo ricorsivo:

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

Crea una sequenza forse vuota di 1s seguita dagli argomenti, quindi sommali tutti insieme.

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

(può effettivamente accettare qualsiasi numero di argomenti)

utilizzo:

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

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

Pyth, 11 byte

+sQ-18l`hO0

Una porta Pyth diretta della mia risposta 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)

Ottava, 20 byte

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

Somma degli input, oltre a un campione casuale dalla distribuzione geometrica con parametro 0.9.

Scherzi a parte, 13 byte

,,1W+9uJYWDkΣ

Utilizza una strategia simile alla risposta CJam di Doorknob (numero di incremento mentre il float casuale è inferiore a 0,1), tranne per il fatto che utilizza numeri interi e incrementi mentre il numero intero casuale in [0,9]è inferiore a 1. La mancanza di ricorsione facile fa male.

Provalo online (necessita di input manuale)

Spiegazione:

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

Il ciclo while lascia lo stack in questo modo:

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

Lo spostamento ndi 1 è necessario per far funzionare il ciclo while, poiché 0è falso. È facilmente gestibile diminuendo ndopo il ciclo while, quindi il risultato finale è a + b + (n - 1).

MATLAB, 51 byte

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

Il risultato si trova nella variabile automatica 'ans'