欧拉工程第63题：Powerful digit counts

题目链接

The 5-digit number, 16807=7⁵, is also a fifth power. Similarly, the 9-digit number, 134217728=8⁹, is a ninth power.

How many n-digit positive integers exist which are also an nth power?

这个题目有点坑：

先说自己的思路<虽然方法不是很好>

根据题意可知道：

a的b次方 除以 最小的b位数（如：1，10,100,1000） 的商 在 1--9之间，则：a的b次方就是符合题意的

然后就根据这个遍历

先找到第一个数符合条件的数firstnum

再找到第一个符合条件之后的第一个不满足条件的数nextnum

则：这中间有 nextnum - firstnum个数

当b也就是次方数大于18的时候，Long都溢出了

此时：有46个数

下面是程序 ：

package project61;

import java.math.BigInteger;

public class P63{
//    a的b次方是b位数
//    a的b次方 除以 b位的第一个数（如：1000） 商 在1 - 9之间
//    以a为开始，找到第一个满足条件的数，如不存在返回 0 
//    满足条件的数是连续的
    long findFirst(long Base,int exp){
        long res =(long) Math.pow(Base, exp);
        long d = 1;
        int Max_Cycle = 10000;
        int texp = exp;
        while(exp!=1){
            d = d*10;
            exp--;
        }
        boolean flag = true ;
        int quot = 0;
        while(Max_Cycle!=0){
            quot = (int) (res/d);
//            System.out.println(quot+"res:"+res+" Base:"+Base+" d:"+d);
            if(quot>=1 && quot<=9){
                return Base;
            }
            Base = Base + 1;
            res = (long) Math.pow(Base, texp);
            Max_Cycle--;
        }
        return 0 ;
    }
    
    long findNext(long Base,int exp){
        long res =(long) Math.pow(Base, exp);
        long d = 1;
        int Max_Cycle = 100000;
        int texp = exp;
        while(exp!=1){
            d = d*10;
            exp--;
        }
        boolean flag = true ;
        int quot = 0;
        while(Max_Cycle!=0){
            quot = (int) (res/d);
            System.out.println("商:"+quot +" 被除数:"+ res+" 除数:"+d+" 底数:"+Base+" 指数:"+texp);
            if(quot==0 ||quot>9){
                
                return Base;
            }
            Base = Base + 1;
            res = (long) Math.pow(Base, texp);
            Max_Cycle--;
        }
        return 0 ;
    }
    void run(){
        long result = 0;
        int base = 1;
        int exp = 1;

        while(exp<=18){
            base = 1 ;
            long firstNum = findFirst(base,exp);
            if(firstNum !=0){
            
            long next = findNext(firstNum,exp);
            System.out.println("第一个满足条件的底数:"+firstNum +" 第一个不满足条件的底数： "+ next);
            result = result + next - firstNum;
            
            }
            exp++;
        }
        System.out.println(result);
    }
    
    public static void main(String[] args){
        long begin= System.currentTimeMillis();
        new P63().run(); 
        long end = System.currentTimeMillis();
        long Time = end - begin;
        System.out.println("Time:"+Time/1000+"s"+Time%1000+"ms");
    }
}

程序流程：

1.在相同的指数情况小，找符合条件的数

 1.1找到第一个符合条件的数的底数

 1.2找到符合条件数后面的第一个不符合条件的数

 1.3这两个数的差，就是在这个指数下所以符合条件的数

2.增加指数。

下面是运行的结果：

可以看出，只有1-9的底数满足条件，上面红框中的是满足条件后的第一个不满足条件的数。

上面至少知道18，设成18以上，溢出，，，输入上面的46当然是不对的，应该是还有的

尝试直接在9的19,20,21...的数中找符合条件的数：

        BigInteger base = new BigInteger("9");
        BigInteger bigres = new BigInteger("0");
        String toStr = "";
        int exp = 18;
        
        for(exp=19;exp<25;exp++){
            bigres = base.pow(exp);
            toStr = bigres+"";
            if(toStr.length() ==exp)
            System.out.println(toStr);
        }

通过上面的程序，就只是把符合条件的其他三个数输出了。

答案是：49

上面的过程是不是太复杂了，如果直接利用BigInteger也不会这么复杂的。

然后看到别人是这样做的：

上面说的很详细。。。

void run1(){
        int count = 0;
        for(int x = 1;x<10;x++){
            count +=(int)(1.0/(1-Math.log(x)/Math.log(10)));

        }
        System.out.println(count);
    }

程序就成这样的了。。。

Python程序：

from math import log10

s = 0 
for n in range(1,10):
    s += int(1/(1-log10(n)))
    
print "result=",s 

Python程序就是这样的了。。。

from math import log10

print sum(map(int, map(lambda a: 1.0/(1.0-log10(a)), range(1, 10))))

Python 也可以这样来。。。