找回密码
 欢迎注册
楼主: 王守恩

[灌水] 这样的A有多少个?

[复制链接]
发表于 2024-2-23 13:49:53 | 显示全部楼层
有没有仅由7,8,9组成的平方数呢? 看到一篇文章讲到$1-1.8*10^{22}$之内数字的平方数无满足条件的解

点评

妙哉!  发表于 2024-2-23 15:52
然后对于这些搜索到的数判断其平方是否所有位都不小于7  发表于 2024-2-23 15:06
这个也可以使用通过尾数部分来扩展。我们先找出所有平方后末k位都不小于7的数字,然后每个数字可以在前面添加一位,看它平方末k+1位是否也是  发表于 2024-2-23 15:05
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2024-2-23 13:57:41 | 显示全部楼层
6,7,8,9的很多,10^8以内有121个:
  1. Select[Range[10^8], Min[IntegerDigits[#^2]] > 5 &]
复制代码

{3,26,83,264,313,824,836,883,887,937,3114,8167,8813,8887,8937,9417,9833,25824,26264,29614,29626,89324,89437,93637,94863,98336,260167,262617,314113,817863,817924,818333,818474,823887,828667,835386,875614,931117,936417,937383,947617,989286,993367,994836,998333,2639867,2772886,2774867,2949386,3114113,3125167,3128576,3158637,3162083,8172313,8238924,8306424,8819687,8881367,8943583,9309617,9311117,9327313,9363637,9427613,9475167,9480974,9843764,9884164,9893887,9983336,9994833,25845676,26038026,26053176,26206676,26265313,26419063,26434214,27870714,27874176,28049736,29456714,29642874,29797617,31284176,31448367,31603764,81785676,81791063,81792236,81846117,82395387,82454836,82927613,82986667,83486333,83658214,87565786,87736417,88311374,88701633,88863924,88875137,89257924,89318363,89318474,93255974,93635937,93690383,93792313,94285676,98370676,98426063,98478367,98483333,98934214,99448367,99483667,99498633,99983333}

点评

王老师试着提交序列吧  发表于 2024-2-24 21:44
这几天看了许多类似数字串,这串数:3, 26, 264, 3114, 25824, 260167, ...OEIS可以有的。  发表于 2024-2-24 18:49
相同数位取1个:3, 26, 264, 3114, 25824, 260167, ...OEIS没有。  发表于 2024-2-23 17:43

评分

参与人数 1威望 +6 金币 +6 贡献 +6 经验 +6 鲜花 +6 收起 理由
王守恩 + 6 + 6 + 6 + 6 + 6 看我能不能发现新大陆!

查看全部评分

毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2024-2-23 17:36:34 | 显示全部楼层
northwolves 发表于 2024-2-21 15:34
a(162)>123000000000

153 1001283601183


和我们主要讨论的话题的代码应该是类似的,我通过两个程序来逼近
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  4. #include <stdint.h>
  5. #include <omp.h>
  6. #include <gmpxx.h>
  7. #include <iostream>

  8. #define TSIZE 21
  9. #define MDEPTH 24
  10. #define TOM   (9*(2*MDEPTH)+1)
  11. mpz_class tmax[TOM];
  12. #define STATM 10000
  13. int digs[STATM];

  14. int getdig(int x)
  15. {
  16.     int s=0;
  17.     while(x>0){
  18.         s+=x%10;
  19.         x/=10;
  20.     }
  21.     return s;
  22. }

  23. void initdigs()
  24. {
  25.     int i;
  26.     for(i=0;i<STATM;i++){
  27.         digs[i]=getdig(i);
  28.     }
  29. }

  30. int getbitones(long x)
  31. {
  32.     int s=0;
  33.     while(x){
  34.         if(x&1)s++;
  35.         x>>=1;
  36.     }
  37.     return s;
  38. }

  39. int sumdigits(const mpz_class& x)
  40. {
  41.     mpz_class y=x;
  42.     int s=0;
  43.     while(y>0){
  44.             mpz_class z=y%STATM;
  45.             s+=digs[z.get_si()];
  46.             y=y/STATM;
  47.     }
  48.     return s;
  49. }


  50. #define INITR 1000000
  51. #define INITL 6
  52. struct SD{
  53.     int curlen;
  54.     mpz_class lmax[TOM];
  55.     mpz_class mod;
  56.     mpz_class X;
  57. };

  58. void search(struct SD *sd)
  59. {
  60.     mpz_class X=sd->X*sd->X;
  61.     int len2 = sumdigits(X%sd->mod);
  62.     if(9*sd->curlen-len2>TSIZE)return;
  63.     int len = sumdigits(X);
  64.     if(sd->lmax[len]==0||sd->X<sd->lmax[len]){
  65.         sd->lmax[len]=sd->X;
  66. #pragma omp critical
  67.         {
  68.             if(tmax[len]==0||sd->X<tmax[len]){
  69.                 tmax[len]=sd->X;
  70.                 std::cout<<len<<":"<<sd->X<<std::endl;
  71.                 fflush(stdout);
  72.             }
  73.         }
  74.     }
  75.     if(sd->curlen>=MDEPTH)return;
  76.     int i;
  77.     sd->curlen++;
  78.     mpz_class modd10=sd->mod;
  79.     sd->mod *=10;
  80.     for(i=0;i<=9;i++){
  81.         search(sd);
  82.         sd->X += modd10;
  83.     }
  84.     sd->mod /=10;
  85.     sd->curlen--;
  86.     sd->X -= 10* sd->mod;
  87. }
  88. int gid;
  89. int main()
  90. {
  91.     initdigs();
  92. #pragma omp parallel
  93.     {
  94.         int i;
  95.         int end=0;
  96.         SD *sd=new SD;
  97.         sd->curlen=INITL;
  98.         sd->mod=INITR;
  99.         while(!end){
  100. #pragma omp critical
  101.             {
  102.                 i=gid++;
  103.             }
  104.             if(i>=INITR)break;
  105.             sd->X=i;
  106.             int len = sumdigits((sd->X*sd->X)%INITR);
  107.             int used = 9*sd->curlen-len;
  108.             if(used>TSIZE)continue;//skip number used to much
  109.             search(sd);
  110.         }
  111.     }

  112.     {
  113.             std::cout<<"Final result:\n";
  114.             int i;
  115.             for(i=0;i<TOM;i++){
  116.                 if(tmax[i]>0){
  117.                      std::cout<<i<<"\t"<<tmax[i]<<std::endl;
  118.                 }
  119.             }
  120.     }

  121.     return 0;
  122. }

复制代码

以及
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  4. #include <stdint.h>
  5. #include <omp.h>
  6. #include <gmpxx.h>
  7. #include <iostream>

  8. //#define TSIZE 14
  9. //#define MDEPTH 10
  10. #define TSIZE 20
  11. #define MDEPTH 24
  12. #define TOM   (9*(2*MDEPTH)+1)
  13. mpz_class tmax[TOM];
  14. #define STATM 10000
  15. int digs[STATM];

  16. int getdig(int x)
  17. {
  18.     int s=0;
  19.     while(x>0){
  20.         s+=x%10;
  21.         x/=10;
  22.     }
  23.     return s;
  24. }

  25. void initdigs()
  26. {
  27.     int i;
  28.     for(i=0;i<STATM;i++){
  29.         digs[i]=getdig(i);
  30.     }
  31. }

  32. int getbitones(long x)
  33. {
  34.     int s=0;
  35.     while(x){
  36.         if(x&1)s++;
  37.         x>>=1;
  38.     }
  39.     return s;
  40. }

  41. int sumdigits(const mpz_class& x)
  42. {
  43.     mpz_class y=x;
  44.     int s=0;
  45.     while(y>0){
  46.             mpz_class z=y%STATM;
  47.             s+=digs[z.get_si()];
  48.             y=y/STATM;
  49.     }
  50.     return s;
  51. }


  52. #define INITR 1000000
  53. #define INITL 6
  54. struct SD{
  55.     int curlen;
  56.     int mislen;
  57.     mpz_class lmax[TOM];
  58.     mpz_class mod;
  59.     mpz_class X;
  60. };

  61. void search(struct SD *sd)
  62. {
  63.     mpz_class LY=sd->X*sd->mod;
  64.     mpz_class X=sqrt(LY+sd->mod-1);
  65.     while(1){
  66.       mpz_class Z=(X*X);
  67.       if(Z<LY)break;
  68.       int len = sumdigits(Z);
  69.       if(sd->lmax[len]==0||X<sd->lmax[len]){
  70.         sd->lmax[len]=X;
  71. #pragma omp critical
  72.         {
  73.             if(tmax[len]==0||X<tmax[len]){
  74.                 tmax[len]=X;
  75.                 std::cout<<len<<":"<<X<<":{"<<sd->curlen<<":"<<sd->X<<"}"<<std::endl;
  76.                 fflush(stdout);
  77.             }
  78.         }
  79.       }
  80.       X--;
  81.     }
  82.     if(sd->curlen>=MDEPTH)return;
  83.     int i;
  84.     sd->X*=10;sd->X+=9;
  85.     sd->mod *=10;
  86.     sd->curlen++;
  87.     for(i=9;i>=0;i--){
  88.         if(sd->mislen<=TSIZE){
  89.             search(sd);
  90.         }
  91.         sd->X--;
  92.         sd->mislen++;
  93.     }
  94.     sd->mislen-=10;
  95.     sd->X++;sd->X/=10;
  96.     sd->curlen--;
  97.     sd->mod /=10;
  98. }
  99. int gid;
  100. int main()
  101. {
  102.     initdigs();
  103.     gid=INITR/100;
  104. #pragma omp parallel
  105.     {
  106.         int i;
  107.         int end=0;
  108.         SD *sd=new SD;
  109.         sd->curlen=INITL;
  110.         sd->mod=INITR;
  111.         while(!end){
  112. #pragma omp critical
  113.             {
  114.                 i=gid++;
  115.             }
  116.             if(i>=INITR)break;
  117.             sd->X=i;
  118.             int len1 = sumdigits(sd->X);
  119.             sd->mislen=9*sd->curlen-len1;
  120.             if(i<INITR/10)sd->mislen-=9;
  121.             if(sd->mislen>TSIZE)continue;//skip number used to much
  122.             search(sd);
  123.         }
  124.     }

  125.     {
  126.             std::cout<<"Final result:\n";
  127.             int i;
  128.             for(i=0;i<TOM;i++){
  129.                 if(tmax[i]>0){
  130.                      std::cout<<i<<"\t"<<tmax[i]<<std::endl;
  131.                 }
  132.             }
  133.     }

  134.     return 0;
  135. }
复制代码

点评

直接就是十倍查找  发表于 2024-2-23 18:33
主要修改两个参数MDEPTH和TSIZE即可。前者代表被平方数字的最大位数,后者代表搜索数字和全9数字的对应位差之和  发表于 2024-2-23 17:44

评分

参与人数 1威望 +8 金币 +8 贡献 +8 经验 +8 鲜花 +8 收起 理由
northwolves + 8 + 8 + 8 + 8 + 8 赞一个!

查看全部评分

毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2024-2-23 17:54:28 | 显示全部楼层
mathe 发表于 2024-2-23 17:36
和我们主要讨论的话题的代码应该是类似的,我通过两个程序来逼近

以及

类似的: A053974 数字 k,使得 k^2 仅包含数字 {6,8,9}。                1
3, 83, 264, 836, 3114, 8167, 98336, 818333, 828667, 994836, 9309617, 984833336, 82885443167, 948097937383, 984879122886, 2588184048685235767383,
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2024-2-23 18:06:27 | 显示全部楼层
northwolves 发表于 2024-2-23 13:49
有没有仅由7,8,9组成的平方数呢? 看到一篇文章讲到$1-1.8*10^{22}$之内数字的平方数无满足条件的解 ...

验证了小于10^{24}的数字的平方数不满足条件

点评

按概率来评估,这样的数字应该基本上不存在了,但是如果允许一位例外,结果应该会多很多。  发表于 2024-2-24 11:21
目前你的数据这个数字是最接近要求的,只有十位数2一个例外2999999999833333333327^2=8999999998999999999989777777779888888888929  发表于 2024-2-24 10:03

评分

参与人数 1威望 +8 金币 +8 贡献 +8 经验 +8 鲜花 +8 收起 理由
northwolves + 8 + 8 + 8 + 8 + 8 赞一个!

查看全部评分

毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2024-2-24 07:05:11 | 显示全部楼层
本帖最后由 王守恩 于 2024-2-24 07:39 编辑

数字串(1)极限性价比(数码和: 数位)=33:4。
数字串(2)极限性价比(数码和: 数位)=33:4。
数字串(3)性价比(数码和: 数位)好像就差多了。
  1. 数字串(1)。Table[k = 6*10^(2 n) - (5*10^n + 1)/3; {k, k^2}, {n, 20}] // TableForm
复制代码

{"583", "339889"},
{"59833", "3579987889"},
{"5998333", "35979998778889"},
{"599983333", "359979999877788889"},
{"59999833333", "3599979999987777888889"},
{"5999998333333", "35999979999998777778888889"},
{"599999983333333", "359999979999999877777788888889"},
{"59999999833333333", "3599999979999999987777777888888889"},
{"5999999998333333333", "35999999979999999998777777778888888889"},
{"599999999983333333333", "359999999979999999999877777777788888888889"},
{"59999999999833333333333", "3599999999979999999999987777777777888888888889"},
{"5999999999998333333333333", "35999999999979999999999998777777777778888888888889"},
{"599999999999983333333333333", "359999999999979999999999999877777777777788888888888889"},
{"59999999999999833333333333333", "3599999999999979999999999999987777777777777888888888888889"},
{"5999999999999998333333333333333", "35999999999999979999999999999998777777777777778888888888888889"},
{"599999999999999983333333333333333", "359999999999999979999999999999999877777777777777788888888888888889"},
{"59999999999999999833333333333333333", "3599999999999999979999999999999999987777777777777777888888888888888889"},
{"5999999999999999998333333333333333333", "35999999999999999979999999999999999998777777777777777778888888888888888889"},
{"599999999999999999983333333333333333333", "359999999999999999979999999999999999999877777777777777777788888888888888888889"},
{"59999999999999999999833333333333333333333", "3599999999999999999979999999999999999999987777777777777777777888888888888888888889"}
  1. 数字串(2)。Table[k = 3*10^(2 n - 1) - (5*10^n + 19)/3; {k, k^2}, {n, 20}] // TableForm
复制代码

{"7", "49"},
{"2827", "7991929"},
{"298327", "88998998929"},
{"29983327", "898999897988929"},
{"2999833327", "8998999989779888929"},
{"299998333327", "89998999998977798888929"},
{"29999983333327", "899998999999897777988888929"},
{"2999999833333327", "8999998999999989777779888888929"},
{"299999998333333327", "89999998999999998977777798888888929"},
{"29999999983333333327", "899999998999999999897777777988888888929"},
{"2999999999833333333327", "8999999998999999999989777777779888888888929"},
{"299999999998333333333327", "89999999998999999999998977777777798888888888929"},
{"29999999999983333333333327", "899999999998999999999999897777777777988888888888929"},
{"2999999999999833333333333327", "8999999999998999999999999989777777777779888888888888929"},
{"299999999999998333333333333327", "89999999999998999999999999998977777777777798888888888888929"},
{"29999999999999983333333333333327", "899999999999998999999999999999897777777777777988888888888888929"},
{"2999999999999999833333333333333327", "8999999999999998999999999999999989777777777777779888888888888888929"},
{"299999999999999998333333333333333327", "89999999999999998999999999999999998977777777777777798888888888888888929"},
{"29999999999999999983333333333333333327", "899999999999999998999999999999999999897777777777777777988888888888888888929"},
{"2999999999999999999833333333333333333327", "8999999999999999998999999999999999999989777777777777777779888888888888888888929"}
  1. 数字串(3)。Table[{Floor@Sqrt[10^(2 n - 1)], Floor[Sqrt[10^(2 n - 1)]]^2}, {n, 20}] // TableForm
复制代码

{"3", "9"},
{"31", "961"},
{"316", "99856"},
{"3162", "9998244"},
{"31622", "999950884"},
{"316227", "99999515529"},
{"3162277", "9999995824729"},
{"31622776", "999999961946176"},
{"316227766", "99999999989350756"},
{"3162277660", "9999999998935075600"},
{"31622776601", "999999999956753113201"},
{"316227766016", "99999999999470044512256"},
{"3162277660168", "9999999999997600893788224"},
{"31622776601683", "999999999999949826038432489"},
{"316227766016837", "99999999999999409792567484569"},
{"3162277660168379", "9999999999999997900254631487641"},
{"31622776601683793", "999999999999999979762122758866849"},
{"316227766016837933", "99999999999999999873578871987712489"},
{"3162277660168379331", "9999999999999999993682442519108007561"},
{"31622776601683793319", "999999999999999999937454230741109035761"},
{"316227766016837933199", "99999999999999999999437522862413986373601"},
{"3162277660168379331998", "9999999999999999999994348728804092706672004"},
{"31622776601683793319988", "999999999999999999999940837306036211360320144"},
{"316227766016837933199889", "99999999999999999999999775830391924218829612321"},
{"3162277660168379331998893", "9999999999999999999999996556705153432158953225449"},
{"31622776601683793319988935", "999999999999999999999999971898281360053828522434225"},
{"316227766016837933199889354", "99999999999999999999999999719650264140086317842537316"},
{"3162277660168379331998893544", "9999999999999999999999999997263247695355666440244879936"},
{"31622776601683793319988935444", "999999999999999999999999999979306982349036990584399477136"},
{"316227766016837933199889354443", "99999999999999999999999999999828064831004726657639283840249"}
目标很明确: T(n)应该从A067179中突围出来。
显然: T(44)=893241282627485818275387^2=797879988989995997899989877988999997998969999769=44*9/48=33/4
这是极限性价比(数码和: 数位)了吗?!

毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2024-2-24 07:38:09 | 显示全部楼层
mathe 发表于 2024-2-18 17:38
利用前面思路重新改写了程序,搜索所有不超过20位整数(平方不超过40位), (不限于3的倍数了)
一个程序是平 ...


  1. 148 262087386170528775387
  2. 149 223584183022838178583
  3. 150 435877272864734253937
  4. 151 741551749981004224417
  5. 152 754718284918279954614
  6. 153 888142995231510436417
  7. 154 1413081381198439327133
  8. 155 2190638491396718286667
  9. 156 2827719752694560960583
  10. 157 2999999999833333333327
  11. 158 2976388751488907738914
  12. 159 8244385168100697671333
  13. 160 8882505274864168010583
  14. 161 14104963594032775808167
  15. 162 22360389084025298775583
  16. 163 24490814584000030724417
  17. 164 43566041821463294027313
  18. 165 44384681805325572255974
  19. 166 70497517615005252750707
  20. 167 83486465909152004768333
  21. 168 99689518004050952477133
  22. 169 169705568555949244636187
  23. 170 199997474684001940194833
  24. 171 281067587951541966833333
  25. 172 315892386718941028010583
  26. 173 312713447088224669275583
  27. 174 706327748923187850491833
  28. 175 984311332861691681833333
  29. 176 893241282627485818275387
复制代码

这是楼上最新配置代码跑出的结果,其中第二个程序有一个线程运行的时间特别长,所以等了较长时间。
其中165项(对应和370)对应的数据44384681805325572255974上面两个配置跑出来的都不是最优
第一个程序结果是44721359538546565724417,第二个程序结果为59999999999833333333333
由于两个程序搜索的差距分别为20和21,加起来只有41,而$44721359538546565724417^2$是46位数,46×9-370=44,所以搜索范围不够
然后我又专门跑了一个老版本仅针对特定目标的代码,对应第二个程序但是将范围扩到到24 (由于$44721359538546565724417^2$第一位是1,已经用掉8个差距,其实搜索范围不大),
   找到了44384681805325572255974。
另外还有361,369,379需要搜索的范围都大于41,(它们平方数第一位最多是2),同样用那代码验证,没有找到更优的结果。
其中另外一个比较有意思的是两个程序中大部分情况第一个代码已经找到最优结果了,但是第二个代码找到最优结果的比例要低很多,主要原因应该是第二个代码会让平方数的前面一半数据之和尽量大,所以通常会使找到的数更大。

下面是那个老版本代码,主要需要配置TLEN,代表平方数的长度,FIRSTD代表已经平方数最高位数值,比如如果是2,程序会仅搜索最高位为0,1,2的情况。
SLEN代表需要搜索的平方数的前一半的长度,我们这里总是TLEN/2的下取整,来和第二个程序匹配。 TSIZE是搜索的数字和差距,但是扣除了最高位FIRSTD已经占掉的差距。
TO代表搜索的平方数所有数字位和。
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  4. #include <stdint.h>
  5. #include <omp.h>
  6. #include <gmpxx.h>
  7. #include <iostream>

  8. #define TLEN 47
  9. #define FIRSTD 2
  10. #define SLEN 23
  11. #define TSIZE 16
  12. #define TO 379
  13. #define WITHED 1

  14. int getbitones(long x)
  15. {
  16.     int s=0;
  17.     while(x){
  18.         if(x&1)s++;
  19.         x>>=1;
  20.     }
  21.     return s;
  22. }

  23. int numdigits(const mpz_class& x)
  24. {
  25.     mpz_class y=x;
  26.     int s=0;
  27.     while(y>0){
  28.             mpz_class z=y%10;
  29.             s+=z.get_si();
  30.             y=y/10;
  31.     }
  32.     return s;
  33. }

  34. mpz_class getinitnum()
  35. {
  36.     mpz_class x=FIRSTD;
  37.     int i;
  38.     for(i=0;i<TLEN-1;i++){
  39.         x*=10;x+=9;
  40.     }
  41.     return x;
  42. }

  43. bool getX(const mpz_class& I, long i, mpz_class& X)
  44. {
  45.     int j;
  46.     int t,c=0;
  47.     mpz_class M=1;
  48.     X=I;
  49.     for(j=0;j<TLEN-1;j++)M*=10;
  50.     for(j=0,t=0;j<SLEN+TSIZE;j++){
  51.         if(i&(1L<<j)){
  52.             c++;
  53.         }else{
  54.             //X(t)=c;
  55.             if(t==0&&c>FIRSTD)return false;
  56.             if(c>9)return false;
  57.             if(c>0)X-=c*M;
  58.             M/=10;
  59.             t++;
  60.             c=0;
  61.         }
  62.     }
  63.     return true;
  64. }

  65. mpz_class curbest;
  66. int main()
  67. {
  68.     mpz_class I = getinitnum();
  69.     long i;
  70.     mpz_class localbest=0;
  71.     mpz_class LD =1;
  72.     for(i=0;i<(TLEN-SLEN);i++){
  73.             LD*=10;
  74.     }
  75. #pragma omp parallel for private(localbest)
  76.     for(i=0;i<(1L<<(SLEN+TSIZE));i++){
  77.         if(getbitones(i)>TSIZE)continue;
  78.         mpz_class X;
  79.         if(getX(I, i, X)){
  80.             mpz_class Y=sqrt(X);
  81.             while(1){
  82.             mpz_class Z=Y*Y;
  83.             if(Z>=X+LD)break;
  84.             int dg = numdigits(Z);
  85.             if(dg==TO){
  86.                     if(localbest==0||Y<localbest){
  87.                        localbest=Y;
  88. #pragma omp critical
  89.                     if(curbest==0||localbest<curbest)
  90.                     {
  91.                         curbest=localbest;
  92.                         std::cout<<"Found "<<TO<<" with "<<Y<<"^2="<<Z<<std::endl;
  93.                         fflush(stdout);
  94.                     }
  95.                     }
  96.             }
  97.             Y=Y+1;
  98.             }
  99.         }
  100.     }

  101.     return 0;
  102. }
复制代码

评分

参与人数 1威望 +8 金币 +8 贡献 +8 经验 +8 鲜花 +8 收起 理由
northwolves + 8 + 8 + 8 + 8 + 8 赞一个!

查看全部评分

毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2024-2-24 09:56:57 | 显示全部楼层
王守恩 发表于 2024-2-23 08:14
光用数码9的平方数是没有的。
光用数码9,8的平方数是没有的。
光用数码9,8,7的平方数是没有的。

mathe版主的数据:

{{3,9},{707106074079263583,33/4},{94180040294109027313,331/40},{2976388751488907738914,355/43},{312713447088224669275583,388/47},{893241282627485818275387,33/4}}
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2024-2-24 13:49:02 | 显示全部楼层
northwolves 发表于 2024-2-24 09:56
mathe版主的数据:

{{3,9},{707106074079263583,33/4},{94180040294109027313,331/40},{297638875148890 ...

目标很明确: T(n)应该从A067179中突围出来。
T(33)=297/36
T(44)=396/48
T(55)=495/60
T(66)=594/72
T(77)=693/84
T(88)=792/96
虽然这只是一厢情愿,大胆去想,错不了。这些数, 会很多吗(我这个不行)? 谢谢!
  1. Select[Range[10^10], Floor[Total[IntegerDigits[#^2]]/IntegerLength[#^2]]≥8 &]
复制代码
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2024-2-24 13:54:36 | 显示全部楼层
  1. ss={3,707106074079263583,943345110232670883,94180040294109027313,2976388751488907738914,312713447088224669275583,893241282627485818275387,314610537013606681884298837387,9984988582817657883693383344833};Table[{t,t^2,Total@IntegerDigits[t^2]/IntegerLength[t^2]},{t,ss}]//TableForm
复制代码


3        9        9
707106074079263583        499998999999788997978888999589997889        33/4
943345110232670883        889899996999889979488999999795999689        33/4
94180040294109027313        8869879989799999999898984986998979999969        331/40
2976388751488907738914        8858889999989698989999979889997999989899396        355/43
312713447088224669275583        97789699989799889886988697997987998989999989889        388/47
893241282627485818275387        797879988989995997899989877988999997998969999769        33/4
314610537013606681884298837387        98979789999989979988999999989499999797975998897999868987769        487/59
9984988582817657883693383344833        99699996998998979989989997788978889798779999999969798987797889        513/62

评分

参与人数 1威望 +3 金币 +3 贡献 +3 经验 +3 鲜花 +3 收起 理由
王守恩 + 3 + 3 + 3 + 3 + 3 大胆猜测, 小心求证。

查看全部评分

毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
您需要登录后才可以回帖 登录 | 欢迎注册

本版积分规则

小黑屋|手机版|数学研发网 ( 苏ICP备07505100号 )

GMT+8, 2024-11-13 14:28 , Processed in 0.058270 second(s), 24 queries .

Powered by Discuz! X3.5

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表