大图书馆中的Lychrel数字

Question

I'm trying to make a Lychrel number program in Go, but I'm running into some trouble. Using the "math/big" library, and with some extra print statements for debugging, my code looks like this:

func reverse(n *big.Int) *big.Int {
    var (
        m = n
        r = big.NewInt(0)
        z = big.NewInt(0)
        one = big.NewInt(1)
        ten = big.NewInt(10)
        )
    for {
        r.Mul(r, ten)
        d := z
        d.Mod(m, ten)
        r.Add(r, d)
        m.Div(m, ten)
        if m.Cmp(one) == -1 {
            return r
        }
    }
}

func radd(num *big.Int) *big.Int {
    newNum := num
    rnum := reverse(num)
    newNum = newNum.Add(num, rnum)
    fmt.Println(num, "+", rnum, "=", newNum)

    return newNum
}

func lychrel(arg int) bool {
    fmt.Println("Now testing", arg)
    num := big.NewInt(int64(arg))
    for i := 0; i < 50; i++ {
        num = radd(num)
        fmt.Println(i, ":", num)
        if num.Cmp(reverse(num)) == 0 {
            return false
        }
    }
    return true
}

While the analogous code without the big library works fine (save for eventual overflow errors), this version doesn't. When I do lychrel(196), for example, I get

Now testing 196
691 + 691 = 691
0 : 691
0 + 0 = 0
1 : 0

I can't figure out where it goes wrong. I hope I'm not missing something dumb, because I've spent all morning trying to get this to work.

Answer 1

Package big

import "math/big"

func NewInt

func NewInt(x int64) *Int

NewInt allocates and returns a new Int set to x.

func (*Int) Set

func (z *Int) Set(x *Int) *Int

Set sets z to x and returns z.

You are assigning pointers, instead of values.

m = n
newNum := num

Assign values,

m = new(big.Int).Set(n)
newNum := new(big.Int).Set(num)

For example,

package main

import (
    "fmt"
    "math/big"
)

func reverse(n *big.Int) *big.Int {
    var (
        m   = new(big.Int).Set(n)
        r   = big.NewInt(0)
        z   = big.NewInt(0)
        one = big.NewInt(1)
        ten = big.NewInt(10)
    )
    for {
        r.Mul(r, ten)
        d := z
        d.Mod(m, ten)
        r.Add(r, d)
        m.Div(m, ten)
        if m.Cmp(one) == -1 {
            return r
        }
    }
}

func radd(num *big.Int) *big.Int {
    newNum := new(big.Int).Set(num)
    rnum := reverse(num)
    newNum = newNum.Add(num, rnum)
    fmt.Println(num, "+", rnum, "=", newNum)
    return newNum
}

func lychrel(arg int) bool {
    fmt.Println("Now testing", arg)
    num := big.NewInt(int64(arg))
    for i := 0; i < 50; i++ {
        num = radd(num)
        fmt.Println(i, ":", num)
        if num.Cmp(reverse(num)) == 0 {
            return false
        }
    }
    return true
}

func main() {
    lychrel(196)
}

Output:

Now testing 196
196 + 691 = 887
0 : 887
. . .