Вдохновленные великолепным Алексом Learn you a R для отличного добра, мы собираемся скромно воссоздать «единственную настоящую 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;
  }
}

Попробуйте эту скрипку онлайн.

Leaderboard

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, поэтому, когда мы, наконец, выйдем из функции, мы по существу посчитали количество сбоев, которые произошли до первого успеха. Это означает, что величина, на которую будет выведен результат, является случайным отклонением от геометрического распределения.

Здесь мы можем воспользоваться широким набором встроенных в R распределений вероятностей и использовать его rgeom, который возвращает случайное значение из геометрического распределения.

Ungolfed:

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

Минколанг 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.

Я украл алгоритм из ответа Doorknob ; цикл while повторяется до тех пор, пока сгенерированное случайное число меньше 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).

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

iir10,2$YlZo-+

В этом коде 10,2$YlZo-выполняется логарифм случайного числа с основанием 10 и округление до ближайшего целого числа.

Бинарно - кодированный Golfical , 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флага.

Исходное изображение:

Увеличено в 50 раз:

Объяснение: Верхний ряд является основным блоком. Он читает число, копирует его вправо, читает другое число, добавляет их, копирует результат справа, выполняет некоторые операции по ГСЧ и, с вероятностью 90%, печатает результат сложения. В остальное время он отправляется в нижний ряд, где помещает единицу в первую ячейку и возвращается к главному ряду непосредственно перед инструкцией сложения (с использованием поворота на север, а затем на восток).

Python, 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⋄⍺+⍵}

Это безымянная двоичная функция.

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

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

Mathematica, 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. Присвойте его переменной или просто запустите напрямую.

Попробуйте онлайн

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

Первый код-гольф, сделанный на Си ... Я не думаю, что он что-то превзойдет, и, возможно, сильно проиграет

РЕДАКТИРОВАТЬ 3: отредактировал 2 байта благодаря @Mego, написав 0,1 вместо 0,1 и переписав троичный оператор

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

РЕДАКТИРОВАТЬ 2: отредактированные 12 байтов, следующие за gnu99, каждая переменная является int, если не указано иное. То же самое касается возвращаемого типа функции

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

РЕДАКТИРОВАТЬ: вырезать 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

объяснение

Это генерирует геометрическую случайную переменную без циклов, непосредственно применяя преобразование к однородной случайной переменной. Обратите внимание, что log _0.1 a используется вместо log a / log 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

Microscript , 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 необходим для запуска цикла while, так как 0это фальси. Это легко решается уменьшением nпосле цикла while, так что конечный результат таков a + b + (n - 1).

MATLAB, 51 байт

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

Результат находится в автоматической переменной ans