1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
package main
import (
"fmt"
"math/big"
)
var digitToFact= map[rune]*big.Int{
'0' : big.NewInt(1),
'1' : big.NewInt(1),
'2' : big.NewInt(2),
'3' : big.NewInt(6),
'4' : big.NewInt(24),
'5' : big.NewInt(120),
'6' : big.NewInt(720),
'7' : big.NewInt(5040),
'8' : big.NewInt(40320),
'9' : big.NewInt(362880),
}
func sliceIndexOfUint64( slice[]uint64, x uint64) int {
for i,e := range slice {
if e == x {
return i;
}
}
return -1
}
func main() {
number := [1000000]int{};
for init_int := uint64(0) ; init_int < 1000000 ; init_int++ {
init := big.NewInt(0);
tmp := big.NewInt(0);
init.SetUint64(init_int)
tmp.SetUint64(init_int)
cmp := 0;
pile := make([]uint64, 0, 61);
isKnow := func ( e *big.Int ) bool {
if e.IsUint64() {
v := e.Uint64();
if sliceIndexOfUint64(pile, v) >= 0 {
return true;
}
if v < 1000000 {
return number[v] != 0;
}
}
return false;
}
for b := true ; b ; b = !isKnow( tmp ) && cmp < 60 {
if tmp.IsUint64() {
pile = append(pile, tmp.Uint64());
}
tmp2 := big.NewInt(0);
for _,c := range tmp.String() {
tmp2 = tmp2.Add(tmp2, digitToFact[c]);
}
cmp += 1;
tmp = tmp2;
}
if isKnow( tmp ) {
v := tmp.Uint64()
i := sliceIndexOfUint64(pile, v)
if sliceIndexOfUint64([]uint64{169, 871, 872, 69, 145, 540, 78}, init_int) >= 0 {
}
if( i >= 0 ) {
for index := i ; index < len(pile) ; index++ {
number[ pile[index] ] = len(pile) - i;
}
for index := i - 1 ; index >= 0 ; index-- {
number[ pile[index] ] = i - index + number[ pile[i] ];
}
} else if v < 1000000 && number[v] != 0 {
cmp += number[v];
for i,e := range pile {
if e < 1000000 {
if number[e] == 0 {
number[ e ] = cmp - i;
}
}
}
}
}
if number[init_int] == 60 {
fmt.Printf("#%d %d\n", number[init_int], init_int);
}
}
}
|
