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

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

팩토리얼에 대해서도 동일한 작업을 수행 할 수 있습니다.

비트 시프트로 수행하는 방법

비트 시프트를 사용하고 코드를 다소 모호하게 (짧게) 만들고 싶다면 다음과 같이 할 수 있습니다.

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

N언어 c 의 부호없는 정수 의 경우,N>>1 경우 하위 비트를 버립니다. 그 결과가 0이 아니면 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 비트 부호없는 정수도 오버플로하는 데 오래 걸리지 않습니다. 얼마나 큰지에 따라 임의의 정밀도 정수를 사용해야합니다.

음수가 될 수없는 단위를 사용하면 다음 사항을 확인할 수 있습니다. n < 2

편집하다

또는 특수한 기능의 경우 다음과 같이 작성할 수 있습니다.

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

물론 추가 재귀 단계의 비용으로 동일한 결과를 얻을 수 있습니다.

NN이 서명되지 않았 음을 알기 때문에 <= 1 인지 확인하기 만하면 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

추신 : 이것은 누산기 반복을위한 일반적인 기능 패턴입니다. 대체 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이 단위이기 때문에

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 표현 - 신체 기능을 약 드미트리의 제안 삼항 연산자는 우리는 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);
}

또한 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)

이것이 가장 빠른 방법은 아니지만 나에게는 더 나은 스타일 인 것 같습니다.