打印所有n位数严格递增的数字-yiteyi-C++库

给定一个数字中的数字n，打印所有数字严格从左到右递增的n位数字。 例如：

null

Input:  n = 2Output:  01 02 03 04 05 06 07 08 09 12 13 14 15 16 17 18 19 23 24 25 26 27 28 29 34 35 36 37 38 39 45 46 47 48 49 56 57 58 59 67 68 69 78 79 89Input:  n = 3Output:  012 013 014 015 016 017 018 019 023 024 025 026 027 028 029 034 035 036 037 038 039 045 046 047 048 049 056 057 058 059 067 068 069 078 079 089 123 124 125 126 127 128 129 134 135 136 137 138 139 145 146 147 148 149 156 157 158 159 167 168 169 178 179 189 234 235 236 237 238 239 245 246 247 248 249 256 257 258 259 267 268 269 278 279 289 345 346 347 348 349 356 357 358 359 367 368 369 378 379 389 456 457 458 459 467 468 469 478 479 489 567 568 569 578 579 589 678 679 689 789Input:  n = 1Output: 0 1 2 3 4 5 6 7 8 9

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

其思想是使用递归。我们从一个可能的N位数字的最左边开始，从大于其前一位的所有数字的集合中填充它。i、 e.用数字（i到9）填充当前位置，其中i是它的前一个数字。填充当前位置后，我们用严格递增的数字递归下一个位置。以下是上述理念的实施——

C++

                         // C++ program to print all n-digit numbers whose digits                       
                         // are strictly increasing from left to right                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // Function to print all n-digit numbers whose digits                       
                         // are strictly increasing from left to right.                       
                         // out   --> Stores current output number as string                       
                         // start --> Current starting digit to be considered                       
                         void                                     findStrictlyIncreasingNum(                                     int                                     start, string out,                                     int                                     n)                       
                         {                       
                                                 // If number becomes N-digit, print it                       
                                                 if                                     (n == 0)                       
                                                 {                       
                                                 cout << out <<                                     " "                                     ;                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 // start from (prev digit + 1) till 9                       
                                                 for                                     (                                     int                                     i = start; i <= 9; i++)                       
                                                 {                       
                                                 // append current digit to number                       
                                                 string str = out + to_string(i);                       
           
                                                 // recurse for next digit                       
                                                 findStrictlyIncreasingNum(i + 1, str, n - 1);                       
                                                 }                       
                         }                       
           
                         // Driver code                       
                         int                                     main()                       
                         {                       
                                                 int                                     n = 3;                       
                                                 findStrictlyIncreasingNum(0,                                     ""                                     , n);                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java program to print all n-digit numbers whose digits                       
                         // are strictly increasing from left to right                       
                         import                                     java.io.*;                       
           
                         class                                     Increasing                       
                         {                       
                                                 // Function to print all n-digit numbers whose digits                       
                                                 // are strictly increasing from left to right.                       
                                                 // out   --> Stores current output number as string                       
                                                 // start --> Current starting digit to be considered                       
                                                 void                                     findStrictlyIncreasingNum(                                     int                                     start, String out,                                     int                                     n)                       
                                                 {                       
                                                 // If number becomes N-digit, print it                       
                                                 if                                     (n ==                                     0                                     )                       
                                                 {                       
                                                 System.out.print(out +                                     " "                                     );                       
                                                 return                                     ;                       
                                                 }                       
                                   
                                                 // start from (prev digit + 1) till 9                       
                                                 for                                     (                                     int                                     i = start; i <=                                     9                                     ; i++)                       
                                                 {                       
                                                 // append current digit to number                       
                                                 String str = out + Integer.toString(i);                       
                                   
                                                 // recurse for next digit                       
                                                 findStrictlyIncreasingNum(i +                                     1                                     , str, n -                                     1                                     );                       
                                                 }                       
                                                 }                       
           
                                                 // Driver code for above function                       
                                                 public                                     static                                     void                                     main(String args[])                                     throws                                     IOException                       
                                                 {                       
                                                 Increasing obj =                                     new                                     Increasing();                       
                                                 int                                     n =                                     3                                     ;                       
                                                 obj.findStrictlyIncreasingNum(                                     0                                     ,                                     " "                                     , n);                       
                                                 }                       
                         }                       

Python3

                         # Python3 program to print all n-digit numbers                       
                         # whose digits are strictly increasing                       
                         # from left to right                       
           
                         # Function to print all n-digit numbers                       
                         # whose digits are strictly increasing                       
                         # from left to right.                       
                         # out --> Stores current output                       
                         #         number as string                       
                         # start --> Current starting digit                       
                         #           to be considered                       
                         def                                     findStrictlyIncreasingNum(start, out, n):                       
                                   
                                                 # If number becomes N-digit, print                       
                                                 if                                     (n                                     =                                     =                                     0                                     ):                       
                                                 print                                     (out, end                                     =                                     " "                                     )                       
                                                 return                       
           
                                                 # start from (prev digit + 1) till 9                       
                                                 for                                     i                                     in                                     range                                     (start,                                     10                                     ):                       
                                   
                                                 # append current digit to number                       
                                                 str1                                     =                                     out                                     +                                     str                                     (i)                       
           
                                                 # recurse for next digit                       
                                                 findStrictlyIncreasingNum(i                                     +                                     1                                     ,                       
                                                 str1, n                                     -                                     1                                     )                       
           
                         # Driver code                       
                         n                                     =                                     3                       
                         findStrictlyIncreasingNum(                                     0                                     , "", n)                       
           
                         # This code is contributed by Mohit Kumar                       

C#

                         // C# program to print all n-digit numbers                       
                         // whose digits are strictly increasing                       
                         // from left to right                       
                         using                                     System;                       
           
                         class                                     GFG {                       
                                   
                                                 // Function to print all n-digit numbers                       
                                                 // whose digits are strictly increasing                       
                                                 // from left to right. out --> Stores                       
                                                 // current output number as string                       
                                                 // start --> Current starting digit to                       
                                                 // be considered                       
                                                 static                                     void                                     findStrictlyIncreasingNum(                                     int                                     start,                       
                                                 string                                     Out,                                     int                                     n)                       
                                                 {                       
                                   
                                                 // If number becomes N-digit, print it                       
                                                 if                                     (n == 0)                       
                                                 {                       
                                                 Console.Write(Out +                                     " "                                     );                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 // start from (prev digit + 1) till 9                       
                                                 for                                     (                                     int                                     i = start; i <= 9; i++)                       
                                                 {                       
                                   
                                                 // append current digit to number                       
                                                 string                                     str = Out + Convert.ToInt32(i);                       
           
                                                 // recurse for next digit                       
                                                 findStrictlyIncreasingNum(i + 1, str, n - 1);                       
                                                 }                       
                                                 }                       
           
                                                 // Driver code for above function                       
                                                 public                                     static                                     void                                     Main()                       
                                                 {                       
                                                 int                                     n = 3;                       
                                                 findStrictlyIncreasingNum(0,                                     " "                                     , n);                       
                                                 }                       
                         }                       
           
                         // This code is contributed by Sam007.                       

Javascript

                         <script>                       
           
                         // Javascript program to print all                       
                         // n-digit numbers whose digits                       
                         // are strictly increasing from                       
                         // left to right                       
                                   
                                                 // Function to print all                       
                                                 // n-digit numbers whose digits                       
                                                 // are strictly increasing                       
                                                 // from left to right.                       
                                                 // out   --> Stores current                       
                                                 // output number as string                       
                                                 // start --> Current starting                       
                                                 // digit to be considered                       
                                                 function                                     findStrictlyIncreasingNum(start,out,n)                       
                                                 {                       
                                                 // If number becomes N-digit, print it                       
                                                 if                                     (n == 0)                       
                                                 {                       
                                                 document.write(out +                                     " "                                     );                       
                                                 return                                     ;                       
                                                 }                       
                                   
                                                 // start from (prev digit + 1) till 9                       
                                                 for                                     (let i = start; i <= 9; i++)                       
                                                 {                       
                                                 // append current digit to number                       
                                                 let str = out + i.toString();                       
                                   
                                                 // recurse for next digit                       
                                                 findStrictlyIncreasingNum(i + 1, str, n - 1);                       
                                                 }                       
                                                 }                       
                                   
                                                 // Driver code for above function                       
                                                 let n = 3;                       
                                                 findStrictlyIncreasingNum(0,                                     " "                                     , n);                       
           
                         // This code is contributed by unknown2108                       
           
                         </script>                       

输出：

012 013 014 015 016 017 018 019 023 024 025 026 027 028 029 034 035 036 037 038 039 045 046 047 048 049 056 057 058 059 067 068 069 078 079 089 123 124 125 126 127 128 129 134 135 136 137 138 139 145 146 147 148 149 156 157 158 159 167 168 169 178 179 189 234 235 236 237 238 239 245 246 247 248 249 256 257 258 259 267 268 269 278 279 289 345 346 347 348 349 356 357 358 359 367 368 369 378 379 389 456 457 458 459 467 468 469 478 479 489 567 568 569 578 579 589 678 679 689 789

时间复杂性： O（N！） 辅助空间： O（N） 练习： 打印数字从左到右严格递减的所有n位数字。本文由 阿迪蒂亚·戈尔 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

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

THE END

技术文章