Рекурсивно найти корень квадратной суммы - PullRequest
Новая
       10

Рекурсивно найти корень квадратной суммы

0 голосов
/ 23 октября 2019

Я пытаюсь рекурсивно найти корневую квадратную сумму двух массивов. В основном дано: 

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

Я реализовал следующий код, но после тестирования я знаю, что он не работает. Я возвращаю квадратный корень каждый раз, поэтому мое значение RSS ниже, чем должно быть. 

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

Для приведенного выше примера я возвращаю 2.85011 вместо этого.

Я чувствую, что я близко, но у меня небольшая проблема. Кто-нибудь может мне помочь?

Ответы [ 3 ]

2 голосов
/ 23 октября 2019

Вы вычисляете sqrt ((1-2) ^ 2 + sqrt ((2-5) ^ 2 + sqrt ((3-8) ^ 2))), вы можете сделать несколько простых «исправлений» в вашей логике с помощьювозведение в квадрат рекурсивного результата один раз 

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

, но, как вы можете видеть, метод имеет недостатки. Это хороший пример того, почему структурированная разработка важна. Вы можете найти принципы, найденные разработчиками, которые хорошо постарели, здесь: http://www.catb.org/~esr/writings/taoup/html/ch01s06.html

, поэтому ваши методы станут примерно такими: 

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

ключ к успеху - это когда вам нужно разойтись;Осторожно, методы хранения с меньшим количеством строк помогают поддерживать код

1 голос
/ 23 октября 2019

Это делает то, что вы хотите: 

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

Запишите математику от руки, чтобы убедиться в ее правильности.

Но, пожалуйста, не пишите реальные программы таким образом. Это не только излишне запутанный способ написания тривиального цикла, но также ужасно неэффективно брать квадратный корень на каждой итерации / рекурсии, чтобы просто отменить его на следующей. Даже для простой версии ниже, один квадратный корень в конце займет больше времени, чем все вместе взятые: 

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);
}
0 голосов
/ 23 октября 2019

Я имею в виду так: 

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