How to code an recursion function from an iterative approach?

Question

How would I be able to code the same code below while using recursion, I did it with an iterative approach and I would really appreciate it if someone can help me code it using recursion thankyou! Here's my code:

function returnNumberOfPalindromes(word) {
  function checkForPalindrome(chunk) { 
    let chunkArray = [];
    for (const letter of chunk) { 
      chunkArray.push(letter);
    }
    if (chunkArray.reverse().join('') === chunk) {
      tally += 1;
    }
  }
  let tally = 0;

  for (let index1 = 0, index2 = 2; index1 <= word.length; index1++, (index2 = index1 + 2)) {
    for (; index2 <= word.length; index2++) { 
      let chunk = word.slice(index1, index2); 
      checkForPalindrome(chunk);
    }
  }
  console.log(tally);
}

returnNumberOfPalindromes("kayak");
returnNumberOfPalindromes("aya");
returnNumberOfPalindromes("appal");
returnNumberOfPalindromes("addadaadd");

Answer 1

I'm not going to write checkForPalindrome recursively since it's trivial to do:

function checkForPalindrome(str) {
  // we can use .split("") to convert to an array of characters
  return str.split("").reverse().join("") == str;
}

function palindromesAtStart(str) {
  // lengths 0 and 1 can't be palindromes
  if (str.length < 2) {
    return 0;
  }
  // if it's a palindrome add 1
  const diff = checkForPalindrome(str) ? 1 : 0;
  // now shorten the string and check again
  return diff + palindromesAtStart(str.slice(0, -1));
}

function returnNumberOfPalindromes(str) {
  if (str.length < 2) {
    return 0;
  }
  // total palindromes is palindromes at start plus palindromes not at start
  return palindromesAtStart(str) + returnNumberOfPalindromes(str.slice(1));
}


console.log(returnNumberOfPalindromes("kayak"));
console.log(returnNumberOfPalindromes("aya"));
console.log(returnNumberOfPalindromes("appal"));
console.log(returnNumberOfPalindromes("addadaadd"));

Essentially, the palindromes in the string can either include the first index, or not include the first index. So, we can write a simple recursive function (palindromesAtStart) to count the number of palindromes which include the first index and add that to the number of palindromes which don't include the first index.