Натхненні славною Алексою " Learn you a R for great good", ми будемо смиренно відтворити Алекс "одну справжню програму R", але з поворотом.

Додаток у стилі Алекса працює так: він має 90% шанс просто повернути суму двох заданих чисел та 10% шанс рекурсивно Алекс додати перше число та друге число + 1. Це означає, що потенційно , додаток може бути вимкнено на 1 або більше.

Виклик

Напишіть повну програму або функцію, яка займає два цілих числа, і Алекс додає їх як визначено. Ви можете припустити, що ваша програма не буде переповнювати стеки, якщо у вашій мові немає хвостової рекурсії. (Зверніть увагу, що вам не доведеться реалізовувати це рекурсивно, доки ймовірності однакові.)

Реалізація довідника (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;
  }
}

Спробуйте цю загадку онлайн.

Таблиця лідерів

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>

Піта, 8

u+G!OTsQ

Спробуйте в Інтернеті

При цьому використовується другий режим Pyth щодо зменшення, який шукає повторне введення, а потім виходить.

Пояснення

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

Якщо виникне додаткове додавання alex-add, воно запуститься знову, але якщо ні, то воно вийде.

Python 2, 55 байт

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

Це абсолютно химерний спосіб зробити це.

Функція randomдає поплавок у [0,1), а її рядкове подання за замовчуванням має 16 цифр після десяткової крапки, на 18 символів. Але оскільки опущення 0-х опущено, воно може бути коротшим. Читаючи цифри з кінця, кожна з них має шанс 1/10 бути 0, і ми зупиняємось, коли потрапляємо на ненулеву цифру. Тож кількість нульових кінцевих нулів розподіляється так само, як і кількість рекурсій, які робить Алекс, тож ми можемо вибірки з цього розподілу на 18 мінус довжину рядка.

Власне, Python відображатиме більше 18 цифр для невеликих чисел, іноді навіть наукові позначення, тому ми додаємо 1, щоб виправити це.

Це ніколи не дасть більше, ніж на 15 більше, ніж сума, але це нормально, оскільки 10 ^ 15 набагато менше, ніж шанс, що космічний промінь порушує обчислення .

R, 60 47 28 байт

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

Це неназваний функціональний об'єкт, який приймає два числа і повертає число. У ньому не використовується рекурсія.

Як xnor зазначив у коментарі, цю проблему можна розглядати як просто додавання двох чисел плюс геометричну випадкову змінну з ймовірністю відмови 1/10.

Чому це правда? Подумайте про це з точки зору рекурсії, як це описано у публікації. У кожній ітерації у нас є 10% шансів додати 1 і повторити, і 90% шанс вийти з функції без подальшого додавання. Кожна ітерація - це власне незалежне випробування Бернуллі з результатами "додавання 1, повтор" (невдача) та "вихід" (успіх). Таким чином, ймовірність невдачі становить 1/10, а ймовірність успіху - 9/10.

При роботі з серією незалежних випробувань Бернуллі кількість випробувань, необхідних для отримання єдиного успіху, слід за геометричним розподілом . У нашому випадку кожна рекурсія означає додавання 1, тому, коли ми остаточно виходимо з функції, ми по суті підраховували кількість відмов, які сталися до першого успіху. Це означає, що сума, на яку буде вилучений результат, є випадковою змінною з геометричного розподілу.

Тут ми можемо скористатися експансивним набором вбудованих і використовувати ймовірність розподілу ймовірностей rgeom, який повертає випадкове значення з геометричного розподілу.

Безголівки:

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

Minkolang 0,14 , 19 11 12 байт

Це версія "функції"; він передбачає aі bвже є на стеці, вискакує їх і відштовхує модифіковану версію a+b. Найближчий еквівалент функцій Minkolang є використання F, який вискакує геть b, aі переходить до (a,b)в CodeBox. Потім, коли лічильник програм потрапляє на f, він відскакує туди, де Fбув використаний.

(+$01$h`d)xf

Це повна версія програми, 15 байт . ( nnбере два числа з введення та N.виводить результат і зупиняється.)

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

Я вкрав алгоритм з відповіді Дорноба ; цикл у той час повторюється до тих пір, поки згенероване випадкове число менше 0,1, додаючи 1 кожен раз. Спробуйте тут (повна версія програми) та запустіть її 100 разів тут .

Пояснення

(              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

Найрозумніша частина тут d. Вершина стека в цей момент часу буде або 0, або 1. Якщо це 0, цикл while виходить. В іншому випадку це триває. Коли я дублюю верхню частину стека, це буде [a+b,1]вдруге через цикл, тому +на початку додається 1 (і аналогічно для подальших подорожей).

CJam, 12 11 байт

{{+Amr!}h;}

Дякуємо @ MartinBütter за збереження байту за допомогою цього супер хитрого хитрості!

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

Стара відповідь:

{+({)Amr!}g}

Спробуйте в Інтернеті .

Пояснення:

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

Основний алгоритм - це "час (0,1 шанс), збільшення числа", що виключає необхідність в рекурсії.

Javascript ES6, 38 байт

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

MATL , 14 13 12 байт

is`r.1<tb+w]

Це лише циклічний метод, додайте входи (введені як [a b]), а потім продовжуйте додавати одне, тоді як рівномірне випадкове число між 0 і 1 менше 0,1. Повний опис нижче:

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    

Зняв 1 байт, змінивши вхідні характеристики (з ii+на is).

Старий спосіб базувався на прийнятті базового 10 журналу випадкового числа між 0 і 1, щоб розробити суму, яку потрібно додати a+b, однак він би працював лише до 15 повторень за рахунок точності з плаваючою комою.

iir10,2$YlZo-+

У цьому коді 10,2$YlZo-робить логарифм базового 10 випадкового числа і округлює до найближчого цілого числа.

Бінарний кодований гольфічний , 32 29 + 1 ( -xпрапор) = 30 байт

Hexdump (відредагований вручну, щоб виправити помилку в зображенні до бінарної частини транспілера, яке було виправлено):

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

Це кодування можна перетворити назад у вихідне графічне зображення за допомогою включеної утиліти Encoder або запустити безпосередньо за допомогою -xпрапора.

Оригінальне зображення:

Збільшено 50x:

Пояснення: верхній рядок - це основний блок. Він читає число, копіює його праворуч, зчитує інше число, додає їх, копіює результат праворуч, робить деякі матеріали RNG і, з вірогідністю 90%, друкує результат додавання. Решту часу він надсилається до нижнього ряду, де він кладе одиницю в першу клітинку і повертається до основного ряду безпосередньо перед інструкцією додавання (використовуючи поворот на північ, потім схід).

Пітон, 66 65 64 63 байт

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

Спробуйте в Інтернеті

Дякуємо Sherlock9 за виправлення та збережений байт.

Дякуємо Матіасу Еттінґеру за ще один байт.

Завдяки mbomb007 за байт.

Джулія, 30 байт

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

Це рекурсивна функція, fяка приймає два числа і повертає номер одного типу. Це повинно працювати нормально для будь-якого числового типу.

Спочатку ми перевіряємо, чи випадковий плавець між 0 і 1 більший за 0,9. Якщо так, то ми повторюємо трохи більше «щось щось», інакше ми просто додамо.

TI-BASIC, 15 байт

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

Це сприймає дані як двоелементний список від Ans. Хоча випадкове число менше 0.1, але воно векторизовано додає до 0.5списку. Збільшення кожного елемента 0.5збільшує суму на 1. Я вважаю, що це найкоротше рішення TI-BASIC.

9-байтова програма sum(Ans)-int(log(10randне працює, тому що randмає лише 14 цифр точності, і, таким чином, вона не може дати число менше 10 ^-14 .

APL, 17 байт

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

Це неназвана діадична функція.

Безголівки:

{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 байт

KsQW!OT=hK;K

Мій перший справжній гольф Pyth!

Здійснює введення даних STDIN у форматі a,b.

Пояснення:

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

Завдяки @FryAmTheEggman за те, що голили два знаки, давши мені коротший спосіб збільшити змінну!

Віци , 12 10 байт

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.

Спробуйте в Інтернеті!

_{Зауважте, що це невелика ймовірність помилки переповнення стека. Ми говоримо (.1)^400шанс. Він також виходить з помилки через те, як я викликав рекурсію.}

Лісп, 58 байт

Мій перший раз писав Лісп!

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

Ви можете використовувати це спеціальне доповнення саме так, як ви зазвичай додавали в Lisp:

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

Я хотів би почути пропозиції, оскільки я абсолютно новий у мові.

Серйозно, 10 байт

,Σ1±╤_G_\+

Ця програма генерує випадкову змінну з геометричного розподілу шляхом перетворення рівномірного розподілу. Він приймає дані як список: [2,3](дужки необов’язково). Спробуйте в Інтернеті .

Пояснення:

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

Враховуючи випадкову змінну X ~ Uniform(0, 1), її можна перетворити на випадкову змінну Y ~ Geometric(p)за формулою Y = floor(log(X)/log(p)).

Математика, 32 байти

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

Пояснення:

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

Зауважте, що ця функція працює для будь-якої кількості входів.

TeaScript , 18 байт 21

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

Це функція TeaScript. Призначте його змінній або просто запустіть її безпосередньо.

Спробуйте в Інтернеті

Цукерки , 11 байт

+#10H{.}10g

Довга форма:

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 байт

Перший гольф-код, зроблений на C ... Я не думаю, що він нічого не виграє, і може бути багато в гольф

EDIT 3: викреслив 2 байти завдяки @Mego, написавши .1 замість 0,1 та переписавши потрійний оператор

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

EDIT 2: введено 12 байт, наступні за gnu99, кожна змінна є цілою, якщо не вказано інше. Те ж саме стосується і типу повернення функції

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

EDIT: набрав 20 байт, забув, що базові .h не потрібні в C99 (використовуючи, наприклад, gcc). Це створить попередження :)

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

71 байт рішення:

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

Якщо ви хочете побачити багато результатів, ви можете використовувати наступний код

#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 байт

r.1H$YlY[ihs

Введення має форму [3 4] , тобто векторний рядок з двома числами.

Приклад

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

Пояснення

Це генерує геометричну випадкову змінну без циклів, безпосередньо застосовуючи перетворення aa на рівномірну випадкову змінну. Зверніть увагу , що лог - _0,1 з використовується замість лог а / 0,1 увійти , щоб зберегти 1 байт.

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

Мікроскрипт , 29 21 байт

isi+vzr10!{l1vzr10!}l

Я спробував зробити відповідь Microscript II, але я чомусь не зміг зробити так, щоб цикл додавання працював правильно :(

Миша-2002 , 41 39 38 байт

Рекурсії немає.

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

Пояснили:

&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

Або якщо ви любитель функціонального програмування, а рекурсія - це ваша угода, тоді 57 байт :

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

Пояснили:

&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

Желе , 7 байт (не конкуруючий)

‘⁵XỊ¤¿+

Спробуйте в Інтернеті!

Як це працює

‘⁵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 байт ^SBCS

В основному те саме, що і рішення Pyth FryAmTheEggman . -1 спасибі Еріку Переможця.

Функція анонімного мовчазного виправлення.

{⍵+1=?10}⍣=+

Спробуйте в Інтернеті!

+ додайте аргументи

{… }⍣= Застосувати наступну функцію, поки дві послідовні програми не мають однакового результату:

 ?10 випадкове ціле число в діапазоні 1–10

 1= це дорівнює тому? (тобто ¹ ⁄ _10- ^й шанс)

 ⍵+ додайте аргумент до цього

Perl 6 , 26 байт

Насправді це робиться рекурсивно:

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

Створіть, можливо, порожню послідовність 1s, а потім аргументи, а потім підсумуйте їх усі разом.

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

(він може насправді приймати будь-яку кількість аргументів)

використання:

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

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

Pyth, 11 байт

+sQ-18l`hO0

Прямий порт Pyth з моєї відповіді 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)

Октава, 20 байт

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

Сума входів, плюс випадкова вибірка з геометричного розподілу з параметром 0.9.

Серйозно, 13 байт

,,1W+9uJYWDkΣ

Використовується аналогічна стратегія на відповідь CJam Doorknob (приріст числа при випадковому поплавці менше 0,1), за винятком того, що вона використовує цілі числа, а приріст, а випадкове ціле число [0,9]- менше 1. Відсутність легкої рекурсії шкодить.

Спробуйте в Інтернеті (потрібен ручний ввід)

Пояснення:

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

Цикл while залишає стек так:

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

Зміна nвгору на 1 необхідна для того, щоб цикл час працював, оскільки 0це фальси. Це легко вирішується декрементацією nпісля циклу час, тому кінцевим результатом є a + b + (n - 1).

MATLAB, 51 байт

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

Результат знаходимо в автоматичній змінній 'ans'