(X == 0 || x == 1) tek bir işlemde sadeleştirmek mümkün mü?

Ben yazmaya çalışıyordum Yani n mümkün olduğunca kompakt bir fonksiyonu olarak Fibonacci dizisindeki inci numarayı:

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

Ancak bunu değiştirerek bunu daha kompakt ve verimli hale getirebilir miyim?

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

tek bir karşılaştırmaya. Bunu yapabilen bazı süslü bit kaydırma işlemi var mı?

Bu da çalışıyor

Math.Sqrt(N) == N 

0 ve 1'in karekökü sırasıyla 0 ve 1'i döndürür.

Bitsel aritmetik kullanarak aritmetik testinizi uygulamanın birçok yolu vardır. İfadeniz:

• x == 0 || x == 1

mantıksal olarak şunların her birine eşdeğerdir:

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

Bonus:

• x * x == x (kanıt biraz çaba gerektirir)

Ancak pratik olarak konuşursak, bu formlar en okunabilir olanlardır ve performanstaki küçük fark, bit tabanlı aritmetiği kullanmaya gerçekten değmez:

• x == 0 || x == 1
• x <= 1(çünkü xişaretsiz bir tamsayıdır)
• x < 2(çünkü xişaretsiz bir tamsayıdır)

Bağımsız değişken uint( işaretsiz ) olduğundan

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

Daha az okunabilir (IMHO) ancak her karakteri sayarsanız ( Kod Golf veya benzeri)

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

Düzenle : düzenlenmiş sorunuz için :

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

Veya

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

Ayrıca diğer tüm bitlerin şu şekilde 0 olup olmadığını da kontrol edebilirsiniz:

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

Matt sayesinde eksiksizlik için daha da iyi çözüm:

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

Her iki durumda da paranteze dikkat etmeniz gerekir çünkü bitsel operatörler bundan daha düşük önceliğe sahiptir ==.

Yapmak istediğiniz, işlevi daha verimli hale getirmekse, bir arama tablosu kullanın. Arama tablosu sadece 47 girişle şaşırtıcı derecede küçüktür - sonraki giriş 32 bitlik işaretsiz bir tamsayıyı aşacaktır. Elbette bu işlevi yazmak için önemsiz hale getirir.

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

Açıkça aynı şeyi faktoriyeller için de yapabilirsiniz.

Bitshift ile nasıl yapılır

Bitshift'i kullanmak ve kodu biraz belirsiz (ancak kısa) yapmak istiyorsanız, şunları yapabilirsiniz:

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

NC dilinde işaretsiz bir tamsayı için,N>>1 için, düşük dereceli biti fırlatır. Bu sonuç sıfır değilse, N'nin 1'den büyük olduğu anlamına gelir.

Not: Bu algoritma, halihazırda hesaplanmış olan sıradaki değerleri gereksiz yere yeniden hesapladığı için korkunç derecede verimsizdir.

ÇOK HIZLI bir şey

Örtülü olarak fibonaci (N) büyüklüğünde bir ağaç oluşturmak yerine bunu bir geçişte hesaplayın:

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

Bazılarının da bahsettiği gibi, 64 bitlik işaretsiz bir tamsayının bile taşması uzun sürmez. Ne kadar büyük olmaya çalıştığınıza bağlı olarak, keyfi hassas tamsayılar kullanmanız gerekecek.

Negatif olamayan bir uint kullandığınızda, aşağıdakileri kontrol edebilirsiniz: n < 2

DÜZENLE

Veya bu özel işlev durumu için aşağıdaki gibi yazabilirsiniz:

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

Bu, elbette ek bir özyineleme adımı pahasına aynı sonuca götürür.

NN'nin işaretsiz olduğunu bildiğiniz için <= 1 olup olmadığını kontrol edin : 0 ve 1 ile N <= 1sonuçlanan yalnızca 2 koşul olabilirTRUE

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

Sorumluluk reddi: C # bilmiyorum ve şu kodu test etmedim:

Ama merak ediyorum, [...] 'yi tek bir karşılaştırmaya çevirerek bunu daha derli toplu ve verimli hale getirebilir miyim ...

Bit kaydırmaya ya da benzerine gerek yok, bu sadece bir karşılaştırma kullanıyor ve çok daha verimli olmalı (O (n) - O (2 ^ n) sanırım?). İşlevin gövdesi daha kompakttır , bildirimle biraz daha uzun olmasına rağmen .

(Özyinelemeden ek yükü kaldırmak için, Mathew Gunn'ın cevabında olduğu gibi yinelemeli sürüm var )

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

Not: Bu, akümülatörler ile yineleme için yaygın bir işlevsel modeldir. İle değiştirirseniz N--, N-1etkili bir şekilde mutasyon kullanmazsınız, bu da onu tamamen işlevsel bir yaklaşımla kullanılabilir kılar.

İşte benim çözümüm, bu basit işlevi optimize etmede pek bir şey yok, diğer yandan burada önerdiğim şey, yinelemeli işlevin matematiksel bir tanımı olarak okunabilirlik.

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

        case  1: return 1;

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

Fibonacci sayısının benzer şekilde matematiksel tanımı.

Anahtar durumunu bir arama tablosu oluşturmaya zorlamak için daha da ileri götürür.

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 için uint, sadece kullan

N <= 1

Dmitry'ın cevabı en iyisidir, ancak bu bir Int32 dönüş türü olsaydı ve aralarından seçim yapabileceğiniz daha büyük bir tam sayı kümeniz varsa bunu yapabilirsiniz.

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

Fibonacci dizisi, bir sayının kendisinden önceki iki sayıyı toplayarak bulunduğu bir sayı dizisidir. İki tür başlangıç ​​noktası vardır: ( 0,1 , 1,2, ..) ve ( 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
-----------------------------------------

Pozisyon Nbu durumda başlar 1değil mi,0-based bir dizi indeksi olarak .

Kullanımı C # 6 İfadesi vücut özelliğini ve yaklaşık Dmitry önerisi üçlü operatörü biz tip 1 için doğru hesaplama ile tek satır fonksiyon yazabiliriz:

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

ve tip 2 için:

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

Partiye biraz geç ama sen de yapabilirsin (x==!!x)

!!xa değerini 1değilse değerine dönüştürür ve öyleyse olarak 0bırakır 0.
Bu tür bir şeyi C gizlemede çok kullanıyorum.

Not: Bu C, C # ile çalışıp çalışmadığından emin değilim

Ben Listde bu özel tam sayılardan bir tane yarattım ve Nbununla ilgili olup olmadığını kontrol ettim.

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

ContainsYalnızca bir kez çağrılan farklı amaçlar için bir uzantı yöntemi de kullanabilirsiniz (örneğin, uygulamanız başlatılırken ve veri yüklerken). Bu, daha net bir stil sağlar ve değerinizle ( N) birincil ilişkiyi netleştirir :

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

Uygula:

N.PertainsTo(ints)

Bunu yapmanın en hızlı yolu bu olmayabilir ama bana göre daha iyi bir tarz gibi görünüyor.