дилемма функционального программирования рекурсии

Question

Ниже мой код в JavaScript. Ответ на петлю внизу - правильный ответ.

Моя рекурсивная версия неверна, и это настолько нелогично, что когда индекс равен 3, а длина массива равна 3, компьютер все еще входит в статус if ... почему? Если 3 не менее 3, компьютер не должен вводить этот оператор if. помогите мне исправить ответ рекурсии. Петля правильная и правильная, ее следует оставить в покое.

var data = [ 
    { 
     name: "Jamestown", 
    population: 2047, 
    temperatures: [-34, 67, 101, 87] 
    }, 
{ 
    name: "Awesome Town", 
    population: 3568, 
    temperatures: [-3, 4, 9, 12] 
}, 
{ 
    name: "Funky Town", 
    population: 1000000, 
    temperatures: [75, 75, 75, 75, 75] 
} 
]; 

рекурсии ответ

function john(arr, i, j, total, coord) 
{ 

    var total = total || 0; 
    var coord = coord || []; 

    if(i < arr.length) 
    { 

    if(j < arr[i].temperatures.length) 
    { 
    total = arr[i].temperatures[j] + total; 
    john(arr, i, j + 1, total, coord) 
    } 

    ave = total/arr[i].temperatures.length; 
    total = 0; 
    coord.push([ave, arr[i].population]) 

    john(arr, i + 1, 0, total, coord) 

    } 
    return coord; 
    } 

console.log("recursion answer(it is wrong) is") 
console.log(john(data, 0, 0, 0)) 

ответ петли

var coords = [], 
    totalTemperature = 0, 
    averageTemperature = 0; 

for (var i=0; i < data.length; i++) { 
    totalTemperature = 0; 

for (var j=0; j < data[i].temperatures.length; j++) { 
    totalTemperature += data[i].temperatures[j]; 
} 

    averageTemperature = totalTemperature/data[i].temperatures.length; 

    coords.push([averageTemperature, data[i].population]); 
} 

console.log("correct answer is this loop answer ...") 
console.log(coords) 

Answer 1

/// рекурсии ответ

function john(arr, i, j, total, coord) 
{ 

    var total = total || 0; 
    var coord = coord || []; 

    if(i < arr.length) 
    { 

    if(j < arr[i].temperatures.length) 
    { 
    total = arr[i].temperatures[j] + total; 
    john(arr, i, j + 1, total, coord) 
    } 

    ave = total/arr[i].temperatures.length; 
    total = 0; 
    coord.push([ave, arr[i].population]) 

    return john(arr, i + 1, 0, total, coord) 

    } 
    return return coord; 
    } 

Answer 2

/// рекурсии ответ

function john(arr, i, j, total, coord) 
{ 

    var total = total || 0; 
    var coord = coord || []; 

    if(i < arr.length) 
    { 

    if(j < arr[i].temperatures.length) 
    { 
    total = arr[i].temperatures[j] + total; 
    john(arr, i, j + 1, total, coord) 
    } 

    ave = total/arr[i].temperatures.length; 
    total = 0; 
    coord.push([ave, arr[i].population]) 
    // it need return john(arr, i + 1, 0, total, coord) 
    // cannot be john(arr, i+1, 0, total, coord) 
    return john(arr, i + 1, 0, total, coord) 

    } 

    return coord; 
    } 

Answer 3

Вы не можете заменить вложенный цикл двумя рекурсивными вызовами на ту же функцию.

При вызове функции с i, j + 1 это будет не просто делать звонки для следующих значений для j, он также будет делать вызовы для следующих значений для i. Когда вы вызываете его с помощью i + 1, j, он будет не просто выполнять вызовы для следующих значений для i, он также будет выполнять вызовы для следующих значений для j.

Вместо того, чтобы получить цепочку вызовов, выглядит следующим образом:

0,0 
    0,1 
    0,2 
     0,3 
    1,0 
    1,1 
     1,2 
     1,3 
    2,0 
     2,1 
     2,2 
      2,3 
      2,4 

Вы получаете то, что выглядит следующим образом:

0,0 
    0,1 
    0,2 
     0,3 
     0,4 
      1,0 
      1,1 
       1,2 
       1,3 
        2,0 
        2,1 
         2,2 
         2,3 
          2,4 
       2,0 
        2,1 
        2,2 
         2,3 
         2,4 
       2,0 
       2,1 
        2,2 
        2,3 
         2,4 
      2,0 
       2,1 
       2,2 
        2,3 
        2,4 
     1,0 
      1,1 
      1,2 
       1,3 
       2,0 
        2,1 
        2,2 
         2,3 
         2,4 
       2,0 
       2,1 
        2,2 
        2,3 
         2,4 
      2,0 
       2,1 
       2,2 
        2,3 
        2,4 
      2,0 
      2,1 
       2,2 
       2,3 
        2,4 
     1,0 
     1,1 
      1,2 
      1,3 
       2,0 
       2,1 
        2,2 
        2,3 
         2,4 
      2,0 
       2,1 
       2,2 
        2,3 
        2,4 
      2,0 
      2,1 
       2,2 
       2,3 
        2,4 
     2,0 
      2,1 
      2,2 
       2,3 
       2,4 
    1,0 
     1,1 
     1,2 
      1,3 
      2,0 
       2,1 
       2,2 
        2,3 
        2,4 
      2,0 
      2,1 
       2,2 
       2,3 
        2,4 
     2,0 
      2,1 
      2,2 
       2,3 
       2,4 
     2,0 
     2,1 
      2,2 
      2,3 
       2,4 
    1,0 
    1,1 
     1,2 
     1,3 
      2,0 
      2,1 
       2,2 
       2,3 
        2,4 
     2,0 
      2,1 
      2,2 
       2,3 
       2,4 
     2,0 
     2,1 
      2,2 
      2,3 
       2,4 
    2,0 
     2,1 
     2,2 
      2,3 
      2,4 

Кроме того, вместо того, чтобы нажать на результат в конце каждого диапазон значений j, это приведет к результату для каждого отдельного вызова.