C에서 내포 된 루트 계산

재귀 만 사용하여 다음 중첩 루트 식을 계산하라는 요청을 받았습니다 .

나는 아래 코드를 작성했지만 효과가 있었기 때문에 하나의 함수 와 하나의 입력 만 사용n 하고 2는 사용하지 않았습니다. 누군가이 코드를 표현식을 계산하는 하나의 함수로 변환하도록 도울 수 있습니까? 의 함수를 제외한 모든 라이브러리를 사용할 수 없습니다 <math.h>.

n = 10에 대한 출력 : 1.757932

double rec_sqrt_series(int n, int m) {
    if (n <= 0)
        return 0;
    if (m > n)
        return 0;
    return sqrt(m + rec_sqrt_series(n, m + 1));
}

double helper(int n) {
    return rec_sqrt_series(n, 1);
}

의 상위 비트를 n카운터로 사용하십시오 .

double rec_sqrt_series(int n)
{
    static const int R = 0x10000;
    return n/R < n%R ? sqrt(n/R+1 + rec_sqrt_series(n+R)) : 0;
}

당연히, 초기 n값 R이상일 때 오작동합니다 . 다음은 양수 값으로 작동하는보다 복잡한 버전입니다 n. 효과가있다:

• 경우 n제외, 그것은 계산하는 상위 비트를 이용하여, 상기 버전과 같이 작동한다.
• 때 n양수가보다 작은 경우, R그것은 자신을 호출 -n위와 같이 함수를 계산. 그렇지 않으면 R-1부정으로 스스로를 호출합니다 . 이 함수는로 호출 된 것처럼 함수를 평가합니다 R-1. 수십 번의 반복 후에 계열이 부동 소수점 형식으로 변경되는 것을 멈추기 때문에 올바른 결과를 얻을 수 있습니다. 더 깊은 숫자의 제곱근은 희석되어 효과가 없습니다. 따라서 함수는 n작은 임계 값 전체에서 동일한 값을 갖 습니다.

double rec_sqrt_series(int n)
{
    static const int R = 0x100;
    return
        0 < n ? n < R ? rec_sqrt_series(-n) : rec_sqrt_series(1-R)
              : n/R > n%R ? sqrt(-n/R+1 + rec_sqrt_series(n-R)) : 0;
}

수학적으로 수식을 변환하지 않으면 (가능한지 모르겠습니다) 각 요소에 대해 현재 단계와 원래의 두 가지 정보가 필요한 것과 같이 하나의 매개 변수 만 사용할 수는 없습니다 n. 그러나 당신은 속일 수 있습니다 . 한 가지 방법은 int매개 변수 에서 두 숫자를 인코딩하는 것입니다 ( Eric에서 표시 ).

또 다른 방법은 원본 n을 정적 로컬 변수에 저장하는 것 입니다. 첫 번째 호출 n에서이 정적 변수를 저장 하면 재귀가 시작되고 마지막 단계 에서이 값을 센티넬 값으로 재설정합니다.

// fn(i) = sqrt(n + 1 - i + fn(i - 1))
// fn(1) = sqrt(n)
//
// note: has global state
double f(int i)
{
    static const int sentinel = -1;
    static int n = sentinel;

    // outside call
    if (n == sentinel)
    {
        n = i;
        return f(n);
    }

    // last step
    if (i == 1)
    {
        double r = sqrt(n);
        n = sentinel;
        return r;
    }

    return sqrt(n + 1 - i + f(i - 1));
}

static int n = sentinelC sentinel의 컴파일 시간 상수가 아니기 때문에 분명히 표준 C 가 아닙니다 (gcc와 clang이 모두조차도 불평하지 않기 때문에 이상합니다 -pedantic)

대신이 작업을 수행 할 수 있습니다.

enum Special { Sentinel = -1 };
static int n = Sentinel;

이 문제는 뒤틀린 솔루션을 요구합니다.

다음은 하나 또는 두 개의 int인수를 취하는 단일 함수를 사용하는 것입니다 .

• 첫 번째 인수가 양수이면 해당 값에 대한 표현식을 계산합니다.
• 첫 번째 인수가 음수이면 두 번째 인수가 와야하며 계산에서 이전 단계에서 되풀이되는 단일 단계를 수행해야합니다.
• 그것은 사용 <stdarg.h>하는이 수도 있고 허용되지 않을 수 있습니다.

코드는 다음과 같습니다.

#include <math.h>
#include <stdarg.h>

double rec_sqrt_series(int n, ...) {
    if (n < 0) {
        va_arg ap;
        va_start(ap, n);
        int m = va_arg(ap, int);
        va_end(ap);
        if (m > -n) {
            return 0.0;
        } else {
            return sqrt(m + rec_sqrt_series(n, m + 1));
        }
    } else {
        return rec_sqrt_series(-n, 1);
    }
}

다음은 단일 기능을 사용 <math.h>하지만 매크로를 사용하는 다른 방법으로 규칙을 남용하는 또 다른 솔루션입니다 .

#include <math.h>

#define rec_sqrt_series(n)  (rec_sqrt_series)(n, 1)
double (rec_sqrt_series)(int n, int m) {
    if (m > n) {
        return 0.0;
    } else {
        return sqrt(m + (rec_sqrt_series)(n, m + 1));
    }
}

또 다른 하나는 엄격하게 재귀 적이 지만 단일 재귀 수준과 다른 트릭은 없습니다. Eric이 언급 했듯이 forOP의 제약 조건에서는 유효하지 않은 루프를 사용합니다 .

double rec_sqrt_series(int n) {
    if (n > 0) {
        return rec_sqrt_series(-n);
    } else {
        double x = 0.0;
        for (int i = -n; i > 0; i--) {
            x = sqrt(i + x);
        }
        return x;
    }
}

다른 접근법이 있습니다.

그것은 int32 비트 에 의존합니다 . 아이디어는 64 비트의 상위 32 비트를 사용하는 것이다 int에

1) 통화가 재귀 통화인지 (또는 "외부"통화)

2) 재귀 중 상위 32 비트에 목표 값을 저장하십시오

// Calling convention:
// when calling this function 'n' must be a positive 32 bit integer value
// If 'n' is zero or less than zero the function have undefined behavior
double rec_sqrt_series(uint64_t n)
{
  if ((n >> 32) == 0)
  {
    // Not called by a recursive call
    // so start the recursion
    return rec_sqrt_series((n << 32) + 1);
  }

  // Called by a recursive call

  uint64_t rn = n & 0xffffffffU;

  if (rn == (n >> 32)) return sqrt(rn);      // Done - target reached

  return sqrt (rn + rec_sqrt_series(n+1));   // Do the recursive call
}