Ist es möglich, (x == 0 || x == 1) in einer einzigen Operation zu vereinfachen?

Also habe ich versucht, die n- te Zahl in der Fibonacci-Folge so kompakt wie möglich zu schreiben :

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

Aber ich frage mich, ob ich dies durch Ändern noch kompakter und effizienter machen kann

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

in einen einzigen Vergleich. Gibt es eine ausgefallene Bitverschiebungsoperation, die dies kann?

Dieser funktioniert auch

Math.Sqrt(N) == N 

Die Quadratwurzel von 0 und 1 gibt 0 bzw. 1 zurück.

Es gibt verschiedene Möglichkeiten, Ihren arithmetischen Test mit bitweiser Arithmetik zu implementieren. Dein Ausdruck:

• x == 0 || x == 1

ist logisch äquivalent zu jedem dieser:

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

Bonus:

• x * x == x (Der Beweis erfordert ein wenig Mühe)

In der Praxis sind diese Formen jedoch am besten lesbar, und der winzige Leistungsunterschied ist es nicht wirklich wert, bitweise zu rechnen:

• x == 0 || x == 1
• x <= 1(weil xeine vorzeichenlose Ganzzahl ist)
• x < 2(weil xeine vorzeichenlose Ganzzahl ist)

Da das Argument uint( ohne Vorzeichen ) ist, können Sie setzen

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

Weniger lesbar (IMHO), aber wenn Sie jeden Charakter zählen ( Code Golf oder ähnlich)

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

Bearbeiten : für Ihre bearbeitete Frage :

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

Oder

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

Sie können auch überprüfen, ob alle anderen Bits wie folgt 0 sind:

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

Der Vollständigkeit halber dank Matt die noch bessere Lösung:

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

In beiden Fällen müssen Sie sich um die Klammern kümmern, da bitweise Operatoren eine niedrigere Priorität als haben ==.

Wenn Sie die Funktion effizienter gestalten möchten, verwenden Sie eine Nachschlagetabelle. Die Nachschlagetabelle ist mit nur 47 Einträgen überraschend klein - der nächste Eintrag würde eine 32-Bit-Ganzzahl ohne Vorzeichen überlaufen. Es macht natürlich auch die Funktion trivial zu schreiben.

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];
    }
}

Sie können natürlich das Gleiche für Fakultäten tun.

Wie es mit Bitshift geht

Wenn Sie Bitshift verwenden und den Code etwas dunkel (aber kurz) machen möchten, können Sie Folgendes tun:

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

Bei einer vorzeichenlosen Ganzzahl Nin der Sprache c N>>1wird das Bit niedriger Ordnung weggeworfen. Wenn dieses Ergebnis ungleich Null ist, bedeutet dies, dass N größer als 1 ist.

Hinweis: Dieser Algorithmus ist schrecklich ineffizient, da er Werte in der bereits berechneten Sequenz unnötig neu berechnet.

Etwas viel schneller

Berechnen Sie es in einem Durchgang, anstatt implizit einen Fibonaci (N) -großen Baum zu bauen:

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;
}

Wie einige Leute bereits erwähnt haben, dauert es nicht lange, bis eine 64-Bit-Ganzzahl ohne Vorzeichen überläuft. Je nachdem, wie groß Sie werden möchten, müssen Sie Ganzzahlen mit beliebiger Genauigkeit verwenden.

Wenn Sie eine Uint verwenden, die nicht negativ werden kann, können Sie überprüfen, ob n < 2

BEARBEITEN

Oder für diesen speziellen Funktionsfall können Sie ihn wie folgt schreiben:

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

Dies führt natürlich zum gleichen Ergebnis auf Kosten eines zusätzlichen Rekursionsschritts.

Überprüfen Sie einfach, ob N<= 1 ist, da Sie wissen, dass N ohne Vorzeichen ist. Es kann nur 2 Bedingungen geben, N <= 1die zu folgenden Ergebnissen führen TRUE: 0 und 1

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

Haftungsausschluss: Ich kenne C # nicht und habe diesen Code nicht getestet:

Aber ich frage mich, ob ich dies noch kompakter und effizienter machen kann, indem ich [...] in einen einzigen Vergleich umwandle ...

Keine Notwendigkeit für Bit-Shifting oder ähnliches, dies verwendet nur einen Vergleich und es sollte viel effizienter sein (O (n) gegen O (2 ^ n), denke ich?). Der Hauptteil der Funktion ist kompakter , endet jedoch mit der Deklaration etwas länger.

(Um Overhead von der Rekursion zu entfernen, gibt es die iterative Version, wie in Mathew Gunns Antwort )

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: Dies ist ein gängiges Funktionsmuster für die Iteration mit Akkumulatoren. Wenn Sie ersetzen N--mit N-1Sie keine Mutation effektiv verwenden, die sie verwendbar in einem reinen funktionalen Ansatz macht.

Hier ist meine Lösung, es gibt nicht viel in der Optimierung dieser einfachen Funktion, andererseits biete ich hier Lesbarkeit als mathematische Definition der rekursiven Funktion an.

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

        case  1: return 1;

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

Die mathematische Definition der Fibonacci-Zahl in ähnlicher Weise.

Nehmen Sie es weiter, um das Switch-Gehäuse zum Erstellen einer Nachschlagetabelle zu zwingen.

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);
    }
}

für N ist uint, benutze einfach

N <= 1

Dmitrys Antwort ist am besten, aber wenn es sich um einen Int32-Rückgabetyp handelt und Sie einen größeren Satz von Ganzzahlen zur Auswahl haben, können Sie dies tun.

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

Die Fibonacci-Sequenz ist eine Reihe von Zahlen, bei denen eine Zahl gefunden wird, indem die beiden Zahlen davor addiert werden. Es gibt zwei Arten von Ausgangspunkten: ( 0,1 , 1,2, ..) und ( 1,1 , 2,3).

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

Die Position Nbeginnt in diesem Fall ab 1, sie ist kein 0-basedArray-Index.

Mit der C # 6-Expression-Body-Funktion und Dmitrys Vorschlag zum ternären Operator können wir eine einzeilige Funktion mit korrekter Berechnung für den Typ 1 schreiben:

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

und für den Typ 2:

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

Etwas spät zur Party, aber du könntest es auch tun (x==!!x)

!!xkonvertiert den a-Wert in, 1wenn dies nicht der Fall ist 0, und belässt ihn bei, 0wenn dies der Fall ist.
Ich benutze diese Art von Dingen oft in der C-Verschleierung.

Hinweis: Dies ist C, nicht sicher, ob es in C # funktioniert

Also habe ich eine Listdieser speziellen Ganzzahlen erstellt und geprüft, ob Nsie dazu gehört.

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);
}

Sie können auch eine Erweiterungsmethode für verschiedene Zwecke verwenden, Containsdie nur einmal aufgerufen wird (z. B. wenn Ihre Anwendung gestartet wird und Daten lädt). Dies bietet einen klareren Stil und verdeutlicht die primäre Beziehung zu Ihrem Wert ( 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);
    }
}

Wende es an:

N.PertainsTo(ints)

Dies ist vielleicht nicht der schnellste Weg, aber für mich scheint es ein besserer Stil zu sein.