Создайте самую короткую программу или функцию, которая находит факториал неотрицательного целого числа.

Факториал, представленный !как, определяется как таковой

В простом английском языке факториал 0 равен 1, а факториал n, где n больше 0, в n раз больше факториала на единицу, чем n.

Ваш код должен выполнять ввод и вывод, используя стандартные методы.

Требования:

• Не использует никаких встроенных библиотек, которые могут вычислить факториал (включая любую форму eval)
• Можно рассчитать факториалы для чисел до 125
• Можно рассчитать факториал для числа 0 (равно 1)
• Завершается менее чем за минуту для номеров до 125

Получается самое короткое представление, в случае ничьей выигрывает ответ, набравший наибольшее количество голосов.

Golfscript - 12 символов

{,1\{)*}/}:f

Начало работы с Golfscript - Факториал шаг за шагом

Вот кое-что для людей, которые пытаются выучить гольф. Обязательным условием является базовое понимание гольф-скрипта и умение читать документацию по гольф-скрипту.

Поэтому мы хотим опробовать наш новый инструмент golfscript . Всегда хорошо начинать с чего-то простого, поэтому мы начинаем с факториала. Вот начальная попытка, основанная на простом императивном псевдокоде:

# pseudocode: f(n){c=1;while(n>1){c*=n;n--};return c}
{:n;1:c;{n 1>}{n c*:c;n 1-:n;}while c}:f

Пробелы в гольскрипте очень редко используются. Самый простой способ избавиться от пробелов - использовать разные имена переменных. Каждый токен может использоваться как переменная (см. Страницу синтаксиса ). Полезные маркеры для использования в качестве переменных специальные символы , такие как |, &, ?- вообще ничего не используется в других местах в коде. Они всегда анализируются как токены одного символа. Напротив, переменные типа like nпотребуют пробела для добавления числа в стек после. Числа по существу являются преинициализированными переменными.

Как всегда, будут утверждения, которые мы можем изменить, не влияя на конечный результат. В golfscript, все оценивается как истина , за исключением 0, [], ""и {}(см это ). Здесь мы можем изменить условие выхода из цикла на простое {n}(мы добавляем цикл в дополнительное время и завершаем работу, когда n = 0).

Как и при игре в гольф на любом языке, это помогает узнать о доступных функциях. К счастью, список очень короток для гольфа. Мы можем изменить , 1-чтобы (спасти другой персонаж. В настоящее время код выглядит следующим образом: (мы могли бы использовать 1вместо этого, |если бы мы хотели, что бы сбросить инициализацию.)

{:n;1:|;{n}{n|*:|;n(:n;}while|}:f

Важно правильно использовать стек, чтобы получить кратчайшие решения (практика, практика). Как правило, если значения используются только в небольшом сегменте кода, может не потребоваться сохранять их в переменных. Удаляя переменную product product и просто используя стек, мы можем сохранить довольно много символов.

{:n;1{n}{n*n(:n;}while}:f

Вот о чем еще подумать. Мы удаляем переменную nиз стека в конце тела цикла, но затем добавляем ее сразу после. Фактически, перед началом цикла мы также удаляем его из стека. Вместо этого мы должны оставить его в стеке, и мы можем оставить условие цикла пустым.

{1\:n{}{n*n(:n}while}:f

Может быть, мы можем даже полностью исключить переменную. Для этого нам нужно будет постоянно хранить переменную в стеке. Это означает, что нам нужно две копии переменной в стеке в конце проверки условия, чтобы мы не потеряли ее после проверки. Это означает, что у нас будет избыточность 0в стеке после окончания цикла, но это легко исправить.

Это приводит нас к нашему оптимальному whileциклическому решению!

{1\{.}{.@*\(}while;}:f

Теперь мы все еще хотим сделать это короче. Очевидной целью должно быть слово while. Глядя на документацию, есть две жизнеспособные альтернативы - развернуть и сделать . Если у вас есть выбор различных маршрутов, попробуйте взвесить преимущества обоих. Развернуть это «довольно много времени цикла», так что в качестве оценки мы сократим 5 символов whileна 4 в /. Что касается do, мы разрезаем whileна 3 символа и получаем объединение двух блоков, что может сохранить еще один или два символа.

На самом деле есть большой недостаток в использовании doцикла. Поскольку проверка условия выполняется после однократного выполнения тела, значение 0будет неправильным, поэтому нам может понадобиться оператор if. Я вам сейчас скажу, что разворачивается короче ( doв конце представлены некоторые решения с ). Попробуйте и попробуйте, код, который у нас уже есть, требует минимальных изменений.

{1\{}{.@*\(}/;}:f

Большой! Наше решение теперь очень короткое, и мы здесь, верно? Нет. Это 17 символов, а у J 12 символов. Никогда не признай поражение!

Теперь вы думаете с ... рекурсией

Использование рекурсии означает, что мы должны использовать ветвящуюся структуру. К сожалению, но так как факториал можно выразить так кратко, рекурсивно, это кажется жизнеспособной альтернативой итерации.

# pseudocode: f(n){return n==0?n*f(n-1):1}
{:n{n.(f*}1if}:f # taking advantage of the tokeniser

Ну, это было легко - если бы мы попробовали рекурсию раньше, мы могли бы даже не взглянуть на использование whileцикла! Тем не менее, мы только на 16 символов.

Массивы

Массивы обычно создаются двумя способами - с помощью [и ]символов, или с ,функцией. Если выполняется с целым числом в верхней части стека, ,возвращает массив этой длины с arr [i] = i.

Для перебора массивов у нас есть три варианта:

1. {block}/: толкать, блокировать, толкать, блокировать, ...
2. {block}%: [push, block, push, block, ...] (здесь есть некоторые нюансы, например, промежуточные значения удаляются из стека перед каждым push)
3. {block}*: толкать, толкать, блокировать, толкать, блокировать, ...

В документации по гольфу есть пример использования {+}*для суммирования содержимого массива. Это говорит о том, что мы можем использовать, {*}*чтобы получить произведение массива.

{,{*}*}:f

К сожалению, не все так просто. Все элементы отключены одним ( [0 1 2]вместо [1 2 3]). Мы можем использовать, {)}%чтобы исправить эту проблему.

{,{)}%{*}*}:f

Ну, не совсем. Это не обрабатывает ноль правильно. Мы можем вычислить (n + 1)! / (N + 1), чтобы исправить это, хотя это стоит слишком дорого.

{).,{)}%{*}*\/}:f

Мы также можем попытаться обработать n = 0 в том же сегменте, что и n = 1. Это на самом деле очень коротко, попытаться выработать как можно меньше.

Не так хорошо , как сортировка, в 7 символов: [1\]$1=. Обратите внимание, что этот метод сортировки имеет полезные цели, такие как наложение границ на число (например, `[0 \ 100] $ 1 =).
Вот победитель, имеющий только 3 символа:.! +

Если мы хотим, чтобы приращение и умножение были в одном и том же блоке, мы должны выполнять итерации по каждому элементу в массиве. Поскольку мы не создаем массив, это означает, что мы должны его использовать {)*}/, что приводит нас к кратчайшей реализации факториала в golfscript! В 12 символов, это связано с J!

{,1\{)*}/}:f

Бонусные решения

Начиная с простого ifрешения для doцикла:

{.{1\{.@*\(.}do;}{)}if}:f

Мы можем выжать пару лишних из этого. Немного сложно, так что вам придется убедить себя, что эти работы. Убедитесь, что вы понимаете все это.

{1\.!!{{.@*\(.}do}*+}:f
{.!{1\{.@*\(.}do}or+}:f
{.{1\{.@*\(.}do}1if+}:f

Лучшей альтернативой является вычисление (n + 1)! / (N + 1), что устраняет необходимость в ifструктуре.

{).1\{.@*\(.}do;\/}:f

Но самое короткое doрешение здесь занимает несколько символов, чтобы отобразить 0 к 1, и все остальное для себя - так что нам не нужно никаких ветвлений. Этот вид оптимизации чрезвычайно легко пропустить.

{.!+1\{.@*\(.}do;}:f

Для тех, кто заинтересован, здесь представлено несколько альтернативных рекурсивных решений такой же длины, как указано выше:

{.!{.)f*0}or+}:f
{.{.)f*0}1if+}:f
{.{.(f*}{)}if}:f

* примечание: на самом деле я не тестировал многие фрагменты кода в этом посте, поэтому не стесняйтесь сообщать, если есть ошибки.

Хаскелл, 17

f n=product[1..n]

Python - 27

Просто:

f=lambda x:0**x or x*f(x-1)

APL (4)

×/∘⍳

Работает как анонимная функция:

    ×/∘⍳ 5
120

Если вы хотите дать ему имя, 6 символов:

f←×/∘⍳

J (12)

Стандартное определение в J:

f=:*/@:>:@i.

Менее 1 секунды на 125!

Например:

 f 0
 1
 f 5
 120
  f 125x
 1882677176888926099743767702491600857595403
 6487149242588759823150835315633161359886688
 2932889495923133646405445930057740630161919
 3413805978188834575585470555243263755650071
 31770880000000000000000000000000000000

Golfscript - 13 символов (SYM)

определяет функцию !

{),()\{*}/}:!             # happy robot version \{*}/ 

альтернативная версия на 13 символов

{),()+{*}*}:! 

вся версия программы 10 символов

~),()+{*}*

Тестовые случаи занимают менее 1/10 секунды:

вход:

0!

выход

1

вход

125!

выход

188267717688892609974376770249160085759540364871492425887598231508353156331613598866882932889495923133646405445930057740630161919341380597818883457558547055524326375565007131770880000000000000000000000000000000

Perl 6: 13 символов

$f={[*]1..$_}

[*]такой же, как у Haskell product, и 1..$_считается от 1 до $_аргумента.

Матлаб, 15

f=@(x)prod(1:x)

Тестовые случаи

>> f(0)
ans =
     1
>> f(4)
ans =
    24
>> tic,f(125),toc
ans =
  1.8827e+209
Elapsed time is 0.000380 seconds.

Python, 28 байт

f=lambda x:x/~x+1or x*f(x-1)

(на основе решения Александру)

MATL , 2 байта

:p

Разъяснение:

:    % generate list 1,2,3,...,i, where i is an implicit input
p    % calculate the product of of all the list entries (works on an empty list too)

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

Рубин - 21 символ

f=->n{n>1?n*f[n-1]:1}

Контрольная работа

irb(main):009:0> f=->n{n>1?n*f[n-1]:1}
=> #<Proc:0x25a6d48@(irb):9 (lambda)>
irb(main):010:0> f[125]
=> 18826771768889260997437677024916008575954036487149242588759823150835315633161
35988668829328894959231336464054459300577406301619193413805978188834575585470555
24326375565007131770880000000000000000000000000000000

Ява, 85 символов

BigInteger f(int n){return n<2?BigInteger.ONE:new BigInteger(""+n).multiply(f(n-1));}

PostScript, 26 символов

/f{1 exch -1 1{mul}for}def

Пример:

GS> 0 f =
1
GS> 1 f =
1
GS> 8 f =
40320

Сама функция занимает всего 21 символ; остальное - привязать его к переменной. Чтобы сохранить байт, можно также привязать его к цифре, например так:

GS> 0{1 exch -1 1{mul}for}def
GS> 8 0 load exec =
40320

JavaScript, 25

function f(n)!n||n*f(n-1)

CoffeeScript, 19

f=(n)->!n||n*f(n-1)

Возвращает trueв случае n = 0, но JavaScript все равно приведет к 1.

Рубин - 30 29 символов

def f(n)(1..n).inject 1,:*end

Контрольная работа

f(0) -> 1
f(5) -> 120

F #: 26 символов

Там нет встроенной функции продукта в F #, но вы можете сделать один со сгибом

let f n=Seq.fold(*)1{1..n}

C #, 20 или 39 символов в зависимости от вашей точки зрения

Как традиционный метод экземпляра (39 символов; проверено здесь ):

double f(int x){return 2>x?1:x*f(x-1);}

Как лямбда-выражение (20 символов, но см. Заявление об отказе от ответственности; проверено здесь ):

f=x=>2>x?1:x*f(x-1);

Мы должны использовать, doubleпотому что 125! == 1.88 * 10 ²⁰⁹ , что намного выше, чем ulong.MaxValue.

Отказ от ответственности за количество символов лямбда-версии:

Если вы выполняете рекурсию в лямбде C #, вам, очевидно, придется хранить лямбда в именованной переменной, чтобы она могла вызывать себя. Но, в отличие от (например, JavaScript), лямбда с самообращением должна быть объявлена и инициализирована в предыдущей строке. Вы не можете вызывать функцию в том же операторе, в котором вы объявляете и / или инициализируете переменную.

Другими словами, это не работает :

Func<int,double> f=x=>2>x?1:x*f(x-1); //Error: Use of unassigned local variable 'f'

Но это делает :

Func<int,double> f=null;            
f=x=>2>x?1:x*f(x-1);  

Для этого ограничения нет веских причин, поскольку fего нельзя отменять во время его работы. Необходимость Func<int,double> f=null;строки - это причуда C #. Делает ли это справедливым игнорировать это при подсчете символов - решать читателю.

CoffeeScript, 21 19 символов для настоящих

f=(x)->+!x||x*f x-1

Протестировано здесь: http://jsfiddle.net/0xjdm971/

Брахилог , 7 6 байт

Делая диапазон и умножая его

Танки -1 байт для ов, имеющих идею использовать функцию max ()

;1⌉⟦₁×

объяснение

;1          --  If n<1, use n=1 instead (zero case)
  ⟦₁        --      Construct the range [1,n]
    ×       --      return the product of said range

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

Брахилог , 10 9 байт

рекурсия

≤1|-₁↰;?×

объяснение

            --f(n):
≤1          --  if n ≤ 1: return 1
|           --  else:
 -₁↰        --      f(n-1)
    ;?×     --            *n

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

С (39 символов)

double f(int n){return n<2?1:n*f(n-1);}

D: 45 символов

T f(T)(T n){return n < 2 ? 1 : n * f(n - 1);}

Более разборчиво:

T f(T)(T n)
{
    return n < 2 ? 1 : n * f(n - 1);
}

Кулер (хотя и более длинная версия) - шаблонизированный, который делает все это во время компиляции ( 64 символа ):

template F(int n){static if(n<2)enum F=1;else enum F=n*F!(n-1);}

Более разборчиво:

template F(int n)
{
    static if(n < 2)
        enum F = 1;
    else
        enum F = n * F!(n - 1);
}

Тем не менее, одноименные шаблоны довольно многословны, так что вы не можете использовать их в код-гольфе очень хорошо. D уже достаточно многословен с точки зрения количества символов, чтобы быть достаточно плохим для гольф-кода (хотя на самом деле он действительно хорош при уменьшении общего размера программы для больших программ). Хотя это мой любимый язык, поэтому я полагаю, что с таким же успехом я мог бы попытаться увидеть, насколько хорошо я смогу это сделать в кодовом гольфе, даже если подобный GolfScript не лишен этого.

PowerShell - 36

Наивный:

filter f{if($_){$_*(--$_|f}else{1}}

Контрольная работа:

> 0,5,125|f
1
120
1,88267717688893E+209

Скала, 39 знаков

def f(x:BigInt)=(BigInt(1)to x).product

Большинство символов гарантируют, что BigIntиспользуются s, так что требование к значениям до 125 выполняется.

Javascript, ES6 17

f=n=>n?n*f(n-1):1

ES6:

• Функция стрелки

PowerShell, 42 байта

(сохранил 2 символа, используя фильтр вместо функции )

filter f($x){if(!$x){1}else{$x*(f($x-1))}}

Выход:

PS C:\> f 0
1
PS C:\> f 5
120
PS C:\> f 1
1
PS C:\> f 125
1.88267717688893E+209

Ракетка (схема) 40 35 29 байт

Вычисляет 0! быть 1, и вычисляет 125! в 0 секунд по таймеру. Регулярный рекурсивный подход

(define(f n)(if(= n 0)1(* n(f(- n 1)))))

Новая версия, чтобы превзойти общий lisp: умножает все элементы списка (так же, как это решение на Haskell)

(λ(n)(apply *(build-list n add1)))

Более новая версия, чтобы превзойти другое решение схемы и математическое решение другой ракетки, используя foldl вместо apply и используя range вместо buildlist

(λ(n)(foldl * n(range 1 n)))

Морнингтон Полумесяц , 1827 1698 символов

Я чувствовал, что изучаю новый язык сегодня, и это то, на чем я остановился ... (Почему я делаю это для себя?) Эта запись не будет выигрывать какие-либо призы, но она побеждает все 0 других ответов до сих пор, используя тот же язык!

Take Northern Line to Bank
Take Central Line to Holborn
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Acton Town
Take District Line to Hammersmith
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Parsons Green
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Bank
Take Circle Line to Temple
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Bank
Take District Line to Upney
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Upney
Take District Line to Bank
Take Circle Line to Embankment
Take Circle Line to Embankment
Take Northern Line to Angel
Take Northern Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Mornington Crescent

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

Любой, кто путешествовал по Лондону, сразу же это поймет, поэтому я уверен, что мне не нужно давать полное объяснение.

Большая часть работы на старте заключается в обработке случая 0. После инициализации продукта в 1, я могу использовать это для вычисления max (input, 1), чтобы получить новый ввод, используя тот факт, что 0! = 1! Тогда основной цикл может начаться.

(РЕДАКТИРОВАТЬ: целая куча поездок была спасена путем удаления 1 из «Терминалов Хитроу 1, 2, 3» вместо генерации ее путем деления 7 (сестер) на себя. Я также использую более дешевый метод для генерации -1 в следующий шаг.)

В Mornington Crescent декрементирование стоит дорого (хотя и дешевле, чем сама Tube). Чтобы сделать вещи более эффективными, я генерирую -1, беря NOT из анализируемого 0 и сохраняю его в Hammersmith для большей части цикла.

Befunge - 2x20 = 40 символов

0\:#v_# 1#<\$v *\<
    >:1-:#^_$>\:#^_$

Это функция в том смысле, что это автономный блок кода, не использующий обтекание. Вы должны поместить аргумент в верхнюю часть стека, затем войти в верхний левый угол, идущий вправо, функция выйдет из нижнего правого угла, идущего вправо, с результатом на вершине стека.

Например, чтобы вычислить факториал 125

555**   0\:#v_# 1#<\$v *\<
            >:1-:#^_$>\:#^_$    .@

Тестирование 0

0   0\:#v_# 1#<\$v *\<
        >:1-:#^_$>\:#^_$    .@

J - 6 символов

*/>:i.

Это считается? Я знаю, что это очень похоже на предыдущий пример J, но оно немного короче :)

Я новичок с J, но это очень весело!

В С (23 символа)

Это нарушает «особенность» GCC, которая делает счет последнего присваивания в качестве возврата, если возврат не указан.

f(a){a=a>0?f(a-1)*a:1;}

В правильном C, 28 символов

f(a){return a>0?f(a-1)*a:1;}

Кона ( 11 6)

*/1.+!

K работает справа налево (по большей части), поэтому мы перечисляем x(составляем список / массив чисел от 0до x-1), добавляем 1к нему (список варьируется 0до x), затем умножаем все числа вместе. Если бы это не было требованием для вычисления 125!, я мог бы сохранить еще 1 байт, исключив .рядом с 1. В любом случае 125! вычисляется в миллисекундах:

  */1.+!125.
1.882677e+209