การคำนวณรูตที่ซ้อนใน C

ฉันถูกขอให้คำนวณนิพจน์รูทที่ซ้อนกันต่อไปนี้โดยใช้การเรียกซ้ำเท่านั้น

ฉันเขียนโค้ดด้านล่างที่ใช้งานได้ แต่พวกเขาอนุญาตให้เราใช้เพียงฟังก์ชั่นเดียวและ 1 อินพุต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ในตัวแปรสแตติกนี้เราจะเริ่มต้นการสอบถามซ้ำและในขั้นตอนสุดท้ายเรารีเซ็ตเป็นค่า Sentinel:

// 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 = sentinelว่าไม่ได้มาตรฐาน C เพราะsentinelไม่ใช่ค่าคงที่เวลารวบรวมใน C (มันแปลกเพราะทั้ง gcc และเสียงดังกราวไม่บ่นแม้แต่กับ-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));
    }
}

อีกคนหนึ่งพูดซ้ำอย่างเคร่งครัดแต่ด้วยระดับการเรียกซ้ำเดียวและไม่มีลูกเล่นอื่น ตามที่เอริคแสดงความคิดเห็นมันใช้forลูปซึ่งอาจไม่ถูกต้องภายใต้ข้อ จำกัด ของ OP:

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

นี่คือวิธีการอื่น

มันขึ้นอยู่กับintการเป็น 32 บิต แนวคิดคือการใช้ 32 บิตบนของ 64 บิต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
}