递归求根平方和

Question

I am trying to recursively find the root squared sum of two arrays. Basically given:

array1 = {1,5,8};
array2 = {2,9,10};
RSS = sqrt((1-2)^2 + (2-5)^2 + (3-8)^2) = 4.58258

I have implemented the following code, but after testing I know that it does not work. I am returning the square root each time, so my RSS value is lower than it should be.

double findRSS(int* array1, int* array2, int size){
    double sum = 0;
    if (size <= 0){
        return 0;   }
    else{
        sum = pow((array1[size-1] - array2[size-1]), 2);
        sum = sum + findRSS(array1, array2, size-1);
    }
    return sqrt(sum);
}

For the above example I am returning 2.85011 instead.

I feel I am close but just have a small issue. Can someone help me out?

Answer 1

You are calculating sqrt((1-2)^2 + sqrt((2-5)^2 + sqrt((3-8)^2))) you can do somewhat simple "fix" to your logic by squaring recursed result once

double findRSS(int* array1, int* array2, int size){
    double sum = 0;
    if (size <= 0){
        return 0;   }
    else{
        sum = pow((array1[size-1] - array2[size-1]), 2);
        sum = sum + pow(findRSS(array1, array2, size-1), 2); // you are undoing sqrt for new one
    }
    return sqrt(sum);
}

but as you can see the method is flawed. This is a good example of why structured development is important. You can find principles developers found that aged well here: http://www.catb.org/~esr/writings/taoup/html/ch01s06.html

so your methods would become something like this:

double diffSum(int* array1, int* array2, int size, int power) {
    double sum = 0;
    if (size <= 0) {
        return 0;
    }
    else {
        sum = pow((array1[size - 1] - array2[size - 1]), power);
        sum = sum + diffSum(array1, array2, size - 1, power);
    }
    return sum;
}

double findRSS(int* array1, int* array2, int size) {
    return sqrt(diffSum(array1, array2, size, 2));
}

key to success is when to know you need to separate; beware keeping methods with fewer lines helps on maintaining the code

Answer 2

This does what you want:

double findRSS(int* array1, int* array2, int size){
    double sum = 0;
    if (size <= 0){
        return 0;   }
    else{
        sum = pow((array1[size-1] - array2[size-1]), 2);
        sum = sum + pow(findRSS(array1, array2, size-1), 2);
    }
    return sqrt(sum);
}

Write out the math by hand to verify that it is correct.

But please don't write actual programs this way. Not only is this a needlessly convoluted way to write a trivial loop, it is also horribly inefficient to take a square root at every iteration/recursion just to immediately undo it at the next. Even for the simple version below, the single square root at the end will take longer than everything else together:

double findRSS(int* array1, int* array2)
{
  double sum = 0;
  for (int i = 0; i < size; ++i)
    sum += std::pow(arra1[i] - array2[i], 2);
  return std::sqrt(sum);
}

Answer 3

I mean this way:

int findRSS(int *arr1, int *arr2, int size)
{
    if (size == 0)
        return 0;
    return (int)pow(arr1[size - 1] - arr2[size - 1], 2) + findRSS(arr1, arr2, size - 1);
}

int main()
{
    int arr1[] = { 1, 5, 8 };
    int arr2[] = { 2, 9, 10 };
    cout << sqrt(findRSS(arr1, arr2, 3)) << endl;
}