Apakah mungkin untuk menyederhanakan (x == 0 || x == 1) menjadi satu operasi?

Jadi saya mencoba menulis angka ke- n dalam deret Fibonacci dalam fungsi sesingkat mungkin:

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

Tapi saya bertanya-tanya apakah saya bisa membuat ini lebih ringkas dan efisien dengan mengubahnya

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

menjadi satu perbandingan. Apakah ada operasi bit shift yang bagus yang dapat melakukan ini?

Yang ini juga berfungsi

Math.Sqrt(N) == N 

akar kuadrat dari 0 dan 1 akan mengembalikan 0 dan 1 masing-masing.

Ada beberapa cara untuk menerapkan tes aritmatika Anda menggunakan aritmatika bitwise. Ekspresi Anda:

• x == 0 || x == 1

secara logis setara dengan masing-masing berikut ini:

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

Bonus:

• x * x == x (buktinya membutuhkan sedikit usaha)

Tetapi secara praktis, formulir ini adalah yang paling mudah dibaca, dan perbedaan kecil dalam performa tidak terlalu berguna jika menggunakan aritmatika bitwise:

• x == 0 || x == 1
• x <= 1(karena xadalah bilangan bulat yang tidak bertanda tangan)
• x < 2(karena xadalah bilangan bulat yang tidak bertanda tangan)

Karena argumen adalah uint( unsigned ), Anda dapat meletakkannya

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

Kurang terbaca (IMHO) tetapi jika Anda menghitung setiap karakter ( Code Golf atau sejenisnya)

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

Edit : untuk pertanyaan yang Anda edit :

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

Atau

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

Anda juga dapat memeriksa bahwa semua bit lainnya adalah 0 seperti ini:

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

Untuk kelengkapan, terima kasih kepada Matt , solusi yang lebih baik:

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

Dalam kedua kasus, Anda perlu menggunakan tanda kurung karena operator bitwise memiliki prioritas lebih rendah daripada ==.

Jika yang ingin Anda lakukan adalah membuat fungsi lebih efisien, gunakan tabel pencarian. Tabel pemeta ternyata sangat kecil, hanya 47 entri - entri berikutnya akan meluap bilangan bulat 32-bit yang tidak ditandatangani. Itu juga tentu saja membuat fungsi menulis menjadi sepele.

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

Anda jelas dapat melakukan hal yang sama untuk faktorial.

Bagaimana melakukannya dengan bitshift

Jika Anda ingin menggunakan bitshift dan membuat kodenya tidak jelas (tetapi singkat), Anda dapat melakukan:

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

Untuk integer unsigned Ndalam bahasa c,N>>1 membuang bit orde rendah. Jika hasilnya bukan nol, ini berarti N lebih besar dari 1.

Catatan: algoritma ini sangat tidak efisien karena tidak perlu menghitung ulang nilai dalam urutan yang telah dihitung.

Sesuatu JAUH lebih cepat

Hitunglah satu kali lintasan daripada secara implisit membangun pohon berukuran fibonaci (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;
}

Seperti yang telah disebutkan beberapa orang, tidak butuh waktu lama untuk meluap bahkan 64 bit unsigned integer. Bergantung pada seberapa besar Anda mencoba pergi, Anda harus menggunakan bilangan bulat presisi arbitrer.

Saat Anda menggunakan uint, yang tidak bisa negatif, Anda dapat memeriksa apakah n < 2

EDIT

Atau untuk kasus fungsi khusus itu Anda dapat menuliskannya sebagai berikut:

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

yang akan memberikan hasil yang sama, tentu saja dengan biaya langkah rekursi tambahan.

Cukup periksa untuk melihat apakah N<= 1 karena Anda tahu N tidak bertanda tangan, hanya ada 2 kondisi N <= 1yang menghasilkan TRUE: 0 dan 1

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

Penafian: Saya tidak tahu C #, dan tidak menguji kode ini:

Tapi saya bertanya-tanya apakah saya bisa membuat ini lebih ringkas dan efisien dengan mengubah [...] menjadi satu perbandingan ...

Tidak perlu bitshifting atau semacamnya, ini hanya menggunakan satu perbandingan, dan seharusnya jauh lebih efisien (O (n) vs O (2 ^ n) menurut saya?). Badan fungsinya lebih kompak , meskipun berakhir menjadi sedikit lebih lama dengan deklarasi.

(Untuk menghilangkan overhead dari rekursi, ada versi iteratif, seperti dalam jawaban Mathew Gunn )

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: Ini adalah pola fungsional umum untuk iterasi dengan akumulator. Jika Anda mengganti N--dengan N-1Anda secara efektif tidak menggunakan mutasi, yang membuatnya dapat digunakan dalam pendekatan fungsional murni.

Inilah solusi saya, tidak banyak yang bisa mengoptimalkan fungsi sederhana ini, sebaliknya yang saya tawarkan di sini adalah keterbacaan sebagai definisi matematis dari fungsi rekursif.

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

        case  1: return 1;

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

Definisi matematis dari bilangan Fibonacci dengan cara yang sama ..

Mengambil lebih jauh untuk memaksa switch case untuk membangun tabel pencarian.

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

untuk N adalah uint, gunakan saja

N <= 1

Jawaban Dmitry adalah yang terbaik tetapi jika itu adalah tipe pengembalian Int32 dan Anda memiliki kumpulan bilangan bulat yang lebih besar untuk dipilih, Anda dapat melakukan ini.

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

Deret Fibonacci adalah rangkaian angka di mana sebuah angka ditemukan dengan menjumlahkan dua angka sebelumnya. Ada dua jenis titik awal: ( 0,1 , 1,2, ..) dan ( 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
-----------------------------------------

Posisi Ndalam kasus ini dimulai dari 1, bukan0-based sebagai indeks array.

Dengan menggunakan fitur tubuh ekspresi C # 6 dan saran Dmitry tentang operator terner kita dapat menulis fungsi satu baris dengan perhitungan yang benar untuk tipe 1:

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

dan untuk tipe 2:

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

Agak terlambat ke pesta, tetapi Anda juga bisa melakukannya (x==!!x)

!!xmengonversi nilai menjadi 1jika tidak 0, dan membiarkannya 0jika memang demikian.
Saya sering menggunakan hal semacam ini dalam kebingungan C.

Catatan: Ini C, tidak yakin apakah itu berfungsi di C #

Jadi saya membuat Listbilangan bulat khusus ini dan memeriksa apakah Nberkaitan dengannya.

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

Anda juga dapat menggunakan metode ekstensi untuk tujuan berbeda di mana Containshanya dipanggil sekali (misalnya, saat aplikasi Anda mulai dan memuat data). Ini memberikan gaya yang lebih jelas dan menjelaskan hubungan utama dengan nilai Anda ( 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);
    }
}

Terapkan itu:

N.PertainsTo(ints)

Ini mungkin bukan cara tercepat untuk melakukannya, tetapi bagi saya, ini tampaknya gaya yang lebih baik.