233猜想

毒酒滴冻鸭

感谢各位高手大神们的参与回复讨论。。。

正如9楼wayne兄说的，这个猜想结果的有趣性在于不但迭代过程必然收敛没有发散，而且最后必然归宿于一个固定26个正整数的循环数集，而不会进入其他正整数组成的另一循环数集。。。

现在看看感觉有点像【罗马道路】的建设结构：

相传在古罗马帝国最兴盛时期，集合全国人力物力构建出一个以罗马都城为中心的道路系统，从都城向四面八方建出先进方便的道路，并声称【从欧洲大陆任意一处地方出发，只要沿着道路走最终必能通向罗马城】。。。此也是谚语【路路通罗马】或【条条大路通罗马】的出处。。。

而这个26正整数循环数集就像一个有26个城门的罗马都城，从城外四面八方的所有起点（其他大于1的正整数），按一楼说的迭代规则（沿着道路走）终将进入这个循环（抵达罗马城）。。。

那么感觉可以进行这样的编程：与其用【233】或【177】之类的固定数值作检测目标，不如用整个26数数集，并记录从任何起点在哪个位置（城门）进入循环，这样就可以统计例如从2到1亿，这26个进入点哪个的使用次数最高（即【流通率最频密的城门】）。。。另外也可统计从各个起点进入循环（抵达城门）的步数，从而统计出各点【与罗马城的距离】，并看看哪些数值【距离罗马城最远】。。。

wayne

这个比较稳定,根据入口的频率从高到低是这个顺序

1. {477,411,233,533,177,599,2333,8211,3133,1377,2411,6011,9077,6611,9533,8577,5999,9977,23333,24111,95333,60111,136199,66799,194577,233333}

复制代码

如果以477作为结束的入口. 长度可以是75

1. {16463267215777913441495522695794515723979492274402326422003030724250333,164632672157779134414955226957945157239794922744023264220030307242503333,7962236525314762022509896493975236777,7646438610693135525314411306996299,82186618488363397878073033,2786402836326499,2143386797174233,1307501248811,537380811,43399,433999,100933,144199,131099,42299,422999,32299,322999,3229999,50399,4999,49999,499999,1277,12777,42599,10399,103999,1799,2577,8599,85999,859999,175511,250733,433,4333,6199,61999,5211,1933,19333,193333,3899,5577,133,199,1999,19999,28577,411,1377,177,599,5999,8577,9533,95333,136199,194577,8211,233,2333,23333,233333,6611,6011,60111,66799,9977,9077,3133,2411,24111,477}

复制代码

l4m2

1e10~1e11的，过程中试图在2^60后面加数字的列表：

1. f[n_]:=Print[NestWhileList[With[{p=FactorInteger[#][[-1,1]]},10 p+Mod[p,10]]&,n,# != 233 &]]
   
2. f[11307204673]
   
3. f[11791409233]
   
4. f[12414334379]
   
5. f[13657056769]
   
6. f[13827439009]
   
7. f[13909583543]
   
8. f[16848542713]
   
9. f[17090397589]
   
10. f[18592301069]
    
11. f[19525134929]
    
12. f[19679131313]
    
13. f[20014237777]
    
14. f[22291198621]
    
15. f[23957249651]
    
16. f[23978654699]
    
17. f[24597368179]
    
18. f[26619166279]
    
19. f[29478092513]
    
20. f[30442286729]
    
21. f[30661423589]
    
22. f[33121043083]
    
23. f[33746307233]
    
24. f[34586315609]
    
25. f[45676578803]
    
26. f[46255881583]
    
27. f[47082389489]
    
28. f[50547274847]
    
29. f[52455978703]
    
30. f[53165107409]
    
31. f[53433005149]
    
32. f[53529277223]
    
33. f[54818734343]
    
34. f[56130999469]
    
35. f[58031988299]
    
36. f[60038162939]
    
37. f[63596449373]
    
38. f[64738897477]
    
39. f[64863478679]
    
40. f[65760248761]
    
41. f[67913307653]
    
42. f[68207723453]
    
43. f[74058459929]
    
44. f[76444275983]
    
45. f[77651002453]
    
46. f[77852418349]
    
47. f[78557724629]
    
48. f[78771156799]
    
49. f[79750139351]
    
50. f[80218841429]
    
51. f[81139521473]
    
52. f[81432060397]
    
53. f[82559994893]
    
54. f[83408220377]
    
55. f[84141179387]
    
56. f[84753966289]
    
57. f[86050929967]
    
58. f[87130079119]
    
59. f[87202118849]
    
60. f[90106652473]
    
61. f[90920408399]
    
62. f[91822444139]
    
63. f[92418356099]
    
64. f[96745464073]

复制代码

目前在做1e11-1e12，我每1G个数需要两分钟

northwolves

1. Pcount[n_,p_]:=Module[{m=10^n,ps=Prime@Range[PrimePi[p]-1]},s={(-1)^Length@#,Times@@#}&/@Subsets[ps];
   
2. Total@Table[Total[#1*Floor[m/(p^k*#2)]&@@@s],{k,Floor@Log[p,m]}]];
   
3. Do[s=Pcount[12,p];
   
4. Print[StringForm["10^12以内最大质因数为`1`的整数个数: `2`",p,s]],{p,{17,23,41,47,53,59}}]

复制代码

10^12以内最大质因数为17的整数个数: 11988011987
10^12以内最大质因数为23的整数个数: 7773819203
10^12以内最大质因数为41的整数个数: 3718025289
10^12以内最大质因数为47的整数个数: 3080856508
10^12以内最大质因数为53的整数个数: 2667386419
10^12以内最大质因数为59的整数个数: 2346328184

wayne

回复 @毒酒滴冻鸭 在12#的评论/  我重新跑了一下, 10^8,统计了一下频率,其实在10^4的时候,排序已经开始保持稳定不变了.

1. <|477->26155852,411->24058370,233->18190595,533->15549417,177->4254808,599->4218599,2333->3108062,8211->2843557,3133->1750705,1377->1091310,2411->919114,6011->642136,9077->520943,6611->427839,9533->360040,8577->326614,5999->262443,9977->211149,23333->155656,24111->63112,95333->55131,60111->41037,136199->36008,66799->28097,194577->12346,233333->11747|>

复制代码

代码如下

1. acc=Association[];
   
2. Do[acc[p]=0,{p,NestWhileList[With[{p=FactorInteger[#][[-1,1]]},10 p+Mod[p,10]]&,233,Length[#]<2||#!=233&,1,30]//Union}];
   
3. mmm=20;Monitor[Do[temp=NestWhileList[With[{p=FactorInteger[#][[-1,1]]},10 p+Mod[p,10]]&,m,KeyExistsQ[acc,#]==False&,1,100];acc[Last[temp]]++;If[Length[temp]>mmm,Print[{m,Length[temp]}];mmm=Length[temp]],{m,10^8}],{m,ReverseSort[acc]}]

复制代码

同时记录了最大的路径长度,23244413 迭代到入口411的时候停止,此时长度是59,

1. {23244413,232444133,2324441333,23244413333,3184166211,246834599,224395099,2243950999,19162699,4077177,1045433,143211,477377,280811,2808111,550611,203933,43399,433999,100933,144199,131099,42299,422999,32299,322999,3229999,50399,4999,49999,499999,1277,12777,42599,10399,103999,1799,2577,8599,85999,859999,175511,250733,433,4333,6199,61999,5211,1933,19333,193333,3899,5577,133,199,1999,19999,28577,411}

复制代码

10^9,最大长度是  429872893 迭代到入口411的时候停止,此时长度是60,

1. {429872893,4298728933,42987289333,1134229277,11342292777,12602547533,12556099,125560999,1255609999,10020833,100208333,1002083333,143211,477377,280811,2808111,550611,203933,43399,433999,100933,144199,131099,42299,422999,32299,322999,3229999,50399,4999,49999,499999,1277,12777,42599,10399,103999,1799,2577,8599,85999,859999,175511,250733,433,4333,6199,61999,5211,1933,19333,193333,3899,5577,133,199,1999,19999,28577,411}

复制代码

l4m2

我程序：

1. // g++ -o c.exe -O2 -march=native c.cpp
   
2. // f[n_]:=Print[NestWhileList[With[{p=FactorInteger[#][[-1,1]]},10 p+Mod[p,10]]&,n,# != 233 &]]
   
3. 
   
4. #include <thread>
   
5. #include <stdio.h>
   
6. #include <time.h>
   
7. #include <vector>
   
8. #include <atomic>
   
9. #include <bitset>
   
10. using u8 = unsigned char;
    
11. using u32 = unsigned;
    
12. using u64 = unsigned long long;
    
13. using u128 = __uint128_t;
    
14. // Don't support -1ULL/val, /1
    
15. struct V4div {
    
16.         u32 val;
    
17.         u8 shift, inc;
    
18.         u64 mult;
    
19.         V4div() = default;
    
20.         V4div(u32 val): val(val) {
    
21.                 shift = 63 - __builtin_clzll(val);
    
22.                 if ((val & (val - 1) )== 0) {
    
23.                         shift--;
    
24.                         inc = 0;
    
25.                         mult = 1ULL << 63;
    
26.                         return; }
    
27.                 u64 s = 0;
    
28.                 u64 r = 1ULL << shift; // fprintf(stderr, "* %llu %llu\n", s, r);
    
29.                 asm("div %2": "+a"(s), "+d"(r): "r"((u64)val));
    
30.                 if (r <= val / 2) {
    
31.                         mult = s;
    
32.                         inc = 1;
    
33.                 } else {
    
34.                         mult = s + 1;
    
35.                         inc = 0; }
    
36.         }
    
37.         friend u64 operator/(u64 a, V4div b) {
    
38.                 return (u64)((a + b.inc) * (u128)b.mult >> 64) >> b.shift;
    
39.         }
    
40.         friend u32 operator%(u64 a, V4div b) {
    
41.                 return a - a / b * b.val;
    
42.         }
    
43. };
    
44. std::vector<V4div> Primes;
    
45. 
    
46. 
    
47. 
    
48. static const unsigned M = 1000000, THC = 21;
    
49. std::atomic<long long> Pbb = 100000000000ULL - M;
    
50. 
    
51. u64 Gprimes(u64 x) {
    
52.         long long ret = 1;
    
53.         for (V4div i: Primes) {
    
54.                 if (x < (u64 )i.val * i.val) break;
    
55.                 while (x % i == 0) {
    
56.                         ret = i.val;
    
57.                         x = x / i;
    
58.                 }
    
59.         }
    
60.         if (x > ret) ret = x;
    
61. Retn:
    
62.         return ret;
    
63. }
    
64. bool isPrime(unsigned long long i) {
    
65. 
    
66.                 for (V4div j: Primes) {
    
67.                         if (i % j == 0) return false;
    
68.                         if (i / j < j.val) return true;
    
69.                 }return true;
    
70. }
    
71. FILE* output = fopen("bad3.txt", "w");
    
72. void f() {
    
73.   while (1) {
    
74.     unsigned long long  lb = Pbb += M;
    
75.     fprintf(stderr , "%lld @ %ld\r", lb, clock()); if (lb > 1000000000000ULL) return;
    
76.         for (unsigned long long  i=lb; i<lb+M; ++i) {
    
77.                 if (!isPrime(i)) continue;
    
78.                 unsigned long long  j=i;
    
79.                 int rdo = 0;
    
80.                 while (j >= i) {
    
81.                         if (j > 1ULL << 60) {
    
82.                                 fprintf(output , "ERROR OV i=%llu j=%llu\n", i,j); fflush(output);
    
83.                                 goto fat;}
    
84.                         if (rdo++==100) {
    
85.                                 fprintf(output , "ERROR TLE i=%llu j=%llu\n", i,j); fflush(output);
    
86.                                 goto fat;}
    
87.                         j = j * 10 + j % 10;
    
88.                         j = Gprimes(j);
    
89.                 }
    
90.                 if (rdo > 10) fprintf(output , "MSG TIME i=%llu j=%llu k=%d\n", i,j, rdo); fflush(output);
    
91.                 fat:;
    
92.         }
    
93. }}
    
94.                
    
95. 
    
96. int main() {
    
97. #if 0
    
98.         std::bitset<-1U>& btpm = *new std::bitset<-1U>;
    
99.         Primes.reserve(1<<28);
    
100.         Primes.emplace_back(2);
     
101.         Primes.emplace_back(3);
     
102.         for (unsigned i = 5; i < -1U; ++i) {
     
103.                 if (btpm[i] == 0) {
     
104.                         Primes.emplace_back(i);
     
105.                         for (unsigned long long j = i; j < -1U; j += i) btpm[j]=1; }
     
106.                 NotPrime: ;
     
107.                 if (i % 65536 == 0) fprintf(stderr, "P.%u\r", i);
     
108.         }
     
109.         delete &btpm;
     
110.         printf("%zu Primes found\n", Primes.size());
     
111. {FILE*pm=fopen("primes.dat","wb");fwrite(Primes.data(),sizeof(*Primes.data()),Primes.size(),pm);fclose(pm);}
     
112. #else
     
113. {FILE*pm=fopen("primes.dat","rb");Primes.resize(203280224);fread(Primes.data(),sizeof(*Primes.data()),Primes.size(),pm);fclose(pm);}printf("read Primes in %ld\n", clock());
     
114. #endif
     
115.         std::thread Th[THC];
     
116.         for (int i=0; i<THC; ++i) {
     
117.                 Th[i] = std::thread(f);
     
118.         }
     
119.         f();
     
120.         for (int i=0; i<THC; ++i) {
     
121.                 Th[i].join();
     
122.         }
     
123. }

复制代码

需要调整THC（使用核数-1）和int main()后的#if 0控制生成素数表还是读文件

wayne

用大模型写的rust代码,多核, 稍微手工改了下, 关于找最大素因子的部分,可以用素数表来继续优化/

1. use rayon::prelude::*;
   
2. use serde::Serialize;
   
3. use std::fs::File;
   
4. use std::io::Write;
   
5. use indicatif::ProgressBar;
   
6. 
   
7. #[derive(Serialize, Debug, Clone)]
   
8. struct Result {
   
9.     number: i64,
   
10.     steps: u32,
    
11. }
    
12. 
    
13. // 找出一个数的最大素因子
    
14. fn largest_prime_factor(mut n: i64) -> i64 {
    
15.     if n <= 1 {
    
16.         return -1;
    
17.     }
    
18. 
    
19.     let mut max_prime = -1;
    
20. 
    
21.     // 处理因子2
    
22.     while n % 2 == 0 {
    
23.         max_prime = 2;
    
24.         n /= 2;
    
25.     }
    
26. 
    
27.     // 处理因子3
    
28.     while n % 3 == 0 {
    
29.         max_prime = 3;
    
30.         n /= 3;
    
31.     }
    
32. 
    
33.     // 轮式分解，步长6
    
34.     let mut i = 5;
    
35.     while i * i <= n {
    
36.         while n % i == 0 {
    
37.             max_prime = i;
    
38.             n /= i;
    
39.         }
    
40.         while n % (i + 2) == 0 {
    
41.             max_prime = i + 2;
    
42.             n /= i + 2;
    
43.         }
    
44.         i += 6;
    
45.     }
    
46. 
    
47.     // 如果剩余的n > 1，则n本身是素数
    
48.     if n > 1 {
    
49.         max_prime = n;
    
50.     }
    
51. 
    
52.     max_prime
    
53. }
    
54. 
    
55. // 根据素因子生成新数字
    
56. fn next_number(prime_factor: i64) -> i64 {
    
57.     prime_factor * 10 + (prime_factor % 10)
    
58. }
    
59. 
    
60. // 计算从给定数字开始迭代到目标数的步数
    
61. // 返回 (步数, 是否成功到达目标数)
    
62. fn count_iterations(start: i64, target: i64) -> (u32, bool) {
    
63.     let mut current = start;
    
64.     let mut steps = 0u32;
    
65.     let max_iterations = 10000; // 防止无限循环
    
66. 
    
67.     while current != target && steps < max_iterations {
    
68.         let prime = largest_prime_factor(current);
    
69.         if prime <= 0 {
    
70.             return (steps, false);
    
71.         }
    
72. 
    
73.         current = next_number(prime);
    
74.         steps += 1;
    
75.     }
    
76. 
    
77.     if current == target {
    
78.         (steps, true)
    
79.     } else {
    
80.         (steps, false)
    
81.     }
    
82. }
    
83. 
    
84. // 输出迭代过程（调试用）
    
85. fn print_iteration_path(start: i64, target: i64) {
    
86.     println!("开始数字: {}", start);
    
87.    
    
88.     let mut current = start;
    
89.     let mut steps = 0;
    
90.     let max_iterations = 10000;
    
91. 
    
92.     while current != target && steps < max_iterations {
    
93.         let prime = largest_prime_factor(current);
    
94.         if prime <= 0 {
    
95.             println!("  无法继续，找不到素因子");
    
96.             break;
    
97.         }
    
98. 
    
99.         let new_num = next_number(prime);
    
100.         println!("  {} -> 素因子: {} -> {}", current, prime, new_num);
     
101. 
     
102.         current = new_num;
     
103.         steps += 1;
     
104.     }
     
105. 
     
106.     if current == target {
     
107.         println!("  ✓ 到达{}，用时 {} 步\n", target, steps);
     
108.     } else {
     
109.         println!("  ✗ 未到达{}\n", target);
     
110.     }
     
111. }
     
112. 
     
113. // 导出为JSON格式
     
114. fn export_to_json(results: &[(i64, u32)], filename: &str) -> std::io::Result<()> {
     
115.     let json_results: Vec<Result> = results
     
116.         .iter()
     
117.         .map(|(number, steps)| Result {
     
118.             number: *number,
     
119.             steps: *steps,
     
120.         })
     
121.         .collect();
     
122.    
     
123.     let json = serde_json::to_string_pretty(&json_results)
     
124.         .expect("Failed to serialize to JSON");
     
125.    
     
126.     let mut file = File::create(filename)?;
     
127.     file.write_all(json.as_bytes())?;
     
128.    
     
129.     println!("✓ 已导出到: {}", filename);
     
130.     Ok(())
     
131. }
     
132. 
     
133. // 导出为CSV格式
     
134. fn export_to_csv(results: &[(i64, u32)], filename: &str) -> std::io::Result<()> {
     
135.     let mut wtr = csv::Writer::from_path(filename)
     
136.         .expect("Failed to create CSV writer");
     
137.    
     
138.     // 写入头部
     
139.     wtr.write_record(&["number", "steps"])
     
140.         .expect("Failed to write CSV header");
     
141.    
     
142.     // 写入数据
     
143.     for (number, steps) in results {
     
144.         wtr.write_record(&[number.to_string(), steps.to_string()])
     
145.             .expect("Failed to write CSV record");
     
146.     }
     
147.    
     
148.     wtr.flush()?;
     
149.    
     
150.     println!("✓ 已导出到: {}", filename);
     
151.     Ok(())
     
152. }
     
153. 
     
154. fn main() {
     
155.     println!("素因子分解迭代程序 v2.0");
     
156.     println!("=================================\n");
     
157. 
     
158.     // 获取命令行参数
     
159.     let args: Vec<String> = std::env::args().collect();
     
160.    
     
161.     let mut min_num = 100i64;
     
162.     let mut max_num = 999i64;
     
163.     let mut target_num = 233i64;
     
164.     let mut export_json = false;
     
165.     let mut export_csv = false;
     
166.     let mut skip_examples = false;
     
167.     let mut sample_count: i64 = 0;
     
168.     let mut positional_args = Vec::new();
     
169. 
     
170.     // 解析参数
     
171.     let mut i = 1;
     
172.     while i < args.len() {
     
173.         match args[i].as_str() {
     
174.             "-h" | "--help" => {
     
175.                 println!("【使用方法】");
     
176.                 println!("  factorize [start] [end] [选项]");
     
177.                 println!("\n【范围参数】");
     
178.                 println!("  factorize 1000 2000   # 测试 1000 到 2000");
     
179.                 println!("  factorize 1000        # 测试 1000 (单个数)");
     
180.                 println!("  factorize 1000 --sample 50 # 测试从 1000 开始的 50 个数");
     
181.                 println!("\n【导出选项】");
     
182.                 println!("  --json          # 导出为JSON格式");
     
183.                 println!("  --csv           # 导出为CSV格式");
     
184.                 println!("  --target [num]  # 设置目标数字 (默认 233)");
     
185.                 println!("  --skip-examples # 跳过示例测试");
     
186.                 println!("\n【示例】");
     
187.                 println!("  factorize 10000 10100 --json");
     
188.                 std::process::exit(0);
     
189.             }
     
190.             "--target" => {
     
191.                 if i + 1 < args.len() {
     
192.                     if let Ok(n) = args[i+1].parse::<i64>() {
     
193.                         target_num = n;
     
194.                     }
     
195.                     i += 1;
     
196.                 }
     
197.             }
     
198.             "--json" => export_json = true,
     
199.             "--csv" => export_csv = true,
     
200.             "--skip-examples" => skip_examples = true,
     
201.             "--sample" => {
     
202.                 if i + 1 < args.len() {
     
203.                     if let Ok(n) = args[i+1].parse::<i64>() {
     
204.                         sample_count = n;
     
205.                     }
     
206.                     i += 1;
     
207.                 }
     
208.             }
     
209.             arg => {
     
210.                 if !arg.starts_with('-') {
     
211.                     positional_args.push(arg);
     
212.                 }
     
213.             }
     
214.         }
     
215.         i += 1;
     
216.     }
     
217. 
     
218.     // 处理位置参数 (范围)
     
219.     if !positional_args.is_empty() {
     
220.         if let Ok(start) = positional_args[0].parse::<i64>() {
     
221.             min_num = start;
     
222.             max_num = start; // 默认为单个数
     
223.             
     
224.             if positional_args.len() >= 2 {
     
225.                 if let Ok(end) = positional_args[1].parse::<i64>() {
     
226.                     max_num = end;
     
227.                 }
     
228.             }
     
229.         }
     
230.     }
     
231. 
     
232.     // 如果指定了 sample_count，覆盖 max_num
     
233.     if sample_count > 0 {
     
234.         max_num = min_num + sample_count - 1;
     
235.     }
     
236.    
     
237.     // 确保 max >= min
     
238.     if max_num < min_num {
     
239.         max_num = min_num;
     
240.     }
     
241. 
     
242.     let total_count = max_num - min_num + 1;
     
243. 
     
244.     // 示例测试（可跳过）
     
245.     if !skip_examples {
     
246.         println!("【示例测试】");
     
247.         let test_numbers = vec![100, 77, 2, 10];
     
248.         for &start in &test_numbers {
     
249.             print_iteration_path(start, target_num);
     
250.         }
     
251.     }
     
252. 
     
253.     // 多线程测试指定位数，带进度条
     
254.     println!("\n【多线程测试范围 {}-{}】", min_num, max_num);
     
255.     println!("正在计算中...\n");
     
256. 
     
257.     let start_time = std::time::Instant::now();
     
258.    
     
259.     // 创建进度条
     
260.     let pb = ProgressBar::new(total_count as u64);
     
261.     pb.set_style(
     
262.         indicatif::ProgressStyle::default_bar()
     
263.             .template("{spinner:.green} [{wide_bar:.cyan/blue}] {pos}/{len} ({percent}%) ETA: {eta}")
     
264.             .unwrap()
     
265.             .tick_strings(&["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]),
     
266.     );
     
267.    
     
268.     // 使用rayon进行并行处理
     
269.     // 对于非常大的范围（例如9位数），一次性收集所有结果会消耗大量内存。
     
270.     // 当数据量超过阈值时，采用流式聚合（仅保留top-k和计数）以节省内存。
     
271.     let mut results: Vec<(i64, u32)> = Vec::new();
     
272.     let mut success_count: usize = 0;
     
273.     let threshold: i64 = 5_000_000; // 超过该值时使用流式聚合以节省内存
     
274. 
     
275.     if total_count > threshold {
     
276.         // 流式聚合：计算成功数量并保留前 k 个最长的记录
     
277.         let k = 100usize;
     
278.         let (topk, count) = (min_num..=max_num)
     
279.             .into_par_iter()
     
280.             .inspect(|_| { pb.inc(1); })
     
281.             .filter_map(|num| {
     
282.                 let (steps, success) = count_iterations(num, target_num);
     
283.                 if success { Some((num, steps)) } else { None }
     
284.             })
     
285.             .fold(
     
286.                 || (Vec::<(i64, u32)>::new(), 0usize),
     
287.                 |mut acc, item| {
     
288.                     acc.1 += 1usize;
     
289.                     acc.0.push(item);
     
290.                     if acc.0.len() > k {
     
291.                         acc.0.sort_by(|a, b| b.1.cmp(&a.1));
     
292.                         acc.0.truncate(k);
     
293.                     }
     
294.                     acc
     
295.                 },
     
296.             )
     
297.             .reduce(
     
298.                 || (Vec::<(i64, u32)>::new(), 0usize),
     
299.                 |mut a, b| {
     
300.                     a.1 += b.1;
     
301.                     a.0.extend(b.0);
     
302.                     a.0.sort_by(|x, y| y.1.cmp(&x.1));
     
303.                     if a.0.len() > k { a.0.truncate(k); }
     
304.                     a
     
305.                 },
     
306.             );
     
307. 
     
308.         results = topk;
     
309.         success_count = count;
     
310.     } else {
     
311.         results = (min_num..=max_num)
     
312.             .into_par_iter()
     
313.             .inspect(|_| { pb.inc(1); })
     
314.             .filter_map(|num| {
     
315.                 let (steps, success) = count_iterations(num, target_num);
     
316.                 if success { Some((num, steps)) } else { None }
     
317.             })
     
318.             .collect();
     
319.         success_count = results.len();
     
320.     }
     
321.    
     
322.     pb.finish_with_message("完成！");
     
323. 
     
324.     let elapsed = start_time.elapsed();
     
325. 
     
326.     // 找出最大迭代步数和对应的数字
     
327.     let (max_number, max_steps) = results
     
328.         .iter()
     
329.         .max_by_key(|(_, steps)| steps)
     
330.         .copied()
     
331.         .unwrap_or((min_num, 0));
     
332. 
     
333.     // 统计信息
     
334.     println!("统计结果：");
     
335.     println!("  总共测试的数量：{} 个", total_count);
     
336.     println!("  成功到达{}的数字：{} 个", target_num, success_count);
     
337.     println!("  最大迭代步数：{} 步", max_steps);
     
338.     println!("  迭代最长的数字：{}\n", max_number);
     
339.     println!("  总耗时：{:.3} 秒\n", elapsed.as_secs_f64());
     
340. 
     
341.     // 显示前10个迭代最长的数字
     
342.     // 根据运行规模输出前 N 条（大规模时输出前100）
     
343.     let top_n = std::cmp::min(results.len(), 100);
     
344.     println!("【迭代步数最长的前{}个数字】", top_n);
     
345.     results.sort_by(|a, b| b.1.cmp(&a.1));
     
346.     for (i, &(num, steps)) in results.iter().take(top_n).enumerate() {
     
347.         println!("  {}. {} -> {} 步", i + 1, num, steps);
     
348.     }
     
349. 
     
350.     // 显示最长的迭代详细过程
     
351.     println!("\n【最长迭代过程详情】");
     
352.     print_iteration_path(max_number, target_num);
     
353.    
     
354.     // 导出功能
     
355.     if export_json {
     
356.         println!("\n【数据导出】");
     
357.         if let Err(e) = export_to_json(&results, &format!("results_{}_{}_{}.json", target_num, min_num, max_num)) {
     
358.             println!("✗ 导出JSON失败: {}", e);
     
359.         }
     
360.     }
     
361.    
     
362.     if export_csv {
     
363.         if let Err(e) = export_to_csv(&results, &format!("results_{}_{}_{}.csv", target_num,min_num, max_num)) {
     
364.             println!("✗ 导出CSV失败: {}", e);
     
365.         }
     
366.     }
     
367. }
     

复制代码

l4m2

12位跑完了。
文件格式：
MSG TIME i=<int> j=<int> k=<int> 从i到第一次小于i，位置是j，需要k步。仅记录k>10的情况。
ERROR OV i=<int> j=<int> 超过2^60的情况下试图*10，可能发生溢出。需要用其他手段（如Mathematica）测试