可被X整除的最大K位数-yiteyi-C++库

给出了整数X和K。任务是找到可被X整除的最高K位数。 例如：

null

Input : X = 30, K = 3Output : 990990 is the largest three digit number divisible by 30.Input : X = 7, K = 2Output : 98

推荐：请尝试你的方法 {IDE} 首先，在进入解决方案之前。

A. 简单解决方案 就是尝试从最大的K位数开始的所有数字（999…K倍），然后返回第一个可被X整除的数字。一 有效解决方案 就是用下面的公式。

ans = MAX - (MAX % X)where MAX is the largest K digit number which is  999...K-times

这个公式适用于简单的学校教学法。我们去掉余数得到最大的可除数。

C++

                         // CPP code to find highest K-digit number divisible by X                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // Function to compute the result                       
                         int                                     answer(                                     int                                     X,                                     int                                     K)                       
                         {                       
                                                 // Computing MAX                       
                                                 int                                     MAX =                                     pow                                     (10, K) - 1;                       
           
                                                 // returning ans                       
                                                 return                                     (MAX - (MAX % X));                       
                         }                       
           
                         // Driver                       
                         int                                     main()                       
                         {                       
                                                 // Number whose divisible is to be found                       
                                                 int                                     X = 30;                       
           
                                                 // Max K-digit divisible is to be found                       
                                                 int                                     K = 3;                       
           
                                                 cout << answer(X, K);                       
                         }                       

JAVA

                         // Java code to find highest                       
                         // K-digit number divisible by X                       
           
                         import                                     java.io.*;                       
                         import                                     java.lang.*;                       
           
                         class                                     GFG {                       
                                                 public                                     static                                     double                                     answer(                                     double                                     X,                                     double                                     K)                       
                                                 {                       
                                                 double                                     i =                                     10                                     ;                       
                                                 // Computing MAX                       
                                                 double                                     MAX = Math.pow(i, K) -                                     1                                     ;                       
           
                                                 // returning ans                       
                                                 return                                     (MAX - (MAX % X));                       
                                                 }                       
           
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
           
                                                 // Number whose divisible is to be found                       
                                                 double                                     X =                                     30                                     ;                       
           
                                                 // Max K-digit divisible is to be found                       
                                                 double                                     K =                                     3                                     ;                       
           
                                                 System.out.println((                                     int                                     )answer(X, K));                       
                                                 }                       
                         }                       
           
                         // Code contributed by Mohit Gupta_OMG <(0_o)>                       

Python3

                         # Python code to find highest                       
                         # K-digit number divisible by X                       
           
                         def                                     answer(X, K):                       
                                   
                                                 # Computing MAX                       
                                                 MAX                                     =                                     pow                                     (                                     10                                     , K)                                     -                                     1                       
                                   
                                                 # returning ans                       
                                                 return                                     (                                     MAX                                     -                                     (                                     MAX                                     %                                     X))                       
           
                         X                                     =                                     30                                     ;                       
                         K                                     =                                     3                                     ;                       
           
                         print                                     (answer(X, K));                       
           
                         # Code contributed by Mohit Gupta_OMG <(0_o)>                       

C#

                         // C# code to find highest                       
                         // K-digit number divisible by X                       
           
                         using                                     System;                       
           
                         class                                     GFG {                       
                                   
                                                 public                                     static                                     double                                     answer(                                     double                                     X,                                     double                                     K)                       
                                                 {                       
                                   
                                                 double                                     i = 10;                       
                                   
                                                 // Computing MAX                       
                                                 double                                     MAX = Math.Pow(i, K) - 1;                       
           
                                                 // returning ans                       
                                                 return                                     (MAX - (MAX % X));                       
                                                 }                       
           
                                                 public                                     static                                     void                                     Main()                       
                                                 {                       
           
                                                 // Number whose divisible is to be found                       
                                                 double                                     X = 30;                       
           
                                                 // Max K-digit divisible is to be found                       
                                                 double                                     K = 3;                       
           
                                                 Console.WriteLine((                                     int                                     )answer(X, K));                       
                                                 }                       
                         }                       
           
                         // This code is contributed by vt_m.                       

PHP

                         <?php                       
                         // PHP code to find highest K-digit                       
                         // number divisible by X                       
           
                         // Function to compute the result                       
                         function                                     answer(                                     $X                                     ,                                     $K                                     )                       
                         {                       
                                   
                                                 // Computing MAX                       
                                                 $MAX                                     = pow(10,                                     $K                                     ) - 1;                       
           
                                                 // returning ans                       
                                                 return                                     (                                     $MAX                                     - (                                     $MAX                                     %                                     $X                                     ));                       
                         }                       
           
                         // Driver                       
                                                 // Number whose divisible                       
                                                 // is to be found                       
                                                 $X                                     = 30;                       
           
                                                 // Max K-digit divisible                       
                                                 // is to be found                       
                                                 $K                                     = 3;                       
           
                                                 echo                                     answer(                                     $X                                     ,                                     $K                                     );                       
           
                         // This code is contributed by ajit                       
                         ?>                       

Javascript

                         <script>                       
                         // Javascript code to find highest K-digit                       
                         // number divisible by X                       
           
                         // Function to compute the result                       
                         function                                     answer(X, K)                       
                         {                       
                                   
                                                 // Computing MAX                       
                                                 let MAX = Math.pow(10, K) - 1;                       
           
                                                 // returning ans                       
                                                 return                                     (MAX - (MAX % X));                       
                         }                       
           
                         // Driver                       
                                                 // Number whose divisible                       
                                                 // is to be found                       
                                                 let X = 30;                       
           
                                                 // Max K-digit divisible                       
                                                 // is to be found                       
                                                 let K = 3;                       
           
                                                 document.write(answer(X, K));                       
           
                         // This code is contributed by gfgking                       
                         </script>                       

输出：

本文由 罗希特·塔普里亚尔 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章