正整数A×颠倒数(A)=正整数B×颠倒数(B)

nyy

4669*9664=45121216，6496*6946=45121216，
4669中有1个4,2个6,1个9，6496后面也是有1个4,2个6,1个9

wayne

2组多没意思, 三组,四组才有趣.这是n<10^8的所有四组的解.

1. 104645899008->{123648,216384,232944,256704,407652,449232,483612,846321}
   
2. 5918942844864->{1224384,1466304,2142672,2306652,2566032,2762412,4036641,4834221}
   
3. 10358850853008->{1226448,2146284,2416824,2449224,4229442,4286142,4826412,8446221}
   
4. 5750892433944->{1237464,1347624,2165562,2358342,2438532,2655612,4267431,4647321}
   
5. 6011342752464->{1237584,1336944,2165772,2339652,2569332,2775612,4496331,4857321}
   
6. 6628869866304->{1358784,1479744,2377872,2559852,2589552,2787732,4479741,4878531}
   
7. 992718536062968->{11224488,20332884,22118844,24776004,40067742,44881122,48823302,88442211}
   
8. 949922356872528->{11246448,20372664,22459224,23348604,40684332,42295422,46627302,84464211}
   
9. 549403549738524->{11336484,13576404,20535762,22339542,24593322,26753502,40467531,48463311}
   
10. 527365570997304->{11347464,12357624,20555652,22385532,23558322,25655502,42675321,46474311}
    
11. 539305912694304->{11549664,12577824,21758742,22759632,23695722,24785712,42877521,46694511}
    
12. 562411024867944->{12156264,13238424,21273462,23167242,24276132,26437212,42483231,46265121}
    
13. 587944983082464->{12156384,14558304,21273672,23077452,25477032,27637212,40385541,48365121}
    
14. 1024553546227008->{12157248,21275184,23196144,25239504,40593252,44169132,48157212,84275121}
    
15. 546920672687424->{12231744,13562304,21405552,23043732,23734032,25550412,40326531,44713221}
    
16. 1033559135533008->{12242448,21424284,24124824,24481224,42218442,42842142,48242412,84424221}
    
17. 568992308855544->{12253464,13465224,21443562,23564142,24146532,26534412,42256431,46435221}
    
18. 340011357444612->{12254772,13238652,14676132,15854412,21445851,23167641,25683231,27745221}
    
19. 1042418529479808->{12344448,22361664,23656044,24325824,42852342,44065632,46616322,84444321}
    
20. 860426716976316->{12373596,13597236,21653793,23795163,36159732,39735612,63279531,69537321}
    
21. 579899832100344->{12375864,13587624,21657762,23778342,24387732,26775612,42678531,46857321}
    
22. 610687106376984->{13212264,14532024,23121462,24013452,25431042,26412132,42023541,46221231}
    
23. 909936112971366->{13274586,14587326,26158743,28745613,31654782,34785162,62378541,68547231}
    
24. 623987609046984->{13323864,14773224,23316762,24135852,25853142,26761332,42237741,46832331}
    
25. 645125317087104->{13344384,14415744,23352672,25227552,25572252,27625332,44751441,48344331}
    
26. 621631023436584->{13369464,14559624,23396562,24397452,25479342,26569332,42695541,46496331}
    
27. 1134871023647088->{13442448,23524284,24350664,26631624,42613662,46605342,48242532,84424431}
    
28. 655859245091904->{13454784,14785344,23545872,25347852,25874352,27854532,44358741,48745431}
    
29. 1083163569127848->{13464408,22536084,24390444,26532804,40823562,44409342,48063522,80446431}
    
30. 1137462800807088->{13466448,23566284,24493464,26536824,42863562,46439442,48266532,84466431}
    
31. 1147980114425088->{13563648,23736384,25552944,25671744,44717652,44925552,48363732,84636531}
    
32. 1095191446714848->{13576608,23391864,23759064,26753904,40935762,46095732,46819332,80667531}
    
33. 976614697896526->{14313286,15743026,26014573,28613143,34131682,37541062,62034751,68231341}
    
34. 999088058982636->{14412396,15852036,25221693,27741063,36014772,39612252,63025851,69321441}
    
35. 670341346809624->{14555064,15723624,24361572,25471362,26317452,27516342,42632751,46055541}
    
36. 1244465038752768->{14773248,25550784,25853184,27831744,44713872,48135852,48705552,84237741}
    
37. 1026761738613156->{15615756,15756156,27327573,27573273,37237572,37572372,65165751,65751651}
    
38. 1462434833657448->{16816968,16968168,29429694,29694294,49249692,49692492,86186961,86961861}
    
39. 1835678214590976->{21728448,22756608,40934844,42817824,42871824,44843904,80665722,84482712}
    
40. 1564048900490832->{23185476,25478316,35078544,38547504,40574583,44587053,61387452,67458132}
    
41. 1701426323612232->{24386796,26798436,36279864,39867624,42676893,46897263,63489762,69768342}
    
42. 1749116423979792->{25224396,27744036,36025584,39624144,44142693,48552063,63044772,69342252}
    
43. 1875177765804672->{27627876,27876276,38438784,38784384,48348783,48783483,67267872,67872672}
    

复制代码

nyy

nyy 发表于 2025-2-24 10:20
再加两句

代码

1. Clear["Global`*"];(*mathematica11.2,win7(64bit)Clear all variables*)
   
2. aaa=
   
3. {{144, 252, 63504}, {156, 273, 101556}, {168, 294, 144648}, {276, 384,
   
4.    185472}, {1224, 2142, 5166504}, {1236, 2163, 7812756}, {1248, 2184,
   
5.    10509408}, {1326, 2613, 8262306}, {1339, 3193, 12494209}, {1344,
   
6.   2352, 5955264}, {1356, 2373, 8856036}, {1368, 2394,
   
7.   11807208}, {1428, 2814, 11768148}, {1456, 2743, 9523696}, {1464,
   
8.   2562, 6794424}, {1476, 2583, 9949716}, {1568, 2954,
   
9.   13564768}, {1584, 2772, 7683984}, {1586, 2873, 10865686}, {1596,
   
10.   2793, 11093796}, {2316, 3504, 14201712}, {2328, 4074,
    
11.   19164096}, {2346, 3264, 15089472}, {2369, 3296, 22818208}, {2436,
    
12.   3624, 15449112}, {2448, 4284, 20666016}, {2556, 3744,
    
13.   16746912}, {2568, 4494, 22218336}, {2576, 3584, 17393152}, {2639,
    
14.   3926, 24706318}, {2676, 3864, 18095112}, {2796, 3984,
    
15.   19493712}, {3468, 4386, 29973924}, {3528, 4716, 29116584}, {3648,
    
16.   4836, 30873024}, {3768, 4956, 32679864}, {4439, 6176,
    
17.   41478016}, {4669, 6496, 45121216}}
    
18. bbb=Select[aaa,Sort@IntegerDigits[#[[1]]]==Sort@IntegerDigits[#[[2]]]&]
    
19. Grid[bbb,Alignment->Left](*列表显示*)
    

复制代码

选出后
{{1224, 2142, 5166504}, {1236, 2163, 7812756}, {1248, 2184,
  10509408}, {1326, 2613, 8262306}, {1339, 3193, 12494209}, {1428,
  2814, 11768148}, {2346, 3264, 15089472}, {2369, 3296,
  22818208}, {2436, 3624, 15449112}, {2448, 4284, 20666016}, {2639,
  3926, 24706318}, {3468, 4386, 29973924}, {3648, 4836,
  30873024}, {4669, 6496, 45121216}}

列表
\[\begin{array}{lll}
1224 & 2142 & 5166504 \\
1236 & 2163 & 7812756 \\
1248 & 2184 & 10509408 \\
1326 & 2613 & 8262306 \\
1339 & 3193 & 12494209 \\
1428 & 2814 & 11768148 \\
2346 & 3264 & 15089472 \\
2369 & 3296 & 22818208 \\
2436 & 3624 & 15449112 \\
2448 & 4284 & 20666016 \\
2639 & 3926 & 24706318 \\
3468 & 4386 & 29973924 \\
3648 & 4836 & 30873024 \\
4669 & 6496 & 45121216 \\
\end{array}\]

wayne

wayne 发表于 2025-2-24 10:34
2组多没意思, 三组,四组才有趣.

为了加速,砍掉不必要的计算,比如末尾是0的,逆序小于本身的情况,同时开启多线程,并且提前返回结果

1. n = 8; SetSharedVariable[lst];
   
2. lst = {}; Monitor[
   
3. ParallelDo[tmpI = ht[[1]]*10^(n - 1) + i*10 + ht[[2]];
   
4.   revI = IntegerReverse[tmpI];
   
5.   If[revI >= tmpI, ii = tmpI*revI; divs = Divisors[ii];
   
6.    tmp = Select[divs[[1 ;; Ceiling[Length[divs]/2]]],
   
7.      IntegerLength[#] == n && IntegerReverse[ii/#] == # &];
   
8.    If[Length[tmp] > 3, Print[{ii -> tmp, i}];
   
9.     AppendTo[lst, ii -> tmp]]], {i, 0, 10^(n - 2) - 1}, {ht,
   
10.    Union[Map[Sort, Tuples[Range[9], {2}]]]}], {Length[lst]}]

复制代码

然后跑了一晚上, 搜索大于四组的在$n<10^9$内没有, 但再继续下去在$10^9<n<10^{10}$就有了.,找到了第一个5组解乘积为10119126106147652568,第一个6组解的乘积是6262460089931994984, 第一个7组解的乘积是5918858243794044864

1. Block[{ii=5918858243794044864,divs},divs=Divisors[ii];ii->Table[Sort[{ii/p,p}],{p,Select[divs[[1;;Length[divs]/2]],IntegerReverse[ii/#]==#&]}]]

复制代码

1. 10119126106147652568->{{1143628488,8848263411},{1257864408,8044687521},{2071654884,4884561702},{2278590444,4440958722},{2478732804,4082378742}}

复制代码

1. 6262460089931994984->{{1335519864,4689155331},{1359755064,4605579531},{1468923624,4263298641},{2163464982,2894643612},{2337159762,2679517332},{2379571362,2631759732}}
   
2. 6752888285764008024->{{1452289464,4649822541},{1466783064,4603876641},{1597357224,4227537951},{2333753982,2893573332},{2415735972,2795375142},{2566870362,2630786652}}

复制代码

1. 5918858243794044864->{{1224264384,4834624221},{1333249344,4439423331},{1466426304,4036246641},{2142462672,2762642412},{2306426652,2566246032},{2333186352,2536813332},{2356471152,2511746532}}

复制代码

nyy

wayne 发表于 2025-2-25 07:03
为了加速,砍掉不必要的计算,比如末尾是0的,逆序小于本身的情况,同时开启多线程,并且提前返回结果

你的算法的原理是怎么样的！？

northwolves

{2,{144,252},63504}}
{3,{13248,23184,27504},1115892288},
{4,{123648,216384,232944,256704},104645899008}
{5,{1143628488,1257864408,2071654884,2278590444,2478732804},10119126106147652568}
{6,{1335519864,1359755064,1468923624,2163464982,2337159762,2379571362},6262460089931994984}
{7,{1224264384,1333249344,1466426304,2142462672,2306426652,2333186352,2356471152},5918858243794044864}
{8, {12253574772,3237358652,13344397452,13477572252,14415758532,14559625332,14677356132,15855734412},340006497569227044612}

nyy

northwolves 发表于 2025-2-25 12:24
{2,{144,252},63504}}
{3,{13248,23184,27504},1115892288},
{4,{123648,216384,232944,256704},1046458990 ...

代码呢？算法原理呢？难道是穷举法吗？

wayne

最开始的版本虽然非常快,但是占用内存也线性增加,最后到了超过计算机内存20GB,靠跟硬盘交换空间才能维持. 现在 给一个基本不占用内存的rust实现, 但速度比较慢, 基本上是稳定的1分钟处理10万个有效的大整数的分解.

1. use chrono::Local;
   
2. use std::collections::*;
   
3. use rayon::prelude::*;
   
4. use std::thread;
   
5. use std::env;
   
6. 
   
7. fn find_prime_factors(mut n: u64) -> Vec<u64> {
   
8.     let primes: Vec<u64> = vec![
   
9.         2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89,
   
10.     ];
    
11.     let mut factors = Vec::new();
    
12.     for p in primes {
    
13.         if p * p > n {
    
14.             break;
    
15.         }
    
16.         while n % p == 0 {
    
17.             factors.push(p);
    
18.             n /= p;
    
19.         }
    
20.     }
    
21.     let mut divisor= 97;
    
22.     while n > 1 {
    
23.         while n % divisor == 0 {
    
24.             factors.push(divisor);
    
25.             n /= divisor;
    
26.         }
    
27.         if divisor * divisor > n {
    
28.             break;
    
29.         }
    
30.         divisor += 2;
    
31.     }
    
32.     if n>1{
    
33.         factors.push(n);
    
34.     }
    
35.     factors
    
36. }
    
37. 
    
38. fn find_divisors_optimized(n: u64) -> BTreeSet<u64> {
    
39.     let prime_factors = find_prime_factors(n);
    
40.     let mut divisors = BTreeSet::new();
    
41.     divisors.insert(1);
    
42.     for factor in prime_factors {
    
43.         let new_divisors: BTreeSet<u64> = divisors.iter().map(|&d| d * factor).collect();
    
44.         divisors.extend(new_divisors);
    
45.     }
    
46.     divisors
    
47. }
    
48. 
    
49. fn get_first_half_with_middle<T: Clone>(vec: &Vec<T>) -> Vec<T> {
    
50.     let half_len = (vec.len() + 1) / 2; // 向上取整
    
51.     vec.iter().take(half_len).cloned().collect()
    
52. }
    
53. fn reverse_integer(mut n: u64) -> u64 {
    
54.     let mut reversed = 0;
    
55.     while n > 0 {
    
56.         reversed = reversed * 10 + n % 10;
    
57.         n /= 10;
    
58.     }
    
59.     reversed
    
60. }
    
61. 
    
62. fn check(n:usize,number:u64)->Vec<(u64, u64)>{
    
63.     let divisors: BTreeSet<u64> = find_divisors_optimized(number);
    
64.     let divisors_half= get_first_half_with_middle(&divisors.iter().cloned().collect());
    
65.     let divisors_n: Vec<(u64, u64)>  = divisors_half.iter().filter_map(|&d| {
    
66.         let digit_count = d.to_string().len();
    
67.         let d_reversed = reverse_integer(d);
    
68.         if digit_count == n && d_reversed==(number/d){
    
69.             Some((d,d_reversed))
    
70.         } else {
    
71.             None
    
72.         }
    
73.     }).collect();
    
74.     divisors_n
    
75. }
    
76. 
    
77. fn compute_task(i:u64,n:usize,n_filter:usize){
    
78.     if i%10!=0{
    
79.         let reversed_i = reverse_integer(i);
    
80.         if reversed_i>=i {
    
81.             let product = i * reversed_i;
    
82.             let divisors = check(n,product);
    
83.             if divisors.len()>=n_filter{
    
84.                 println!("[{}] {} {} -> {:?}", i, divisors.len(), product, divisors);
    
85.             }
    
86.         }
    
87.     } else if i%10000==0{
    
88.         eprintln!("[{}][{}]--------------------{:?}",Local::now().format("%Y-%m-%d %H:%M:%S%.3f"), i,thread::current().id());
    
89.     }
    
90. }
    
91. 
    
92. fn main() {
    
93.     let args: Vec<String> = env::args().collect();
    
94.     if args.len() < 3 {
    
95.         eprintln!("Usage: {} <n> <n_filter>", args[0]);
    
96.         std::process::exit(1);
    
97.     }
    
98.     let n :u32= args[1].parse::<u32>().expect("failed to parse");
    
99.     let progress_span:u64 = 10u64.pow(n-1);
    
100.     let n_filter :u32= args[2].parse::<u32>().expect("failed to parse");
     
101. 
     
102.     (1*progress_span..10*progress_span).into_par_iter().for_each(|i:u64| {
     
103.         compute_task(i,n as usize,n_filter as usize);
     
104.     });
     
105. 
     
106. }
     

复制代码

附件是已经编译好了的可执行程序.
说明: 程序必须传入两个参数, 第一个参数是要搜索的整数的位数,第二个是要搜索的组数. 比如,我要搜索全部的六位数的三组及以上的解,如下 primes.exe 6 3

1. primes.exe 6 3
   
2. [216384] 4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
   
3. [279624] 3 119391618528 -> [(134688, 886431), (243984, 489342), (279624, 426972)]
   
4. [254772] 3 70687000944 -> [(145584, 485541), (158544, 445851), (254772, 277452)]
   
5. [158544] 3 70687000944 -> [(145584, 485541), (158544, 445851), (254772, 277452)]
   
6. [256704] 4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
   
7. [134688] 3 119391618528 -> [(134688, 886431), (243984, 489342), (279624, 426972)]
   
8. [123648] 4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
   
9. [232944] 4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
   
10. [145584] 3 70687000944 -> [(145584, 485541), (158544, 445851), (254772, 277452)]
    
11. [243984] 3 119391618528 -> [(134688, 886431), (243984, 489342), (279624, 426972)]

复制代码

由于7位数开始,速度略慢,需要等待,为了显示程序运行的进度,证明程序还活着,可以再添加一个可选的参数,true或者false,表示是否打印进度

1. E:\coding\rust\ddd\target\release>primes.exe 6 4 true
   
2. [2025-02-26 11:41:15.871][100000]--------------------ThreadId(12)
   
3. [2025-02-26 11:41:15.871][250000]--------------------ThreadId(7)
   
4. [2025-02-26 11:41:15.871][400000]--------------------ThreadId(4)
   
5. [2025-02-26 11:41:15.871][300000]--------------------ThreadId(3)
   
6. [2025-02-26 11:41:15.871][150000]--------------------ThreadId(15)
   
7. [2025-02-26 11:41:15.871][200000]--------------------ThreadId(2)
   
8. [2025-02-26 11:41:15.871][350000]--------------------ThreadId(5)
   
9. [2025-02-26 11:41:15.964][390000]--------------------ThreadId(13)
   
10. [2025-02-26 11:41:15.969][340000]--------------------ThreadId(9)
    
11. [2025-02-26 11:41:15.986][240000]--------------------ThreadId(16)
    
12. [[216384] 4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
    
13. 2025-02-26 11:41:16.028][130000]--------------------ThreadId(11)
    
14. [2025-02-26 11:41:16.064][380000]--------------------ThreadId(14)
    
15. [2025-02-26 11:41:16.082][230000]--------------------ThreadId(6)
    
16. [2025-02-26 11:41:16.089][330000]--------------------[256704] 4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
    
17. ThreadId(10)
    
18. [2025-02-26 11:41:16.171][110000]--------------------ThreadId(12)
    
19. [2025-02-26 11:41:16.194][160000]--------------------ThreadId(15)
    
20. [2025-02-26 11:41:16.196][140000]--------------------ThreadId(9)
    
21. [2025-02-26 11:41:16.223[232944] 4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
    
22. ][220000]--------------------ThreadId(8)
    
23. [2025-02-26 11:41:16.232][310000]--------------------ThreadId(3)
    
24. [2025-02-26 11:41:16.256][410000]--------------------ThreadId(4)
    
25. [2025-02-26 11:41:16.269][360000]--------------------ThreadId(5)
    
26. [2025-02-26 11:41:16.285][210000]--------------------ThreadId(2)
    
27. [[123648] 4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
    
28. 2025-02-26 11:41:16.332][260000]--------------------ThreadId(7)
    
29. [2025-02-26 11:41:16.370][320000]--------------------ThreadId(11)
    
30. [2025-02-26 11:41:16.396][120000]--------------------ThreadId(8)
    
31. [2025-02-26 11:41:16.413][450000]--------------------ThreadId(3)
    
32. [2025-02-26 11:41:16.438][370000]--------------------ThreadId(10)
    
33. [2025-02-26 11:41:16.488][170000]--------------------ThreadId(15)
    
34. [2025-02-26 11:41:16.513][270000]--------------------ThreadId(16)
    
35. [2025-02-26 11:41:16.542][180000]--------------------ThreadId(9)
    
36. [2025-02-26 11:41:16.567][440000]--------------------ThreadId(11)
    
37. [2025-02-26 11:41:16.587][290000]--------------------ThreadId(7)
    
38. [2025-02-26 11:41:16.597][190000]--------------------ThreadId(14)
    
39. [2025-02-26 11:41:16.623][420000]--------------------ThreadId(5)
    
40. [2025-02-26 11:41:16.640][280000]--------------------ThreadId(6)
    
41. [2025-02-26 11:41:16.649][430000]--------------------ThreadId(17)
    
42. [2025-02-26 11:41:16.793][490000]--------------------ThreadId(11)
    
43. [2025-02-26 11:41:16.809][470000]--------------------ThreadId(4)
    
44. [2025-02-26 11:41:16.845][460000]--------------------ThreadId(10)
    
45. [2025-02-26 11:41:16.866][480000]--------------------ThreadId(15)

复制代码

静态编译的二进制.
primes.exe (421.5 KB, 下载次数: 9)

2025-2-28 20:20 上传

点击文件名下载附件

王守恩

一个晚上就是弄这两个？？？？？？？？没骗你！！！

正整数A×颠倒数A=正整数B×颠倒数B。譬如：144×441=252×252。譬如：168×861=294×492。我们不妨约定A是最小的那个。您也来一个？谢谢！

开始, 我列了个方程, 软件好像看不懂。

1. NSolve[{IntegerReverse[A]*A == IntegerReverse[B]*B}, {A, B}, Integers]

复制代码

NSolve::nsmet: This system cannot be solved with the methods available to NSolve.
我去找专业的FindInstance，给了1个解。

1. FindInstance[{IntegerReverse[A]*A == IntegerReverse[B]*B, 0 < A < 500, A < IntegerReverse[A], A < B < IntegerReverse[B]}, {A, B}, Integers, 1]

复制代码

{{A -> 168, B -> 294}}第2个解就不肯给了。

1. FindInstance[{IntegerReverse[A]*A == IntegerReverse[B]*B, 0 < A < 500, A < IntegerReverse[A], A < B < IntegerReverse[B]}, {A, B}, Integers, 2]

复制代码

FindInstance::nsmet: The methods available to FindInstance are insufficient to find the requested instances or prove they do not exist.

我去问问DeepSeek。(有据可查)

正整数A×颠倒数A=正整数B×颠倒数B,譬如：168×861=294×492。您也来一个？谢谢！

嗯，今天遇到了一个有趣的数学问题，题目是说找到两个正整数A和B，使得A乘以它的颠倒数等于B乘以它的颠倒数，比如例子里的168×861=294×492。用户让我也来一个这样的例子，所以现在我得仔细想想怎么解决这个问题。

首先，我得明确什么是“颠倒数”。比如168的颠倒数就是861，也就是把数字的各位数字顺序颠倒过来。那问题就是说，存在两个不同的数A和B，使得A×reverse(A) = B×reverse(B)，并且结果相等。现在需要找出这样的A和B对。

.........(省略)——已深度思考(用时513秒)

以下是一个满足条件的例子：A = 252，B = 441

验证：252的倒数是252（回文数），乘积为252 × 252 = 63,504。441的倒数是144，乘积为441 × 144 = 63,504

两者乘积相等，因此满足条件。（注：尽管252是回文数，但441与它不同，且颠倒后的144也不等于252，因此构成不同的数对。）

一个晚上就是弄这两个？？？？？？？？真没骗你！！！

这《数学研发论坛》是最好的！高手如云！！学习氛围很好！！！谢谢站长(经营挺不容易的)！！！！

这串数就是A——144, 156, 168, 276, 1224, 1236, 1248, 1326, 1339, 1344, 1356, 1368, 1428, 1456, 1464, 1476, 1568, 1584, 1586, 1596, 2316, 2346, 2369, 2436, 2556, 2576,

只是题目扩展一下: 正整数A×颠倒数A=正整数B×颠倒数B=正整数C×颠倒数C=正整数D×颠倒数D= ......,  。

我们约定A是最小的那个。凭这个A——可以有颠倒数A——可以有A×颠倒数A的积——可以有B——可以有C, 可以有D,  ......,  。

数论爱好者

王守恩 发表于 2025-2-26 10:34
一个晚上就是弄这两个？？？？？？？？没骗你！！！

正整数A×颠倒数A=正整数B×颠倒数B。譬如：144×441= ...

https://oeis.org/A117282
这有1万个乘积，满足正整数A×颠倒数A=正整数B×颠倒数B，问题是怎样求出A和B?
检验了一部分数据，大部分乘积能够被3和7整除，极个别乘积被7整除，不被3整除，是否能够断言：正整数A×颠倒数A=正整数B×颠倒数B，两组相同乘积的数都能够被7整除？
https://oeis.org/A066599
A (n) =最小的数，它可以用n种不同的方式表示为一个数及其反转的乘积。这里列出1-8组，举的例子有14组
你的条件苛刻一点，0不能作为颠倒数的首位
5组的不能被7整除