雄辩的JavaScript第二版递归练习解决方案

我试图解决在线书籍的递归练习：

问题是这样说的：

我们已经看到%（余数操作符）可以用来测试 一个数字是偶数还是奇数，通过使用%2检查它是否可以被整除 两个。这里有另一种方法来定义一个（正的，整数）数字 是偶数还是奇数：

• 零是偶数
• 一个是奇怪的

---

• 对于任何其他数字N，其均匀度与N-2相同

---

定义一个递归函数，即使与此描述相对应。 函数应接受数字参数并返回布尔值

在50和75上进行测试。查看它在-1上的行为。为什么？你能思考吗 有没有办法解决这个问题

以下是我尝试过的方法，它是有效的：

function isEven(number) {
    if (number == 0) {
        return true;
    } else {
        return (-number % 2 == 0) ? true : false;
    }
    return isEven(number - 2);
}

console.log(isEven(-1));

---

但是，这似乎是一个错误的答案，因为据我所知，作者希望我使用-2方法。我想知道这是否确实是正确的答案，或者这是否是错误的，是否有人能给我指出正确的方向。

我认为问题在于创建一个isEven函数而不使用mod/%/余数操作

function isEven(number) {
  if (number < 0) {
    number = Math.abs(number);
  }
  if (number===0) {
    return true;
  }
  if (number===1) {
    return false;
  }
  else {
    number = number - 2;
    return isEven(number);
  }

}

函数isEven（数字）{
如果（数字<0）{
数字=数学abs（数字）；
}
如果（数字==0）{
返回true；
}
如果（数字==1）{
返回false；
}
否则{
数字=数字-2；
返回isEven（编号）；
}
}

我想这一点很重要

它不处理字符串

它不处理浮动

不要将其放入生产应用程序中

---

下面提供了不使用modulos运算符

%

或JavaScript中任何其他内置函数的替代解决方案。相反，这个解决方案依赖于使用另一个递归来更改数字的负值

function isEven(number) {
    if (number < 0) {
        return isEven(-number);
    } else if (number == 1) {
        return false;
    } else if  (number == 0) {
        return true;
    } else {
        return isEven(number - 2);
    }
}

console.log(isEven(50)); // true
console.log(isEven(75)); // false
console.log(isEven(-1)); // false

函数isEven（数字）{
如果（数字<0）{
返回isEven（-number）；
}else if（数字==1）{
返回false；
}else if（数字==0）{
返回true；
}否则{
返回isEven（编号-2）；
}
}
console.log（isEven（50））；//真的
console.log（isEven（75））；//假的
console.log（isEven（-1））；//假的

我们调用isEven（数字-2）返回函数顶部，初始输入的数字比之前少2，它将继续这样做，直到数字为1或0，然后它将能够返回布尔值true或false（偶数或奇数）。

问题要求不要使用模运算符（%）.

---

我认为您感到困惑的原因是您不理解递归是如何工作的。它之所以是n-2，是因为它取这个数，然后减去2，直到它是零或一。因此给我们一个正确或错误的答案

希望有帮助。阅读递归过程是如何工作的。

这是网站上的答案。我用引号说“正确”，因为我不理解第二个“elseif”语句的

返回isEven（-n）

。为什么作者包含将

n

转换为正数的选项

function isEven(n) {
  if (n == 0)
    return true;
  else if (n == 1)
    return false;
  else if (n < 0)
    return isEven(-n);
  else
    return isEven(n - 2);
}

function isEven(n) {
    function checkNumber(num){
        if ( num % 2 === 0)
            return true;
        else
            return false;
        }
    return checkNumber(-n); // instead of return isEven(n - 2) where stack blows
}

console.log(isEven(50)); // -> true

console.log(isEven(75)); // -> false


console.log(isEven(-1)); // -> false

console.log(isEven(-2)); // -> true

函数isEven（n）{
如果（n==0）
返回true；
else如果（n==1）
返回false；
else if（n<0）
返回isEven（-n）；
其他的
返回isEven（n-2）；
}

无论如何，我想我会分享，因为我没有看到任何人张贴这个答案

var isEven = function(n) {
  // Get the absolute value of the number
  // so we don't have to bother with negatives
  n = Math.abs(n);

  // We know that if we subtract 2 from our number
  // until it is equal to zero, our number was even
  // If our number isn't zero, this statement will be skipped
  if(n === 0) return true;

  // We know that if we subtract 2 from our number
  // and it reaches a value of 1, it isn't even
  // If our number isn't 1, this statement will be skipped
  if(n === 1) return false;

  // We subtract 2 from our original number and pass it
  // back in to this function to check it over and over again
  // until one of the conditions is met and the function can
  // return a result
  return isEven(n - 2);
}

// We test our function here
console.log(isEven(-21));

这是我能想出的最精简的方法。请注意，我们从内部调用isEven函数，并传入n-2的值。这将不断地从数字中减去2，并检查它是否等于0或1，直到得到正确的结果并返回相应的布尔值

---

我希望这能让事情澄清一点。

下面的代码怎么样？似乎对我有用

/*if > 1 keep looking, otherwise return reverse boolean value. 
If negative value, inverse, to answer the last part of the question... 
Also needed to use parseInt as the text value I used, 
was considered a string value!
This being a recursive function which really isn't necessary, 
means that in javascript we will get a 
stack size exceeded error when the number becomes too large.*/

function isEven(x) {
    return (x>1)?isEven(x-2):(x>=0)?!x:isEven(-x);
}

---

为了更好地理解递归，我想知道这个解决方案是否有效

function isEven(n) {
    function checkNumber(num){
        if ( num % 2 === 0)
            return true;
        else
            return false;
        }
    return checkNumber(-n); // instead of return isEven(n - 2) where stack blows
}

console.log(isEven(50)); // -> true

console.log(isEven(75)); // -> false


console.log(isEven(-1)); // -> false

console.log(isEven(-2)); // -> true

我希望这有助于：

const evenOrOdd = (N) => {
    if (Math.abs(N) === 0) {
        return console.log('Even');
    } else if (Math.abs(N) === 1) {
        return console.log('Odd');
    }
    evenOrOdd(Math.abs(N) - 2);
};

---

它利用了关于这个问题的所有三个给定论点。它可以处理负整数。它不使用模运算符。最后，我看不到任何与我提供的代码片段类似的代码片段，因此我很乐意与大家分享我所能看到的。

这本书希望这些值有以下console.log输出

//define recursive function isEven takes a positive whole number
//returns true if even
function isEven(x) {
  //define innner function to loop over value
  function find(current) {
    //check if value == 0, return true
    if (current == 0) { 
      return true
    //check if value == 1 return false
     } else if (current == 1)  {
        return false
    //loop over value, subtracting 2 each time until either 0 or 1
    //which returns the approriate true/false value based on evenness
     } else {
     console.log(current)
     return find(current -2)
    }
  }
    return find(x)
}

console.log(isEven(50));
// → true
console.log(isEven(75));
// → false
console.log(isEven(-2));
// → ??

提示说：“当给定一个负数时，函数将一次又一次地递归，传递给自己一个更负的数，从而离返回结果越来越远。它最终将耗尽堆栈空间并中止。”所以我不确定我得到的是否代表了这一点，但我的代码和console.log输出如下所示：

   let isEven = function(num) {
         if (num ===0) {
             return true
         } else if (num===1){
             return false
         } else {
             return isEven(num-2)
         }
    }    

console.log(isEven(50));
// → true
console.log(isEven(75));
// → false
console.log(isEven(-2));
// → RangeError: Maximum call stack size exceeded (line 3 in function isEven)```

---

如果数字是1或-1所以奇数，则函数返回false，
如果数字是0so偶数，则返回真，

如果数字不是1，-1或0，我们必须首先检查数字是正数还是负数，

如果数值为负且小于-1我们再次调用该函数，但将数值增加2，直到得到-1或0
如果数值为正且大于1我们再次调用该函数，但将数值减少2，直到得到1或0

例如，数字是5->
它是正数且大于1，因此反复调用函数并将数字减少2，直到结果为0或1:
5->3->1/->false

    function isEven(num) {
    if (num == 1 || num == -1) {
        return false;
    } else if (num == 0) {
        return true;
    } else {
        if (num < -1) {
            return isEven(num + 2);
        } else {
            return isEven(num - 2);
        }
    }
}

---

我在上面看到了很多使用数学函数和模运算符的示例。但我猜作者希望通过一个简单的递归函数，让读者了解相同函数的功能，以及如果没有正确定义它，如何导致重复的函数调用，并最终导致堆栈溢出。我相信下面的代码可以帮助您理解：

函数isEven（n）{
如果（n==0）{
返回true；
}else如果（n==1）{
返回false；
}否则{
回报是
console.log(isEven(50));
// → true
console.log(isEven(75));
// → false
console.log(isEven(-2));
// → ??

   let isEven = function(num) {
         if (num ===0) {
             return true
         } else if (num===1){
             return false
         } else {
             return isEven(num-2)
         }
    }    

console.log(isEven(50));
// → true
console.log(isEven(75));
// → false
console.log(isEven(-2));
// → RangeError: Maximum call stack size exceeded (line 3 in function isEven)```

    function isEven(num) {
    if (num == 1 || num == -1) {
        return false;
    } else if (num == 0) {
        return true;
    } else {
        if (num < -1) {
            return isEven(num + 2);
        } else {
            return isEven(num - 2);
        }
    }
}

console.log(`-35 is even: ${isEven(-35)}`); //-> false
console.log(`-1 is even: ${isEven(-1)}`);  //-> false
console.log(`0 is even: ${isEven(0)}`);  //-> true
console.log(`32 is even: ${isEven(32)}`);  //-> true