เป็นไปได้ไหมที่จะลดความซับซ้อน (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( ไม่ได้ลงชื่อ ) คุณสามารถใส่

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

อ่านได้น้อยลง (IMHO) แต่ถ้าคุณนับอักขระแต่ละตัว ( Code Golfหรือเหมือนกัน)

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

เพื่อความสมบูรณ์ขอบคุณMattทางออกที่ดียิ่งขึ้น:

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

เห็นได้ชัดว่าคุณสามารถทำสิ่งเดียวกันสำหรับแฟกทอเรียลได้

วิธีทำด้วย bitshift

หากคุณต้องการใช้ bitshift และทำให้โค้ดค่อนข้างคลุมเครือ (แต่สั้น) คุณสามารถทำได้:

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

สำหรับจำนวนเต็มที่ไม่ได้ลงชื่อNในภาษา c ให้N>>1ปิดบิตลำดับต่ำ ถ้าผลลัพธ์นั้นไม่ใช่ศูนย์แสดงว่า N มีค่ามากกว่า 1

หมายเหตุ: อัลกอริทึมนี้ไม่มีประสิทธิภาพอย่างมากเนื่องจากคำนวณค่าใหม่ในลำดับที่คำนวณแล้วโดยไม่จำเป็น

วิธีที่เร็วกว่า

คำนวณหนึ่งรอบแทนที่จะสร้างต้นไม้ขนาด 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;
}

ดังที่บางคนกล่าวถึงการล้นออกมาใช้เวลาไม่นานแม้แต่จำนวนเต็ม 64 บิตที่ไม่ได้ลงชื่อ ขึ้นอยู่กับว่าคุณพยายามไปมากแค่ไหนคุณจะต้องใช้จำนวนเต็มที่มีความแม่นยำโดยพลการ

เมื่อคุณใช้ uint ซึ่งไม่สามารถติดลบได้คุณสามารถตรวจสอบได้ว่า n < 2

แก้ไข

หรือสำหรับกรณีฟังก์ชันพิเศษนั้นคุณสามารถเขียนได้ดังนี้:

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

ซึ่งจะนำไปสู่ผลลัพธ์เดียวกันแน่นอนโดยมีค่าใช้จ่ายของขั้นตอนการเรียกซ้ำเพิ่มเติม

เพียงตรวจสอบเพื่อดูว่าNเป็น <= 1 หรือไม่เนื่องจากคุณทราบว่า N ไม่ได้ลงนามมีเพียง 2 เงื่อนไขN <= 1ที่ส่งผลให้TRUE: 0 และ 1

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

ข้อจำกัดความรับผิดชอบ: ฉันไม่รู้ C # และไม่ได้ทดสอบรหัสนี้:

แต่ฉันสงสัยว่าฉันสามารถทำให้สิ่งนี้กะทัดรัดและมีประสิทธิภาพมากขึ้นได้หรือไม่โดยการเปลี่ยน [... ] เป็นการเปรียบเทียบเพียงครั้งเดียว ...

ไม่จำเป็นต้องมีการขยับบิตหรือสิ่งนี้ใช้การเปรียบเทียบเพียงครั้งเดียวและมันควรจะมีประสิทธิภาพมากกว่านี้(O (n) เทียบกับ O (2 ^ n) ฉันคิดว่า?) เนื้อความของฟังก์ชั่นมีขนาดกะทัดรัดมากขึ้นแม้ว่าจะใช้เวลานานขึ้นเล็กน้อยด้วยการประกาศ

(ในการลบค่าใช้จ่ายออกจากการเรียกซ้ำมีเวอร์ชันซ้ำเช่นเดียวกับในคำตอบของ 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: นี่เป็นรูปแบบการทำงานทั่วไปสำหรับการวนซ้ำด้วยตัวสะสม หากคุณแทนที่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);
    }
}

นิยามทางคณิตศาสตร์ของ Fibonacci number ในทำนองเดียวกัน ..

ดำเนินการต่อไปเพื่อบังคับให้สวิตช์เคสสร้างตารางการค้นหา

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

ลำดับฟีโบนักชีคือชุดของตัวเลขที่พบตัวเลขโดยการบวกตัวเลขสองตัวไว้ข้างหน้า จุดเริ่มต้นมีสองประเภท: ( 0,1 , 1,2, .. ) และ ( 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
-----------------------------------------

ตำแหน่งNในกรณีนี้เริ่มจาก1ไม่ใช่0-basedดัชนีอาร์เรย์

การใช้คุณลักษณะ C # 6 Expression-bodyและข้อเสนอแนะของ Dmitry เกี่ยวกับตัวดำเนินการ ternaryเราสามารถเขียนฟังก์ชันหนึ่งบรรทัดพร้อมการคำนวณที่ถูกต้องสำหรับประเภท 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)

!!xแปลงค่าเป็น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);
}

คุณยังสามารถใช้วิธีการขยายเพื่อจุดประสงค์ต่างๆที่Containsเรียกเพียงครั้งเดียว (เช่นเมื่อแอปพลิเคชันของคุณเริ่มต้นและกำลังโหลดข้อมูล) สิ่งนี้ให้รูปแบบที่ชัดเจนขึ้นและชี้แจงความสัมพันธ์หลักกับค่าของคุณ ( 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)

นี่อาจไม่ใช่วิธีที่เร็วที่สุด แต่สำหรับฉันแล้วดูเหมือนว่าจะเป็นรูปแบบที่ดีกว่า