4669*9664=45121216，6496*6946=45121216，
4669中有1个4,2个6,1个9，6496后面也是有1个4,2个6,1个9
2组多没意思, 三组,四组才有趣.这是n<10^8的所有四组的解.
104645899008->{123648,216384,232944,256704,407652,449232,483612,846321}
5918942844864->{1224384,1466304,2142672,2306652,2566032,2762412,4036641,4834221}
10358850853008->{1226448,2146284,2416824,2449224,4229442,4286142,4826412,8446221}
5750892433944->{1237464,1347624,2165562,2358342,2438532,2655612,4267431,4647321}
6011342752464->{1237584,1336944,2165772,2339652,2569332,2775612,4496331,4857321}
6628869866304->{1358784,1479744,2377872,2559852,2589552,2787732,4479741,4878531}
992718536062968->{11224488,20332884,22118844,24776004,40067742,44881122,48823302,88442211}
949922356872528->{11246448,20372664,22459224,23348604,40684332,42295422,46627302,84464211}
549403549738524->{11336484,13576404,20535762,22339542,24593322,26753502,40467531,48463311}
527365570997304->{11347464,12357624,20555652,22385532,23558322,25655502,42675321,46474311}
539305912694304->{11549664,12577824,21758742,22759632,23695722,24785712,42877521,46694511}
562411024867944->{12156264,13238424,21273462,23167242,24276132,26437212,42483231,46265121}
587944983082464->{12156384,14558304,21273672,23077452,25477032,27637212,40385541,48365121}
1024553546227008->{12157248,21275184,23196144,25239504,40593252,44169132,48157212,84275121}
546920672687424->{12231744,13562304,21405552,23043732,23734032,25550412,40326531,44713221}
1033559135533008->{12242448,21424284,24124824,24481224,42218442,42842142,48242412,84424221}
568992308855544->{12253464,13465224,21443562,23564142,24146532,26534412,42256431,46435221}
340011357444612->{12254772,13238652,14676132,15854412,21445851,23167641,25683231,27745221}
1042418529479808->{12344448,22361664,23656044,24325824,42852342,44065632,46616322,84444321}
860426716976316->{12373596,13597236,21653793,23795163,36159732,39735612,63279531,69537321}
579899832100344->{12375864,13587624,21657762,23778342,24387732,26775612,42678531,46857321}
610687106376984->{13212264,14532024,23121462,24013452,25431042,26412132,42023541,46221231}
909936112971366->{13274586,14587326,26158743,28745613,31654782,34785162,62378541,68547231}
623987609046984->{13323864,14773224,23316762,24135852,25853142,26761332,42237741,46832331}
645125317087104->{13344384,14415744,23352672,25227552,25572252,27625332,44751441,48344331}
621631023436584->{13369464,14559624,23396562,24397452,25479342,26569332,42695541,46496331}
1134871023647088->{13442448,23524284,24350664,26631624,42613662,46605342,48242532,84424431}
655859245091904->{13454784,14785344,23545872,25347852,25874352,27854532,44358741,48745431}
1083163569127848->{13464408,22536084,24390444,26532804,40823562,44409342,48063522,80446431}
1137462800807088->{13466448,23566284,24493464,26536824,42863562,46439442,48266532,84466431}
1147980114425088->{13563648,23736384,25552944,25671744,44717652,44925552,48363732,84636531}
1095191446714848->{13576608,23391864,23759064,26753904,40935762,46095732,46819332,80667531}
976614697896526->{14313286,15743026,26014573,28613143,34131682,37541062,62034751,68231341}
999088058982636->{14412396,15852036,25221693,27741063,36014772,39612252,63025851,69321441}
670341346809624->{14555064,15723624,24361572,25471362,26317452,27516342,42632751,46055541}
1244465038752768->{14773248,25550784,25853184,27831744,44713872,48135852,48705552,84237741}
1026761738613156->{15615756,15756156,27327573,27573273,37237572,37572372,65165751,65751651}
1462434833657448->{16816968,16968168,29429694,29694294,49249692,49692492,86186961,86961861}
1835678214590976->{21728448,22756608,40934844,42817824,42871824,44843904,80665722,84482712}
1564048900490832->{23185476,25478316,35078544,38547504,40574583,44587053,61387452,67458132}
1701426323612232->{24386796,26798436,36279864,39867624,42676893,46897263,63489762,69768342}
1749116423979792->{25224396,27744036,36025584,39624144,44142693,48552063,63044772,69342252}
1875177765804672->{27627876,27876276,38438784,38784384,48348783,48783483,67267872,67872672}
nyy 发表于 2025-2-24 10:20
再加两句
代码
Clear["Global`*"];(*mathematica11.2,win7(64bit)Clear all variables*)
aaa=
{{144, 252, 63504}, {156, 273, 101556}, {168, 294, 144648}, {276, 384,
185472}, {1224, 2142, 5166504}, {1236, 2163, 7812756}, {1248, 2184,
10509408}, {1326, 2613, 8262306}, {1339, 3193, 12494209}, {1344,
2352, 5955264}, {1356, 2373, 8856036}, {1368, 2394,
11807208}, {1428, 2814, 11768148}, {1456, 2743, 9523696}, {1464,
2562, 6794424}, {1476, 2583, 9949716}, {1568, 2954,
13564768}, {1584, 2772, 7683984}, {1586, 2873, 10865686}, {1596,
2793, 11093796}, {2316, 3504, 14201712}, {2328, 4074,
19164096}, {2346, 3264, 15089472}, {2369, 3296, 22818208}, {2436,
3624, 15449112}, {2448, 4284, 20666016}, {2556, 3744,
16746912}, {2568, 4494, 22218336}, {2576, 3584, 17393152}, {2639,
3926, 24706318}, {2676, 3864, 18095112}, {2796, 3984,
19493712}, {3468, 4386, 29973924}, {3528, 4716, 29116584}, {3648,
4836, 30873024}, {3768, 4956, 32679864}, {4439, 6176,
41478016}, {4669, 6496, 45121216}}
bbb=Select]]==Sort@IntegerDigits[#[]]&]
Grid(*列表显示*)
选出后
{{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 发表于 2025-2-24 10:34
2组多没意思, 三组,四组才有趣.
为了加速,砍掉不必要的计算,比如末尾是0的,逆序小于本身的情况,同时开启多线程,并且提前返回结果
n = 8; SetSharedVariable;
lst = {}; Monitor[
ParallelDo]*10^(n - 1) + i*10 + ht[];
revI = IntegerReverse;
If;
tmp = Select/2]]],
IntegerLength[#] == n && IntegerReverse == # &];
If > 3, Print[{ii -> tmp, i}];
AppendTo]], {i, 0, 10^(n - 2) - 1}, {ht,
Union, {2}]]]}], {Length}]
然后跑了一晚上, 搜索大于四组的在$n<10^9$内没有, 但再继续下去在$10^9<n<10^{10}$就有了.,找到了第一个5组解乘积为10119126106147652568,第一个6组解的乘积是6262460089931994984, 第一个7组解的乘积是5918858243794044864
Block[{ii=5918858243794044864,divs},divs=Divisors;ii->Table,{p,Select/2]],IntegerReverse==#&]}]]
10119126106147652568->{{1143628488,8848263411},{1257864408,8044687521},{2071654884,4884561702},{2278590444,4440958722},{2478732804,4082378742}}
6262460089931994984->{{1335519864,4689155331},{1359755064,4605579531},{1468923624,4263298641},{2163464982,2894643612},{2337159762,2679517332},{2379571362,2631759732}}
6752888285764008024->{{1452289464,4649822541},{1466783064,4603876641},{1597357224,4227537951},{2333753982,2893573332},{2415735972,2795375142},{2566870362,2630786652}}
5918858243794044864->{{1224264384,4834624221},{1333249344,4439423331},{1466426304,4036246641},{2142462672,2762642412},{2306426652,2566246032},{2333186352,2536813332},{2356471152,2511746532}}
wayne 发表于 2025-2-25 07:03
为了加速,砍掉不必要的计算,比如末尾是0的,逆序小于本身的情况,同时开启多线程,并且提前返回结果
你的算法的原理是怎么样的！？
本帖最后由 northwolves 于 2025-3-4 00:03 编辑
{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}
northwolves 发表于 2025-2-25 12:24
{2,{144,252},63504}}
{3,{13248,23184,27504},1115892288},
{4,{123648,216384,232944,256704},1046458990 ...
代码呢？算法原理呢？难道是穷举法吗？
最开始的版本虽然非常快,但是占用内存也线性增加,最后到了超过计算机内存20GB,靠跟硬盘交换空间才能维持. 现在 给一个基本不占用内存的rust实现, 但速度比较慢, 基本上是稳定的1分钟处理10万个有效的大整数的分解.
use chrono::Local;
use std::collections::*;
use rayon::prelude::*;
use std::thread;
use std::env;
fn find_prime_factors(mut n: u64) -> Vec<u64> {
let primes: Vec<u64> = vec![
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89,
];
let mut factors = Vec::new();
for p in primes {
if p * p > n {
break;
}
while n % p == 0 {
factors.push(p);
n /= p;
}
}
let mut divisor= 97;
while n > 1 {
while n % divisor == 0 {
factors.push(divisor);
n /= divisor;
}
if divisor * divisor > n {
break;
}
divisor += 2;
}
if n>1{
factors.push(n);
}
factors
}
fn find_divisors_optimized(n: u64) -> BTreeSet<u64> {
let prime_factors = find_prime_factors(n);
let mut divisors = BTreeSet::new();
divisors.insert(1);
for factor in prime_factors {
let new_divisors: BTreeSet<u64> = divisors.iter().map(|&d| d * factor).collect();
divisors.extend(new_divisors);
}
divisors
}
fn get_first_half_with_middle<T: Clone>(vec: &Vec<T>) -> Vec<T> {
let half_len = (vec.len() + 1) / 2; // 向上取整
vec.iter().take(half_len).cloned().collect()
}
fn reverse_integer(mut n: u64) -> u64 {
let mut reversed = 0;
while n > 0 {
reversed = reversed * 10 + n % 10;
n /= 10;
}
reversed
}
fn check(n:usize,number:u64)->Vec<(u64, u64)>{
let divisors: BTreeSet<u64> = find_divisors_optimized(number);
let divisors_half= get_first_half_with_middle(&divisors.iter().cloned().collect());
let divisors_n: Vec<(u64, u64)>= divisors_half.iter().filter_map(|&d| {
let digit_count = d.to_string().len();
let d_reversed = reverse_integer(d);
if digit_count == n && d_reversed==(number/d){
Some((d,d_reversed))
} else {
None
}
}).collect();
divisors_n
}
fn compute_task(i:u64,n:usize,n_filter:usize){
if i%10!=0{
let reversed_i = reverse_integer(i);
if reversed_i>=i {
let product = i * reversed_i;
let divisors = check(n,product);
if divisors.len()>=n_filter{
println!("[{}] {} {} -> {:?}", i, divisors.len(), product, divisors);
}
}
} else if i%10000==0{
eprintln!("[{}][{}]--------------------{:?}",Local::now().format("%Y-%m-%d %H:%M:%S%.3f"), i,thread::current().id());
}
}
fn main() {
let args: Vec<String> = env::args().collect();
if args.len() < 3 {
eprintln!("Usage: {} <n> <n_filter>", args);
std::process::exit(1);
}
let n :u32= args.parse::<u32>().expect("failed to parse");
let progress_span:u64 = 10u64.pow(n-1);
let n_filter :u32= args.parse::<u32>().expect("failed to parse");
(1*progress_span..10*progress_span).into_par_iter().for_each(|i:u64| {
compute_task(i,n as usize,n_filter as usize);
});
}
附件是已经编译好了的可执行程序.
说明: 程序必须传入两个参数, 第一个参数是要搜索的整数的位数,第二个是要搜索的组数. 比如,我要搜索全部的六位数的三组及以上的解,如下 primes.exe 6 3
primes.exe 6 3
4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
3 119391618528 -> [(134688, 886431), (243984, 489342), (279624, 426972)]
3 70687000944 -> [(145584, 485541), (158544, 445851), (254772, 277452)]
3 70687000944 -> [(145584, 485541), (158544, 445851), (254772, 277452)]
4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
3 119391618528 -> [(134688, 886431), (243984, 489342), (279624, 426972)]
4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
3 70687000944 -> [(145584, 485541), (158544, 445851), (254772, 277452)]
3 119391618528 -> [(134688, 886431), (243984, 489342), (279624, 426972)]
由于7位数开始,速度略慢,需要等待,为了显示程序运行的进度,证明程序还活着,可以再添加一个可选的参数,true或者false,表示是否打印进度
E:\coding\rust\ddd\target\release>primes.exe 6 4 true
--------------------ThreadId(12)
--------------------ThreadId(7)
--------------------ThreadId(4)
--------------------ThreadId(3)
--------------------ThreadId(15)
--------------------ThreadId(2)
--------------------ThreadId(5)
--------------------ThreadId(13)
--------------------ThreadId(9)
--------------------ThreadId(16)
[ 4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
2025-02-26 11:41:16.028]--------------------ThreadId(11)
--------------------ThreadId(14)
--------------------ThreadId(6)
-------------------- 4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
ThreadId(10)
--------------------ThreadId(12)
--------------------ThreadId(15)
--------------------ThreadId(9)
4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
]--------------------ThreadId(8)
--------------------ThreadId(3)
--------------------ThreadId(4)
--------------------ThreadId(5)
--------------------ThreadId(2)
[ 4 104645899008 -> [(123648, 846321), (216384, 483612), (232944, 449232), (256704, 407652)]
2025-02-26 11:41:16.332]--------------------ThreadId(7)
--------------------ThreadId(11)
--------------------ThreadId(8)
--------------------ThreadId(3)
--------------------ThreadId(10)
--------------------ThreadId(15)
--------------------ThreadId(16)
--------------------ThreadId(9)
--------------------ThreadId(11)
--------------------ThreadId(7)
--------------------ThreadId(14)
--------------------ThreadId(5)
--------------------ThreadId(6)
--------------------ThreadId(17)
--------------------ThreadId(11)
--------------------ThreadId(4)
--------------------ThreadId(10)
--------------------ThreadId(15)
静态编译的二进制.
一个晚上就是弄这两个？？？？？？？？没骗你！！！
正整数A×颠倒数A=正整数B×颠倒数B。譬如：144×441=252×252。譬如：168×861=294×492。我们不妨约定A是最小的那个。您也来一个？谢谢！
开始, 我列了个方程, 软件好像看不懂。
NSolve[{IntegerReverse*A == IntegerReverse*B}, {A, B}, Integers]
NSolve::nsmet: This system cannot be solved with the methods available to NSolve.
我去找专业的FindInstance，给了1个解。
FindInstance[{IntegerReverse*A == IntegerReverse*B, 0 < A < 500, A < IntegerReverse, A < B < IntegerReverse}, {A, B}, Integers, 1]
{{A -> 168, B -> 294}}第2个解就不肯给了。
FindInstance[{IntegerReverse*A == IntegerReverse*B, 0 < A < 500, A < IntegerReverse, A < B < IntegerReverse}, {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 16:18 编辑
王守恩 发表于 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整除