数的阶乘

【问题标题】：factorial of a number数的阶乘
【发布时间】：2010-12-14 10:27:13
【问题描述】：

我有以下代码，但它没有给出完美的阶乘结果，你能找出来吗？

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
 <head>
  <title> New Document </title>
  <script type="text/javascript">
 function fact(num)
 {
    var x=parseInt(num);
    //alert(x+1);
    if(x>0)
        x=x* fact(x-1);
    alert(x);
 }
  </script>
 </head>

 <body>
 <form name="f1">
  Enter the Number  :<input type="text" length="8" name="txt1"><br>
  <input type="button" value="Find factiorial" onclick="fact(txt1.value)">
  </form>
 </body>
</html>

【问题讨论】：

标签： javascript


【解决方案1】：

你必须return 值。给你：

function fact(x) {
   if(x==0) {
      return 1;
   }
   return x * fact(x-1);
}

function run(number) {
    alert(fact(parseInt(number, 10)));
}

和

<input type="button" value="Find factiorial" onclick="run(txt1.value)">

（如何使它适用于负数我留给你；）（但我还是在这篇文章中展示了））

只是为了好玩，更正确的非递归算法：

function fact(x) {
       if(x == 0) {
           return 1;
       }
       if(x < 0 ) {
           return undefined;
       }
       for(var i = x; --i; ) {
           x *= i;
       }
       return x;
}

【讨论】：

  • 递归算法没有基本情况。非递归函数也是错误的。
  • @dheerosaur：是的，对于递归算法，修复了这个问题（对我来说还早；））。但是为什么非递归的错误呢？它对我有用（见这里jsfiddle.net/fgpPJ/1）@Mihir：它现在有效。
  • 我发现了一件事.. 当我放置 if(x>0){ return x* fact(x-1)} 结果是 NaN .. 当我放置 if(x== 0){return 1} return x*fact(x-1).. 它显示正确的结果。这两个代码块有什么区别
  • 对不起，非递归的是对的。我正在寻找 for 中的惯用检查。
  • @Mihir - 在第二个 sn-p 中，所有代码路径返回一个数字。首先，您需要在if 之后使用return 1 - 如果没有它，它就不是一个完整的功能。
【解决方案2】：

使用循环很容易实现

function fact(num)
{
    if(num<0)
     return "Undefined";
    var fact=1;
    for(var i=num;i>1;i--)
      fact*=i;
    return fact;
 }

<input type="button" value="Find factiorial" onclick="alert(fact(6))">

【讨论】：

    【解决方案3】： 
    function factorial(n) {
  return (n != 1) ? n * factorial(n - 1) : 1;
}

alert( factorial(5) );

    你可以尝试使用递归方法

    【讨论】：

      【解决方案4】：
      1. 您的函数永远不会返回任何内容。
      2. 当 x 为 0 时你会做什么？
      3. 小问题 - 除了alert，您实际上并没有对返回的值做任何事情。

      如果你愿意，试试这个（将鼠标悬停在文本上）：

      if(x==0) return 1;
      return x * fact(x-1);

      工作示例：http://jsbin.com/apuka3/2

      【讨论】：

      【解决方案5】：

      首先，您的函数中需要有一个return。 ;)

      【讨论】：

        【解决方案6】：

        我写了这个，它有效。

          var d = 1;
  for (num; num > 1; num--) {
    d *= num;
  }
  return d;

        【讨论】：

          【解决方案7】：

          这是一个简短的递归版本：

          function doFact(n) {
  return +!(+(n)) || doFact(n - 1) * n;
}

function factorialFromInput() {
  var theInputVal = document.getElementsByTagName("input")[0].value;
  var theContainer = document.getElementById("resultContainer");
  theContainer.innerHTML = "" + doFact(Math.abs(theInputVal));
}
          .wrapper>* {
  line-height: 2em;
  width: 30%;
}
#resultContainer {
  border: outset grey;
  min-height: 1.1em;
  padding-left: 0.3em;
  background-color: #eff0f1;
  overflow: scroll;
}
          <div class="wrapper">
  <input type="text" id="valEntered">
  <br>
  <button onclick="factorialFromInput();">Calculate Factorial</button>
  <br>
  <div id="resultContainer"></div>
</div>

          【讨论】：

            【解决方案8】： 
            function fact(n) {
  if (n > 1) {
    return n * fact(n-1);
  } else {
    return 1;
  }
}
console.log(fact(5));

            使用三元运算符，我们将上面的代码替换为一行代码，如下所示

            function fact(n) {
      return (n != 1) ? n * fact(n - 1) : 1;
 }
console.log(fact(5));

            【讨论】：

              【解决方案9】：

              这是最简单的方法，也是最新的 JS(ES6)

              factorial = n =>  n - 1 > 0 ? n * factorial(n - 1) : n;

//output
console.log(factorial(5));

              这里我使用了 ES6 箭头函数。为了更好地理解，请查看arrow function是什么。

              【讨论】：

                【解决方案10】：

                JS 中的递归对堆栈溢出错误是开放的，而且速度也很慢。通过其他方式循环更好。我对阶乘代码的贡献很简单；

                var fact = n => n > 0 ? Array.from({length: n}, (_,i) => i+1)
                             .reduce((p,c) => p*c)
                      : 1;
console.log(fact(5));

                【讨论】：

                  【解决方案11】：

                  函数的重要部分是这一行：

                   x = x * fact(x-1);

                  但fact 函数不返回值，所以这与x * undefined 相同。尝试将return x; 添加到函数底部。

                  【讨论】：

                    【解决方案12】：

                    1) 当 X=0 时，函数应该返回 1； 2) 增加了回报；

                     function fact(num)
 {
    var x=parseInt(num);
    //alert(x+1);
    if(x>0)
        x=x* fact(x-1);
    else
        x=1;
    return x;
 }

                    用法

                    <input type="button" value="Find factiorial" onclick="alert(run(fact.value));">

                    【讨论】：

                      【解决方案13】：

                      对 Anton 的代码稍作修改：

                      function fact(x) {
   if(x>0)
       return x* fact(x-1);
   if(x===0)
       return 1;
   return null;

}

                      （负的阶乘不存在，但0的阶乘等于1，这种情况下，如果一个数小于0，函数将返回null）

                      【讨论】：

                      【解决方案14】：

                      怎么样：

                      function fact(n) {
  n = Math.round(n);
  if (n < 2) {
    return 1;
  }
  else {
    return n * fact(n - 1);
  }
}

                      ?

                      【讨论】：

                        【解决方案15】：

                        我的建议：

                        function fact(x) {
    if (x<0) {
        return Infinity
    };
    var _= 1
    for ($=1;$<=x;++$) {
        _*=$
    };
    return _
};

                        它只是返回任何“x”的阶乘。

                        【讨论】：

                          【解决方案16】：

                          这是我使用 while 循环制作的一个：

                          function factorialize(num) 
{
  i = 1;
  b = 1;
  while (i < num) {
    b = b + (b * i);
    i = i + 1;
    }
return b;
}

                          【讨论】：

                            【解决方案17】： 
                             <script src="jquery-3.1.0.js"></script>
<script>
    $(function () {
        var target = 5;
        var factorial = 1;
        for (var i = 1; i <= target; i++) {
            factorial *= i;
        }
        alert(factorial);
       });
</script>

                            您可以在目标中设置任何值，此逻辑将计算阶乘。

                            谢谢... :)

                            【讨论】：

                              【解决方案18】：

                              我不确定为什么没有人使用动态编程来回答这个问题，在我看来，这是迄今为止在阶乘上构建东西的最有效方法。

                               var mem = [];

 function fact(num)
 {
    var x = parseInt(num);

    if (x == 0 || x == 1) return 1;

    mem[x] = x * fact(x-1);

    return mem[x];
 }

                              【讨论】：

                              • mem[x] 不会为给定的 'num' 重新访问。所以这不是 DP，只是简单的记忆/缓存。
                              【解决方案19】：

                              一个很简单的形式：

                              function fact() {
    var x = document.getElementById("txtf").value;
    var f=1;
    for (var i=1; i <= x ; i++){
        f = f*i;
    }
    document.getElementById('showR').innerHTML= f;
}


 <input type="text" id="txtf" value="3">
   <input type="button" id="btnf" value="click for calculate" onclick="fact()">
   <p id="showR">/Factoriel/</p>

                              【讨论】：

                                【解决方案20】： 
                                    function factorial(num) {

    var result = 1;

    for (var i = 1; i <= num; i++) {
        result = result * i;

    }

    return result;
}
//call function e.g factorial(4).. 1*2*3*4 it will evaluate in ascending order

                                【讨论】：

                                • 你的答案会更好一些解释。点击左下角的编辑链接。
                                【解决方案21】： 
                                var factorialNumber , factorial=1;
factorialNumber=prompt("Factorial Number" , "write Factorial Number");
for(var i = 1; i<= factorialNumber;i++){
    factorial *= i;
}
alert(factorial);

                                上面的代码首先定义了两个变量factorialNumber和factorial。 factorial 初始化为 1。factorialNumber 将得到 prompt 的结果（需要一个数字），然后使用循环，在每个步骤中，阶乘与步骤的索引相乘，表示为通过i。计算成功后，我们使用alert 显示结果。

                                【讨论】：

                                • 请在您的代码中添加解释。仅代码的答案通常不受欢迎
                                • 我的代码怎么样？好吗？毕有帮助吗？我检查了它还不错你的想法是什么？顺便说一句，我今年 17 岁
                                • 很好，但是，它与这里的其他一些答案没有什么不同。我的评论主要是人们喜欢在工作示例旁边获得对代码作用的解释
                                【解决方案22】：

                                使用 Do 循环非常简单。

                                    <table>
    <tr>
        <th>Amount of integers</th>
        <th>Answer</th>
    </tr>
    <tr>
        <th><input id="int" type="number"/></th>
        <th><input id="answer" type="number"/></th>
    </tr>
</table>
<button onclick="calculate()">calculate</button>
<script>
    function calculate() {
        var input = document.getElementById("int").value;
        var int = 1;

        do {
            var product = int *= input;
            input--;
        } while (input > 0);
        answer.value = product;
    }
</script>

                                您首先设置一个表格作为输入变量的一种方式，并有一个地方可以输出答案。您还可以添加一个按钮来执行您的功能。

                                输入变量是用户输入的值。您还可以使用 int 变量作为占位符。

                                在 do 循环中，您是另一个变量，即产品，它使用您的占位符变量并通过输入对其计时。此后输入递减，只要输入值大于零，循环就会继续迭代。

                                然后在最后，它会将答案发布到表格中的 'answer' id 标签。

                                【讨论】：

                                  【解决方案23】： 
                                  function factorial (n) {
  if (n > 1) {
    return n * factorial(n-1);
  }
  return 1;
}
console.log("recursive way => ",factorial(5));

                                  【讨论】：

                                    【解决方案24】： 
                                    function factorial(num){
    if(num<1||typeof num!=='number'){
    return undefined
  }
  if(num===1){
    return num
  }
    return num*factorial(num-1)
}
console.log(factorial(3))

                                    https://jsfiddle.net/mohittadhiyal/6w64x0sL/10/

                                    【讨论】：

                                      【解决方案25】：

                                      我已经看到在许多地方（Eloquent JavaScript 等）使用的递归方法。在这里，函数被递归调用，直到它到达 0，这不应该是这种情况。我们应该只调用函数直到它 >= 2，因为我们需要乘以的最后一个数字是 1。

                                      这是一个很小的变化，可能无关紧要。很想知道其他人是怎么想的。假设它是一个有效的正整数。

                                      /**
 * Popular approach - the recursive function is called till x is 0
 * 
 * @param x
 */
function popularFactorial(x) {
    console.log(x)
    if(x === 0) {
        return 1
    } else {
        return x * popularFactorial(x - 1)
    }
}
var result = popularFactorial(8)
console.log(result)

/**
 * Using this approach, the recursive function is called one less time
 * i.e till x is 1
 * 
 * @param x 
 */
function factorial(x) {
    console.log(x)
    if(x === 0) {
      return 1
    } else if(x >= 2) {
        return x * factorial(x - 1)
    }
    return x
}
var result = factorial(8)
console.log(result)

                                      【讨论】：

                                        【解决方案26】： 
                                        function factorial(n) {
    return [...Array(n + 1).keys()].slice(1).reduce((total, currentValue) => total * currentValue, 1);
}

                                        【讨论】：

                                          【解决方案27】： 

                                          //This is fastest way to implement factorial
const fact = n => !n ? 1 : n * fact(--n);

console.log(fact(10))

                                          【讨论】：

                                            【解决方案28】：

                                            我对 javascript 很陌生，很高兴知道可以对此答案进行的任何改进

                                            var a = 1;
function factorial(num) {
    if (num == 0) {
        return 1;
    } else if (num < 0) {
        return undefined;
    } else {
    for(i = num; i > 0; i--){
        a *= i;
    }
    return a;
    }
}
var b = factorial(5);
console.log(b);

                                            【讨论】：

                                            • 您好。欢迎来到stackoverflow。这应该是一个问题而不是一个答案。答案部分仅用于答案。但是您可以创建一个新问题并链接到该帖子作为参考。
                                            猜你喜欢
                                            • 2014-03-24
                                            • 1970-01-01
                                            • 2011-01-26
                                            • 2021-01-17
                                            • 1970-01-01
                                            • 2023-03-22
                                            • 2015-04-19
                                            • 1970-01-01
                                            • 2011-10-17
                                            相关资源
                                            最近更新 更多
                                            热门标签
                                            Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode