Question

我正在尝试实现这段代码：

func factorial(x int) (result int) {
  if x == 0 {
    result = 1;
  } else {
    result = x * factorial(x - 1);
  }
  return;
}

as big.Int，以使其对较大的x值有效。

以下为fmt.Println（factorial（r））返回值0

7的阶乘应该是5040？

关于我做错的任何想法？

package main

import "fmt"
import "math/big"

func main() {
        fmt.Println("Hello, playground")

    //n := big.NewInt(40)
    r := big.NewInt(7)

    fmt.Println(factorial(r))

}

func factorial(n *big.Int) (result *big.Int) {
    //fmt.Println("n = ", n)
    b := big.NewInt(0)
    c := big.NewInt(1)

    if n.Cmp(b) == -1 {
        result = big.NewInt(1)
    }
    if n.Cmp(b) == 0 {
        result = big.NewInt(1)
    } else {
        // return n * factorial(n - 1);
        fmt.Println("n = ", n)
        result = n.Mul(n, factorial(n.Sub(n, c)))
    }
    return result
}

这个代码在go playground：http://play.golang.org/p/yNlioSdxi4

Answer 1

Go package math.big已func (*Int) MulRange(a, b int64)。在第一个参数设置为1的情况下调用时，它将返回b！：

package main

import (
    "fmt"
    "math/big"
)

func main() {
    x := new(big.Int)
    x.MulRange(1, 10)
    fmt.Println(x)
}

将产生

3628800

Answer 2

在int版本中，每个int都是不同的。但在您的big.Int版本中，您实际上是在共享big.Int个值。所以当你说

时

result = n.Mul(n, factorial(n.Sub(n, c)))

表达式n.Sub(n, c)实际上将0存储回n，因此在评估n.Mul(n, ...)时，您基本上正在执行0 * 1并且您将返回{ {1}}结果。

请记住，0操作的结果不仅会返回它们的值，还会将它们存储到接收器中。这就是您在big.Int等表达式中看到重复的原因，例如为什么它再次将n.Mul(n, c)作为第一个参数。因为你也可以说n并且你会得到相同的值，但它会存储在result.Mul(n, c)而不是result中。

这是为了避免这个问题而重写的代码：

这是一个稍微清理/优化的版本（我试图删除func factorial(n *big.Int) (result *big.Int) { //fmt.Println("n = ", n) b := big.NewInt(0) c := big.NewInt(1) if n.Cmp(b) == -1 { result = big.NewInt(1) } if n.Cmp(b) == 0 { result = big.NewInt(1) } else { // return n * factorial(n - 1); fmt.Println("n = ", n) result = new(big.Int) result.Set(n) result.Mul(result, factorial(n.Sub(n, c))) } return } s的无关分配）：http://play.golang.org/p/feacvk4P4O

Answer 3

例如，

package main

import (
    "fmt"
    "math/big"
)

func factorial(x *big.Int) *big.Int {
    n := big.NewInt(1)
    if x.Cmp(big.NewInt(0)) == 0 {
        return n
    }
    return n.Mul(x, factorial(n.Sub(x, n)))
}

func main() {
    r := big.NewInt(7)
    fmt.Println(factorial(r))
}

输出：

Answer 4

非递归版：

func FactorialBig(n uint64) (r *big.Int) {
    //fmt.Println("n = ", n)
    one, bn := big.NewInt(1), new(big.Int).SetUint64(n)
    r = big.NewInt(1)
    if bn.Cmp(one) <= 0 {
        return
    }
    for i := big.NewInt(2); i.Cmp(bn) <= 0; i.Add(i, one) {
        r.Mul(r, i)
    }
    return
}

playground

去大。用递归的因子

4 个答案: