（x == 0 || x == 1）を単一の操作に簡略化することは可能ですか？

だから私はフィボナッチ数列のn番目の数をできるだけコンパクトな関数で書こうとしました：

public uint fibn ( uint N ) 
{
   return (N == 0 || N == 1) ? 1 : fibn(N-1) + fibn(N-2);
}

しかし、これを変更することでこれをさらにコンパクトで効率的なものにできるかどうか疑問に思っています

(N == 0 || N == 1)

単一の比較に。これを行うことができるいくつかの派手なビットシフト操作はありますか？

これも効く

Math.Sqrt(N) == N 

0と1の平方根は、それぞれ0と1を返します。

ビット演算を使用して算術テストを実装する方法はいくつかあります。あなたの表現：

• x == 0 || x == 1

論理的にこれらのそれぞれと同等です：

• (x & 1) == x
• (x & ~1) == 0
• (x | 1) == 1
• (~x | 1) == (uint)-1
• x >> 1 == 0

ボーナス：

• x * x == x （証明には少し労力がかかります）

しかし実際には、これらの形式が最も読みやすく、パフォーマンスのわずかな違いはビット演算を使用する価値がありません。

• x == 0 || x == 1
• x <= 1 （なぜなら xは符号なし整数である）
• x < 2（xは符号なし整数であるため）

引数はuint（unsigned）なので、

  return (N <= 1) ? 1 : N * fibn(N-1);

読みにくい（IMHO）が、各文字を数える場合（コードゴルフなど）

  return N < 2 ? 1 : N * fibn(N-1);

編集：編集した質問の場合：

  return (N <= 1) ? 1 : fibn(N-1) + fibn(N-2);

または

  return N < 2 ? 1 : fibn(N-1) + fibn(N-2);

他のすべてのビットが次のように0であることも確認できます。

return (N & ~1) == 0 ? 1 : N * fibn(N-1);

マットのおかげで完全を期すために、さらに優れたソリューション：

return (N | 1) == 1 ? 1 : N * fibn(N-1);

どちらの場合も、ビット単位の演算子の優先度はよりも低いため、かっこに注意する必要があります==。

関数をより効率的にしたい場合は、ルックアップテーブルを使用します。ルックアップテーブルは驚くほど小さく、47エントリしかありません。次のエントリは32ビットの符号なし整数でオーバーフローします。もちろん、関数の記述も簡単です。

class Sequences
{
    // Store the complete list of values that will fit in a 32-bit unsigned integer without overflow.
    private static readonly uint[] FibonacciSequence = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,
        233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418,
        317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169,
        63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073
    };

    public uint fibn(uint N)
    {
        return FibonacciSequence[N];
    }
}

明らかに階乗に対しても同じことができます。

ビットシフトでそれを行う方法

ビットシフトを使用してコードをややあいまいに（ただし短く）したい場合は、次のようにします。

public uint fibn ( uint N ) {
   return N >> 1 != 0? fibn(N-1) + finb(N-2): 1;
}

N言語cの符号なし整数の場合N>>1、下位ビットを破棄します。その結果がゼロ以外の場合は、Nが1より大きいことを意味します。

注：このアルゴリズムは、すでに計算されたシーケンスの値を不必要に再計算するため、ひどく非効率的です。

何か速い方法

暗黙的にfibonaci（N）サイズのツリーを構築するのではなく、1パスで計算します。

uint faster_fibn(uint N) { //requires N > 1 to work
  uint a = 1, b = 1, c = 1;
  while(--N != 0) {
    c = b + a;
    a = b;
    b = c;
  }
  return c;
}

一部の人々が述べたように、64ビットの符号なし整数であってもオーバーフローするのに時間がかかりません。移動しようとしている大きさに応じて、任意の精度の整数を使用する必要があります。

負にならないuintを使用しているので、 n < 2

編集

または、その特別な関数の場合、次のように書くことができます。

public uint fibn(uint N)
    return (N == 0) ? 1 : N * fibn(N-1);
}

もちろん、同じ結果が得られますが、追加の再帰ステップが必要になります。

かどうかを確認するために、単純にチェックしN、あなたがNのみという2つの条件があることができ、符号なしである知っているので、<= 1でN <= 1のその結果TRUE、0と1：

public uint fibn ( uint N ) 
{
   return (N <= 1) ? 1 : fibn(N-1) + finb(N-2);
}

免責事項：私はC＃を知りません、そしてこのコードをテストしませんでした：

しかし、[...]を1つの比較に変更することで、これをさらにコンパクトで効率的にできるかどうか疑問に思っています...

ビットシフトなどは必要ありません。これは比較を1つだけ使用し、はるかに効率的です（O（n）対O（2 ^ n）だと思いますか？）。関数の本体はよりコンパクトですが、宣言により少し長くなっています。

（再帰からオーバーヘッドを取り除くために、マシューガンの答えのように、反復バージョンがあります）

public uint fibn ( uint N, uint B=1, uint A=0 ) 
{
    return N == 0 ? A : fibn( N--, A+B, B );
}

                     fibn( 5 ) =
                     fibn( 5,   1,   0 ) =
return 5  == 0 ? 0 : fibn( 5--, 0+1, 1 ) =
                     fibn( 4,   1,   1 ) =
return 4  == 0 ? 1 : fibn( 4--, 1+1, 1 ) =
                     fibn( 3,   2,   1 ) =
return 3  == 0 ? 1 : fibn( 3--, 1+2, 2 ) =
                     fibn( 2,   3,   2 ) =
return 2  == 0 ? 2 : fibn( 2--, 2+3, 3 ) =
                     fibn( 1,   5,   3 ) =
return 1  == 0 ? 3 : fibn( 1--, 3+5, 5 ) =
                     fibn( 0,   8,   5 ) =
return 0  == 0 ? 5 : fibn( 0--, 5+8, 8 ) =
                 5
fibn(5)=5

PS：これは、アキュムレータを使用した反復の一般的な機能パターンです。と置き換えるN--と、N-1効果的にミューテーションを使用していないため、純粋な機能的アプローチで使用できます。

これが私の解決策です。この単純な関数を最適化することはあまりありませんが、ここで提供しているのは、再帰関数の数学的定義としての読みやすさです。

public uint fibn(uint N) 
{
    switch(N)
    {
        case  0: return 1;

        case  1: return 1;

        default: return fibn(N-1) + fibn(N-2);
    }
}

同様の方法でフィボナッチ数の数学的定義。

さらに切り替えて、検索テーブルを構築するように強制します。

public uint fibn(uint N) 
{
    switch(N)
    {
        case  0: return 1;
        case  1: return 1;
        case  2: return 2;
        case  3: return 3;
        case  4: return 5;
        case  5: return 8;
        case  6: return 13;
        case  7: return 21;
        case  8: return 34;
        case  9: return 55;
        case 10: return 89;
        case 11: return 144;
        case 12: return 233;
        case 13: return 377;
        case 14: return 610;
        case 15: return 987;
        case 16: return 1597;
        case 17: return 2584;
        case 18: return 4181;
        case 19: return 6765;
        case 20: return 10946;
        case 21: return 17711;
        case 22: return 28657;
        case 23: return 46368;
        case 24: return 75025;
        case 25: return 121393;
        case 26: return 196418;
        case 27: return 317811;
        case 28: return 514229;
        case 29: return 832040;
        case 30: return 1346269;
        case 31: return 2178309;
        case 32: return 3524578;
        case 33: return 5702887;
        case 34: return 9227465;
        case 35: return 14930352;
        case 36: return 24157817;
        case 37: return 39088169;
        case 38: return 63245986;
        case 39: return 102334155;
        case 40: return 165580141;
        case 41: return 267914296;
        case 42: return 433494437;
        case 43: return 701408733;
        case 44: return 1134903170;
        case 45: return 1836311903;
        case 46: return 2971215073;

        default: return fibn(N-1) + fibn(N-2);
    }
}

Nはuintなので、使用するだけです

N <= 1

Dmitryの答えが最善ですが、それがInt32戻り型であり、より大きな整数のセットから選択する場合は、これを行うことができます。

return new List<int>() { -1, 0, 1, 2 }.Contains(N) ? 1 : N * fibn(N-1);

フィボナッチ数列は一連の数であり、その前に2つの数を足すことで数が見つかります。開始点には、（0,1、1,2、..）と（1,1、2,3）の2つのタイプがあります。

-----------------------------------------
Position(N)| Value type 1 | Value type 2
-----------------------------------------  
1          |  0           |   1
2          |  1           |   1
3          |  1           |   2
4          |  2           |   3
5          |  3           |   5
6          |  5           |   8
7          |  8           |   13
-----------------------------------------

Nこの場合の位置はから始まり、配列のインデックス1ではありません0-based。

使用してC＃6式ボディ機能を約ドミトリーの提案三項演算子は、我々はタイプ1のための正しい計算と一行関数を書くことができます。

public uint fibn(uint N) => N<3? N-1: fibn(N-1)+fibn(N-2);

タイプ2の場合：

public uint fibn(uint N) => N<3? 1: fibn(N-1)+fibn(N-2);

パーティーに少し遅れましたが、あなたも行うことができます (x==!!x)

!!xaがで1ない場合はに値を変換し、0そうである0場合はそのままにします。
私はこのようなものをCの難読化でよく使用します。

注：これはCですが、C＃で機能するかどうかはわかりません

だから私Listはこれらの特別な整数を作成し、Nそれに関連するかどうかを確認しました。

static List<uint> ints = new List<uint> { 0, 1 };

public uint fibn(uint N) 
{
   return ints.Contains(N) ? 1 : fibn(N-1) + fibn(N-2);
}

がContains1回だけ呼び出されるさまざまな目的で拡張メソッドを使用することもできます（アプリケーションが起動してデータをロードするときなど）。これにより、より明確なスタイルが提供され、値（N）との主な関係が明確になります。

static class ObjectHelper
{
    public static bool PertainsTo<T>(this T obj, IEnumerable<T> enumerable)
    {
        return (enumerable is List<T> ? (List<T>) enumerable : enumerable.ToList()).Contains(obj);
    }
}

それを適用する：

N.PertainsTo(ints)

これは最速の方法ではないかもしれませんが、私には、より良いスタイルのように見えます。