非負整数の階乗を見つける最短のプログラムまたは関数を作成します。

で表される階乗は、!そのように定義されます

平易な英語では、0の階乗は1であり、nの階乗は、nが0より大きい場合、nより小さい階乗の階乗のn倍です。

コードは、標準の方法を使用して入出力を実行する必要があります。

要件：

• 階乗を計算できる組み込みライブラリを使用しません（これにはの形式が含まれますeval）
• 125までの数値の階乗を計算できます
• 数値0（1に等しい）の階乗を計算できます
• 最大125の番号で1分以内に完了

最短の提出が勝ち、同点の場合は、その時点で最も票数の多い答えが勝ちます。

Golfscript-12文字

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

Golfscriptを始めよう-段階的要因

ここでは、golfscriptを学ぼうとしている人々のためのものです。前提条件は、golfscriptの基本的な理解と、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

空白は、golfscriptで使用されることはほとんどありません。空白を取り除く最も簡単なトリックは、異なる変数名を使用することです。すべてのトークンを変数として使用できます（構文ページを参照）。変数のような特殊文字があると便利なトークンが使用する|、&、?コードの他の場所で使用され、一般的には何もありません- 。これらは常に単一文字のトークンとして解析されます。対照的に、次のような変数では、n後にスタックに数値をプッシュするためのスペースが必要になります。数値は基本的に事前に初期化された変数です。

いつものように、最終結果に影響を与えずに変更できるステートメントがあります。golfscriptでは、すべてのものは除くtrueと評価され0、[]、""、及び{}（参照これを）。ここで、ループの終了条件を単純に変更できます{n}（追加の時間をループし、n = 0で終了します）。

あらゆる言語のゴルフと同様に、利用可能な機能を知ることは役立ちます。幸いなことに、リストはgolfscriptの非常に短いものです。に変更1-し(て、別のキャラクターを保存できます。現在、コードは次のようになっています：（必要に応じて1、|ここではなく初期化を削除します）

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

スタックを適切に使用して最短のソリューションを取得することが重要です（練習練習）。一般的に、値がコードの小さなセグメントでのみ使用される場合、変数に保存する必要はないかもしれません。実行中の製品変数を削除し、単にスタックを使用するだけで、非常に多くのキャラクターを節約できます。

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

他に考えるべきことがあります。nループ本体の終わりでスタックから変数を削除しますが、その後すぐにプッシュします。実際、ループを開始する前に、スタックからも削除します。代わりにスタックに残しておく必要があり、ループ条件を空白のままにできます。

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

変数を完全に削除することもできます。これを行うには、常にスタックに変数を保持する必要があります。つまり、条件チェックの終了時にスタック上に変数のコピーが2つ必要なので、チェック後に失われないようにします。これは0、ループの終了後にスタックに冗長性を持たせることを意味しますが、修正は簡単です。

これにより、最適なwhileループソリューションが実現します。

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

今、私たちはまだこれを短くしたいです。明らかなターゲットは単語であるべきwhileです。ドキュメントを見ると、実行可能な代替案が2つあります-unfoldとdoです。さまざまなルートを選択できる場合は、両方の利点を比較検討してください。展開は「かなりしばらくループ」であるため、推定として5文字whileを4 ずつに減らします/。についてはdo、while3文字ずつカットし、2つのブロックをマージします。これにより、別の文字が1つまたは2つ保存されます。

実際には、doループを使用することには大きな欠点があります。本体が1回実行された後に条件チェックが行われるため、の値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文字です。

配列

配列は通常、2つの方法で作成されます- [と]文字を使用するか、,関数を使用します。スタックの先頭に整数を指定して実行すると、,arr [i] = iでその長さの配列を返します。

配列を反復処理するには、3つのオプションがあります。

1. {block}/：プッシュ、ブロック、プッシュ、ブロック、...
2. {block}%：[push、block、push、block、...]（これにはいくつかのニュアンスがあります。たとえば、各プッシュの前に中間値がスタックから削除されます）
3. {block}*：プッシュ、プッシュ、ブロック、プッシュ、ブロック、...

golfscriptドキュメントには{+}*、配列の内容を合計するために使用する例があります。これ{*}*は、配列の積を取得するために使用できることを示しています。

{,{*}*}:f

残念ながら、それはそれほど単純ではありません。すべての要素が（[0 1 2]ではなく[1 2 3]）1つずれています。{)}%この問題を修正するために使用できます。

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

よくない。これはゼロを正しく処理しません。これを修正するために（n + 1）！/（n + 1）を計算できますが、コストがかかりすぎます。

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

また、n = 1と同じバケットでn = 0を処理することもできます。これは実際には非常に短いので、できる限り短い時間を試してみてください。

7文字でソートするのはあまり良くありません：[1\]$1=。このソート手法には、数字に境界を課すなどの便利な目的があることに注意してください（例： `[0 \ 100] $ 1 =）
。3文字のみの勝者は次のとおりです。

同じブロックでインクリメントと乗算を行いたい場合、配列内のすべての要素を反復処理する必要があります。配列を構築していないので、これはを使用する必要があることを意味します{)*}/。これにより、factorialの最短の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]

パイソン-27

単純に：

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

APL（4）

×/∘⍳

無名関数として機能します：

    ×/∘⍳ 5
120

名前を付けたい場合、6文字：

f←×/∘⍳

J（12）

Jの標準定義：

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

125秒で1秒未満！

例えば：

 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から$_引数までのカウントアップです。

Matlab、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)

（Alexandruのソリューションに基づく）

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)

オンラインでお試しください！

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

Java、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)

truen = 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);

125doubleなので使用する必要があります！== 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/

Brachylog、7 6バイト

範囲を作成して乗算する

max（）関数を使用するという考えを持つovsへの-1バイトのタンク

;1⌉⟦₁×

説明

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

オンラインでお試しください！

Brachylog、10 9バイト

再帰

≤1|-₁↰;?×

説明

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

オンラインでお試しください！

C（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

Scala、39文字

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

ほとんどの文字は、BigIntsが使用されることを保証しているため、最大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)))))

Common Lispに勝る新しいバージョン：リストのすべての要素を乗算します（Haskellソリューションと同じ）

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

適用の代わりにfoldlを使用し、buildlistの代わりにrangeを使用して、他のスキームソリューションを破り、他のラケットソリューションを計算する新しいバージョン

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

モーニングトンクレセント、1827年1698年

今日は新しい言語を学ぼうと思ったのですが、これが私が着陸したものです...（なぜ自分でこれを行うのですか？）このエントリは賞品を獲得することはできませんが、同じ言語！

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！その後、メインループを開始できます。

編集次のステップ。）

減量はモーニングトンクレセントでは高価です（ただし、チューブ自体よりも安価です）。物事をより効率的にするために、解析された0のNOTを取得して-1を生成し、ループの大部分について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の初心者ですが、これまでのところとても楽しいです！

In C（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