当前位置：网站首页>hdu 1333 Smith Numbers（暴力思路）

hdu 1333 Smith Numbers（暴力思路）

2022-08-09 20:11:00 【51CTO】


题目：​ ​http://acm.hdu.edu.cn/showproblem.php?pid=1333​​

Smith Numbers

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1734    Accepted Submission(s): 567


Problem Description

While skimming his phone directory in 1982, Albert Wilansky, a mathematician of Lehigh University, noticed that the telephone number of his brother-in-law H. Smith had the following peculiar property: The sum of the digits of that number was equal to the sum of the digits of the prime factors of that number. Got it? Smith’s telephone number was 493-7775. This number can be written as the product of its prime factors in the following way:

4937775 = 3 * 5 * 5 * 65837
The sum of all digits of the telephone number is 4+9+3+7+7+7+5= 42?, and the sum of the digits of its prime factors is equally 3+5+5+6+5+8+3+7= 42. Wilansky was so amazed by his discovery that he named this kind of numbers after his brother-in-law: Smith numbers.

As this observation is also true for every prime number, Wilansky decided later that a (simple and unsophisticated) prime number is not worth being a Smith number, so he excluded them from the definition.

Wilansky published an article about Smith numbers in the Two Year College Mathematics Journal and was able to present a whole collection of different Smith numbers: For example, 9985 is a Smith number and so is 6036. However,Wilansky was not able to find a Smith number that was larger than the telephone number of his brother-in-law. It is your task to find Smith numbers that are larger than 4937775!


Input

The input consists of a sequence of positive integers, one integer per line. Each integer will have at most 8 digits. The input is terminated by a line containing the number 0.

Output

For every number n > 0 in the input, you are to compute the smallest Smith number which is larger than n, and print it on a line by itself. You can assume that such a number exists.

Sample Input 

      
      

       
       4937774
       
       
0
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    •

Sample Output 

      
      

       
       4937775
      
      

      
      
    
       
       
  • 1.
    •

分析：


smith number：除素数外，所有位的数的和等于该数字的所有素因子的所有位上的数字的和。


输入的数字是最多8位，int不是最多10位吗？估摸着用int应该没有问题。就是一个数字一个数字的试。


      
      

       
       import 
       
       java.
       
       util.
       
       *;
       
       

       
       public 
       
       class 
       
       Main {
       
       
    
       
       static 
       
       int 
       
       getsum(
       
       int 
       
       x){
       
       
        
       
       int 
       
       ans
       
       =
       
       0;
       
       
        
       
       while(
       
       x
       
       >
       
       0){
       
       
            
       
       ans
       
       =
       
       ans
       
       +
       
       x
       
       %
       
       10;
       
       
            
       
       x
       
       /=
       
       10;
       
       
        }
       
       
        
       
       return 
       
       ans;
       
       
    }
       
       
    
       
       static 
       
       final 
       
       int 
       
       maxn
       
       =(
       
       int)(
       
       1e4
       
       +
       
       10);
       
       
    
       
       static 
       
       int[] 
       
       fac
       
       =
       
       new 
       
       int [
       
       maxn],
       
       pow
       
       =
       
       new 
       
       int [
       
       maxn];
       
       
    
       
       static 
       
       int 
       
       cnt;
       
       
    
       
       static 
       
       void 
       
       resolve(
       
       int 
       
       x){
       
       
        
       
       cnt
       
       =
       
       0;
       
       
        
       
       Arrays.
       
       fill(
       
       pow,
       
       0);
       
       
        
       
       for(
       
       int 
       
       i
       
       =
       
       2;
       
       i
       
       *
       
       i
       
       <=
       
       x;
       
       i
       
       ++){
       
       
            
       
       if(
       
       x
       
       %
       
       i
       
       ==
       
       0){
       
       
                
       
       fac[
       
       cnt]
       
       =
       
       i;
       
       
                
       
       while(
       
       x
       
       %
       
       i
       
       ==
       
       0){
       
       
                    
       
       x
       
       /=
       
       i;
       
       
                    
       
       pow[
       
       cnt]
       
       ++;
       
       
                }
       
       
                
       
       cnt
       
       ++;
       
       
            }
       
       
        }
       
       
        
       
       if(
       
       x
       
       >
       
       1){
       
       
            
       
       fac[
       
       cnt]
       
       =
       
       x;
       
       
            
       
       pow[
       
       cnt
       
       ++]
       
       ++;
       
       
        }
       
       
    }
       
       
    
       
       public 
       
       static 
       
       void 
       
       main(
       
       String[] 
       
       args) {
       
       
        
       
       int 
       
       n,
       
       k,
       
       sum1,
       
       sum2;
       
       
        
       
       Scanner 
       
       sc
       
       =
       
       new 
       
       Scanner(
       
       System.
       
       in);
       
       
        
       
       while(
       
       sc.
       
       hasNextInt()){
       
       
            
       
       n
       
       =
       
       sc.
       
       nextInt();
       
       
            
       
       if(
       
       n
       
       ==
       
       0) 
       
       break;
       
       
            
       
       k
       
       =
       
       n
       
       +
       
       1;
       
       
            
       
       while(
       
       k
       
       >
       
       n){
       
       
                
       
       resolve(
       
       k);
       
       
                
       
       if(
       
       fac[
       
       0]
       
       ==
       
       k){
       
       
                    
       
       k
       
       ++;
       
       
                    
       
       continue;
       
       
                }
       
       
                
       
       sum2
       
       =
       
       0;
       
       
                
       
       for(
       
       int 
       
       i
       
       =
       
       0;
       
       i
       
       <
       
       cnt;
       
       i
       
       ++){
       
       
                    
       
       sum2
       
       +=
       
       getsum(
       
       fac[
       
       i])
       
       *
       
       pow[
       
       i];
       
       
                }
       
       
                
       
       sum1
       
       =
       
       getsum(
       
       k);
       
       
                
       
       if(
       
       sum1
       
       ==
       
       sum2) 
       
       break;
       
       
                
       
       k
       
       ++;
       
       
            }
       
       
            
       
       System.
       
       out.
       
       println(
       
       k);
       
       
        }
       
       
    }
       
       

       
       
}
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    • 
       
       
  • 7.
    • 
       
       
  • 8.
    • 
       
       
  • 9.
    • 
       
       
  • 10.
    • 
       
       
  • 11.
    • 
       
       
  • 12.
    • 
       
       
  • 13.
    • 
       
       
  • 14.
    • 
       
       
  • 15.
    • 
       
       
  • 16.
    • 
       
       
  • 17.
    • 
       
       
  • 18.
    • 
       
       
  • 19.
    • 
       
       
  • 20.
    • 
       
       
  • 21.
    • 
       
       
  • 22.
    • 
       
       
  • 23.
    • 
       
       
  • 24.
    • 
       
       
  • 25.
    • 
       
       
  • 26.
    • 
       
       
  • 27.
    • 
       
       
  • 28.
    • 
       
       
  • 29.
    • 
       
       
  • 30.
    • 
       
       
  • 31.
    • 
       
       
  • 32.
    • 
       
       
  • 33.
    • 
       
       
  • 34.
    • 
       
       
  • 35.
    • 
       
       
  • 36.
    • 
       
       
  • 37.
    • 
       
       
  • 38.
    • 
       
       
  • 39.
    • 
       
       
  • 40.
    • 
       
       
  • 41.
    • 
       
       
  • 42.
    • 
       
       
  • 43.
    • 
       
       
  • 44.
    • 
       
       
  • 45.
    • 
       
       
  • 46.
    • 
       
       
  • 47.
    • 
       
       
  • 48.
    • 
       
       
  • 49.
    • 
       
       
  • 50.
    • 
       
       
  • 51.
    • 
       
       
  • 52.
    • 
       
       
  • 53.
    • 
       
       
  • 54.
    • 
       
       
  • 55.
    • 
       
       
  • 56.
    • 
       
       
  • 57.
    •



原网站

版权声明
本文为[51CTO]所创，转载请带上原文链接，感谢
https://blog.51cto.com/u_15746559/5560968

边栏推荐

猜你喜欢

随机推荐