Eloquent JavaScript第2版递归练习解决方案

Question

我试图解决在线图书eloquentjavascript 2nd edition的递归练习：

以下是问题所述：

  

我们已经看到％（余数运算符）可用于测试是否   通过使用％2检查它是否可被整除，数字是偶数还是奇数   二。这是另一种定义（正，整）数字的方法   是偶数还是奇数：

     

  
• 零是均匀的。
  
• 一个是奇怪的。
  
• 对于任何其他数字N，其均匀度与N - 2相同。
  

     

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

     

在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方法。我想知道这是否确实是正确的答案，或者是否有人指出我正确的方向。

Answer 1

我认为您感到困惑的原因是因为您不了解递归是如何工作的。它是n-2的原因是，它取数字并减去2直到它为0或1。因此，给我们一个真或假。

希望有所帮助。阅读递归过程的工作原理。

Answer 2

下面提供了不使用模运算符%或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

Answer 3

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

Answer 4

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

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

Answer 5

我认为问题是创建一个isEven函数而不使用mod /％/ remainder操作

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

}

我想添加到此

非常重要

1. 它不处理字符串
2. 它不处理花车
3. 不要将其放入生产应用程序

Answer 6

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，直到我们得到一个正确的结果并返回相应的布尔值

我希望这可以解决一些问题。

Answer 7

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

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)```

Answer 8

下面的代码怎么样？似乎为我工作。

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

Answer 9

这是网站上的"correct"回答。我在引号中说“正确”，因为我不理解第二个'else if'语句return 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);
}

无论如何，以为我会分享，因为我没有看到任何人发布这个答案。

Answer 10

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

Answer 11

问题要求您不要使用模数运算符（％）。

// Your code here.
var isEven = function(a){
  if (a == 0){ //case 1 : zero is even
    return true;
  }
  else if(a == 1){ //case 2: one is odd 
    return false;
  }
    else {
      return isEven(Math.abs(a-2)); //solves case 3 (negative numbers)
    }
}

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

Answer 12

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

如果数字不是 1,-1 也不是 0，我们首先要检查数字是正数还是负数，

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

因此，例如，数字是 5 ->
它是正数且大于 1，因此一遍又一遍地调用该函数并将数字减 2，直到结果为是 0 或 1：
5->3->1 //->假

    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

Answer 13

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

function isEven(n){
  if(n==0){
    return true;
  } else if(n==1){
    return false;
  } else {
    return isEven(n-2);
  }
}
console.log(isEven(50));
console.log(isEven(75));
console.log(isEven(-1));

Answer 14

function isEven(num){
 if(num %2 == 0) {
 return true;
} else {
  return false;
 }
}

console.log(isEven(50));
// → true

console.log(isEven(75));
// → false

console.log(isEven(-1));
// → ??

Answer 15

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

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

Answer 16

function isEven(number) {
    while(number>= -1)
    {   
        return isEven(number-2) == 0 && number>-1 ? true : false;
    }
}
console.log(isEven(-1));

Answer 17

我希望这会有所帮助：

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

Google Chrome Console code results:

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