精华内容
下载资源
问答
  • 1到100累乘 用数组来存储这个数位,然后用数组打印出这个数字 9、1到100累乘 1 * 2 * 3*4 * ....100 老师的分析 a[200] a[0] = 1 a[0] * 1 a[0] * 2 = 2 a[0] * 3 = 6; a[0] * 4 = 24; 0+1 a[1] = a[0] / ...
  • 后来我认真分析了这道题,它的要求就是要打印1到100内,数字中不包含有7的整数。分析了要求,我又想了想,这其实就是要求打印1到100内十位或者个位上不是7的整数。但是思路出来了,编写代码又要怎么来呢?后来,我就...
    ------- android培训java培训、期待与您交流!---------
    

        在做黑马程序员测试题时,遇到了这一道题。但是我就想啊,这道题应该怎么做呢?后来我认真分析了这道题,它的要求就是要打印1到100内,数字中不包含有7的整数。分析了要求,我又想了想,这其实就是要求打印1到100内十位或者个位上不是7的整数。但是思路出来了,编写代码又要怎么来呢?后来,我就想到了十位不包含7的代码就是:x/10!=7,个位不包含7的代码就是:x%10!=7。按着这个想法代码如下:

    package com.itheima;
    /**
     *  编写程序,打印1到100之内的整数,但数字中包含7的要跳过,例如:17、27、71、72
     * @author liufeibo 2015
     */
    public class Test7 {
    
    	public static void main(String[] args) {
    		for(int x=1;x<=100;x++){
    			//判断x是否包含7,如果x十位或者个位包含有7就跳过,没有就打印出来
    			if(x/10!=7 && x%10!=7)
    				System.out.println(x);
    		}
    	}
    
    }


    ------- android培训java培训、期待与您交流!---------
    展开全文
  • 输入数字n,按顺序打印1到最大的n位十进制数。比如输入3,则打印出1、2、3一直到最大的3位数即999。陷阱:考虑大数问题,就是输入的数字非常大的情况,如100怎么表示100位的数呢,可以用字符串保存。 细节问题...

        输入数字n,按顺序打印出1到最大的n位十进制数。比如输入3,则打印出1、2、3一直到最大的3位数即999。


    陷阱:考虑大数问题,就是输入的数字非常大的情况,如100,怎么表示100位的数呢,可以用字符串保存。

     

    细节问题:

    1.字符串递增的溢出判断

    2.打印时过滤0

     

    方法一:

          使用字符串数组表示大数,最直观的方法是字符串里每个字符都是’0’到’9’之间的某一个字符,用来表示数字中的一位。因为数字最大是n位的,因此我们需要一个长度为n+l的字符串(字符串中最后一个是结束号\0)。当实际数字不够n位的时候,在字符串的前半部分补0。

          首先把字符串中的每一个数字都初始化为’0’,然后每一次为字符串表示的数字加1,再打印出来。因此只需要做两件事:一是在字符串表达的数字上模拟加法,二是把字符串表达的数字打印出来。

          在这里定义了函数PrintNumber,在这个函数里,只有在碰到第一个非0的字符之后才开始打印,直至字符串的结尾。

     

    1. // ====================方法一====================  
    2. void Print1ToMaxOfNDigits_1(int n)  
    3. {  
    4.     if (n <= 0)  
    5.     {  
    6.         printf("n必须为正整数,参数错误!");  
    7.         return;  
    8.     }  
    9.   
    10.     char* number = new char[n + 1];  
    11.     memset(number, '0', n);  
    12.     number[n] = '\0';  
    13.   
    14.     while (!Increment(number))  
    15.     {  
    16.         PrintNumber(number);  
    17.     }  
    18.   
    19.     delete[] number;  
    20. }  
    21.   
    22.   
    23. // 字符串number表示一个数字,在 number上增加1,如果做加法溢出,则返回true;否则为false  
    24. bool Increment(char* number)  
    25. {  
    26.     bool isOverflow = false;  
    27.     int nTakeOver = 0;  
    28.     int nLength = strlen(number);  
    29.   
    30.     for (int i = nLength - 1; i >= 0; i--)  
    31.     {  
    32.         //将字符串number变为整数,后面才可以自++运算  
    33.         int nSum = number[i] - '0' + nTakeOver;  
    34.   
    35.         if (i == nLength - 1)  
    36.         {  
    37.             nSum++;  
    38.         }  
    39.   
    40.         if (nSum >= 10)  
    41.         {  
    42.             if (i == 0)//由9变为10,这里用0代替,加法溢出了  
    43.             {  
    44.                 isOverflow = true;  
    45.             }  
    46.             else  
    47.             {  
    48.                 nSum -= 10;  
    49.                 nTakeOver = 1;  
    50.                 number[i] = '0' + nSum;//将整数number变为字符串,方便后面进行打印  
    51.             }  
    52.         }  
    53.         else  
    54.         {  
    55.             number[i] = '0' + nSum;  
    56.             break;  
    57.         }  
    58.     }  
    59.   
    60.     return isOverflow;  
    61. }  


    方法二:


    思路:将n位数看做排列组合问题,以3位数为例,有3个位置,每个位上从0到9中选一个数字放进去,求所有的排列情况。三个位置是依次放进去数字的,这可以用递归。每个位置上0到9的十种情况可以用for循环来遍历。另外,记得函数最开始进入时要检查边界条件。

     

    1. // ====================方法二====================  
    2. void Print1ToMaxOfNDigits_2(int n)  
    3. {  
    4.     if (n <= 0)  
    5.     {  
    6.         printf("n必须为正整数,参数错误!");  
    7.         return;  
    8.     }  
    9.   
    10.     char* number = new char[n + 1];  
    11.     number[n] = '\0';  
    12.   
    13.     for (int i = 0; i < 10; i++)  
    14.     {  
    15.         number[0] = i + '0';//整数转为字符串  
    16.   
    17.         Print1ToMaxOfNDigitsRecursively(number, n, 0);  
    18.     }  
    19.   
    20.     delete[] number;  
    21. }  
    22.   
    23. //数字全排列递归法  
    24. void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index)  
    25. {  
    26.     //到了最后一位数字,递归结束  
    27.     if (index == length - 1)  
    28.     {  
    29.         PrintNumber(number);  
    30.         return;  
    31.     }  
    32.   
    33.     for (int i = 0; i < 10; i++)  
    34.     {  
    35.         //整数转为字符串  
    36.         number[index + 1] = i + '0';  
    37.   
    38.         Print1ToMaxOfNDigitsRecursively(number, length, index + 1);  
    39.     }  
    40. }  


    测试用例:

    1.功能测试(输入1,2,3,…);

     

    2.特殊输入测试(输入-1,0)。

     

    完整代码及测试用例实现:

     

    1. #include <stdio.h>  
    2. #include <stdlib.h>  
    3. #include <string.h>  
    4.   
    5. //打印1到最大N位数字  
    6. void PrintNumber(char* number);  
    7. //字符串number表示一个数字,在 number上增加1,如果做加法溢出,返回true;否则为false  
    8. bool Increment(char* number);  
    9. //数字全排列递归法  
    10. void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index);  
    11.   
    12.   
    13. // ====================方法一====================  
    14. void Print1ToMaxOfNDigits_1(int n)  
    15. {  
    16.     if (n <= 0)  
    17.     {  
    18.         printf("n必须为正整数,参数错误!");  
    19.         return;  
    20.     }  
    21.   
    22.     char* number = new char[n + 1];  
    23.     memset(number, '0', n);  
    24.     number[n] = '\0';  
    25.   
    26.     while (!Increment(number))  
    27.     {  
    28.         PrintNumber(number);  
    29.     }  
    30.   
    31.     delete[] number;  
    32. }  
    33.   
    34.   
    35. // 字符串number表示一个数字,在 number上增加1,如果做加法溢出,则返回true;否则为false  
    36. bool Increment(char* number)  
    37. {  
    38.     bool isOverflow = false;  
    39.     int nTakeOver = 0;  
    40.     int nLength = strlen(number);  
    41.   
    42.     for (int i = nLength - 1; i >= 0; i--)  
    43.     {  
    44.         //将字符串number变为整数,后面才可以自++运算  
    45.         int nSum = number[i] - '0' + nTakeOver;  
    46.   
    47.         if (i == nLength - 1)  
    48.         {  
    49.             nSum++;  
    50.         }  
    51.   
    52.         if (nSum >= 10)  
    53.         {  
    54.             if (i == 0)//由9变为10,这里用0代替,加法溢出了  
    55.             {  
    56.                 isOverflow = true;  
    57.             }  
    58.             else  
    59.             {  
    60.                 nSum -= 10;  
    61.                 nTakeOver = 1;  
    62.                 number[i] = '0' + nSum;//将整数number变为字符串,方便后面进行打印  
    63.             }  
    64.         }  
    65.         else  
    66.         {  
    67.             number[i] = '0' + nSum;  
    68.             break;  
    69.         }  
    70.     }  
    71.   
    72.     return isOverflow;  
    73. }  
    74.   
    75.   
    76. // ====================方法二====================  
    77. void Print1ToMaxOfNDigits_2(int n)  
    78. {  
    79.     if (n <= 0)  
    80.     {  
    81.         printf("n必须为正整数,参数错误!");  
    82.         return;  
    83.     }  
    84.   
    85.     char* number = new char[n + 1];  
    86.     number[n] = '\0';  
    87.   
    88.     for (int i = 0; i < 10; i++)  
    89.     {  
    90.         number[0] = i + '0';//整数转为字符串  
    91.   
    92.         Print1ToMaxOfNDigitsRecursively(number, n, 0);  
    93.     }  
    94.   
    95.     delete[] number;  
    96. }  
    97.   
    98. //数字全排列递归法  
    99. void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index)  
    100. {  
    101.     //到了最后一位数字,递归结束  
    102.     if (index == length - 1)  
    103.     {  
    104.         PrintNumber(number);  
    105.         return;  
    106.     }  
    107.   
    108.     for (int i = 0; i < 10; i++)  
    109.     {  
    110.         //整数转为字符串  
    111.         number[index + 1] = i + '0';  
    112.   
    113.         Print1ToMaxOfNDigitsRecursively(number, length, index + 1);  
    114.     }  
    115. }  
    116.   
    117. // ====================公共函数====================  
    118. // 字符串number表示一个数字,数字有若干个0开头, 打印出这个数字,并忽略前面的0  
    119. void PrintNumber(char* number)  
    120. {  
    121.     bool isBeginning = true;  
    122.     int nLength = strlen(number);  
    123.   
    124.     for (int i = 0; i < nLength; i++)  
    125.     {  
    126.         if (isBeginning&&number[i] != '0')  
    127.         {  
    128.             isBeginning = false;  
    129.         }  
    130.         if (!isBeginning)  
    131.         {  
    132.             printf("%c", number[i]);  
    133.         }  
    134.     }  
    135.   
    136.     printf("\t");  
    137. }  
    138.   
    139.   
    140. // ====================测试代码====================  
    141. void Test(int n)  
    142. {  
    143.     printf("Test for %d begins(方法一):\n", n);  
    144.     Print1ToMaxOfNDigits_1(n);  
    145.     printf("\n");  
    146.   
    147.     printf("Test for %d begins(方法二):\n", n);  
    148.     Print1ToMaxOfNDigits_2(n);  
    149.     printf("\n");  
    150.   
    151.     printf("Test for %d ends.\n", n);  
    152. }  
    153.   
    154. int main(int argc, int* argv[])  
    155. {  
    156.     Test(1);  
    157.     Test(2);  
    158.     Test(3);  
    159.     Test(0);  
    160.     Test(-1);  
    161.     system("pause");  
    162.     return 0;  
    163. }  


    运行结果:

    Test for 1 begins(方法一):

    1       2       3       4       5       6       7       8       9

    Test for 1 begins(方法二):

            1       2       3       4       5       6       7       8       9

    Test for 1 ends.

    Test for 2 begins(方法一):

    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      58      59      60

    61      62      63      64      65      66      67      68      69      70      71      72      73      74      75

    76      77      78      79      80      81      82      83      84      85      86      87      88      89      90

    91      92      93      94      95      96      97      98      99

    Test for 2 begins(方法二):

            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      58      59

    60      61      62      63      64      65      66      67      68      69      70      71      72      73      74

    75      76      77      78      79      80      81      82      83      84      85      86      87      88      89

    90      91      92      93      94      95      96      97      98      99

    Test for 2 ends.

    Test for 3 begins(方法一):

    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      58      59      60

    61      62      63      64      65      66      67      68      69      70      71      72      73      74      75

    76      77      78      79      80      81      82      83      84      85      86      87      88      89      90

    91      92      93      94      95      96      97      98      99      100     101     102     103     104     105

    106     107     108     109     110     111     112     113     114     115     116     117     118     119     120

    121     122     123     124     125     126     127     128     129     130     131     132     133     134     135

    136     137     138     139     140     141     142     143     144     145     146     147     148     149     150

    151     152     153     154     155     156     157     158     159     160     161     162     163     164     165

    166     167     168     169     170     171     172     173     174     175     176     177     178     179     180

    181     182     183     184     185     186     187     188     189     190     191     192     193     194     195

    196     197     198     199     200     201     202     203     204     205     206     207     208     209     210

    211     212     213     214     215     216     217     218     219     220     221     222     223     224     225

    226     227     228     229     230     231     232     233     234     235     236     237     238     239     240

    241     242     243     244     245     246     247     248     249     250     251     252     253     254     255

    256     257     258     259     260     261     262     263     264     265     266     267     268     269     270

    271     272     273     274     275     276     277     278     279     280     281     282     283     284     285

    286     287     288     289     290     291     292     293     294     295     296     297     298     299     300

    301     302     303     304     305     306     307     308     309     310     311     312     313     314     315

    316     317     318     319     320     321     322     323     324     325     326     327     328     329     330

    331     332     333     334     335     336     337     338     339     340     341     342     343     344     345

    346     347     348     349     350     351     352     353     354     355     356     357     358     359     360

    361     362     363     364     365     366     367     368     369     370     371     372     373     374     375

    376     377     378     379     380     381     382     383     384     385     386     387     388     389     390

    391     392     393     394     395     396     397     398     399     400     401     402     403     404     405

    406     407     408     409     410     411     412     413     414     415     416     417     418     419     420

    421     422     423     424     425     426     427     428     429     430     431     432     433     434     435

    436     437     438     439     440     441     442     443     444     445     446     447     448     449     450

    451     452     453     454     455     456     457     458     459     460     461     462     463     464     465

    466     467     468     469     470     471     472     473     474     475     476     477     478     479     480

    481     482     483     484     485     486     487     488     489     490     491     492     493     494     495

    496     497     498     499     500     501     502     503     504     505     506     507     508     509     510

    511     512     513     514     515     516     517     518     519     520     521     522     523     524     525

    526     527     528     529     530     531     532     533     534     535     536     537     538     539     540

    541     542     543     544     545     546     547     548     549     550     551     552     553     554     555

    556     557     558     559     560     561     562     563     564     565     566     567     568     569     570

    571     572     573     574     575     576     577     578     579     580     581     582     583     584     585

    586     587     588     589     590     591     592     593     594     595     596     597     598     599     600

    601     602     603     604     605     606     607     608     609     610     611     612     613     614     615

    616     617     618     619     620     621     622     623     624     625     626     627     628     629     630

    631     632     633     634     635     636     637     638     639     640     641     642     643     644     645

    646     647     648     649     650     651     652     653     654     655     656     657     658     659     660

    661     662     663     664     665     666     667     668     669     670     671     672     673     674     675

    676     677     678     679     680     681     682     683     684     685     686     687     688     689     690

    691     692     693     694     695     696     697     698     699     700     701     702     703     704     705

    706     707     708     709     710     711     712     713     714     715     716     717     718     719     720

    721     722     723     724     725     726     727     728     729     730     731     732     733     734     735

    736     737     738     739     740     741     742     743     744     745     746     747     748     749     750

    751     752     753     754     755     756     757     758     759     760     761     762     763     764     765

    766     767     768     769     770     771     772     773     774     775     776     777     778     779     780

    781     782     783     784     785     786     787     788     789     790     791     792     793     794     795

    796     797     798     799     800     801     802     803     804     805     806     807     808     809     810

    811     812     813     814     815     816     817     818     819     820     821     822     823     824     825

    826     827     828     829     830     831     832     833     834     835     836     837     838     839     840

    841     842     843     844     845     846     847     848     849     850     851     852     853     854     855

    856     857     858     859     860     861     862     863     864     865     866     867     868     869     870

    871     872     873     874     875     876     877     878     879     880     881     882     883     884     885

    886     887     888     889     890     891     892     893     894     895     896     897     898     899     900

    901     902     903     904     905     906     907     908     909     910     911     912     913     914     915

    916     917     918     919     920     921     922     923     924     925     926     927     928     929     930

    931     932     933     934     935     936     937     938     939     940     941     942     943     944     945

    946     947     948     949     950     951     952     953     954     955     956     957     958     959     960

    961     962     963     964     965     966     967     968     969     970     971     972     973     974     975

    976     977     978     979     980     981     982     983     984     985     986     987     988     989     990

    991     992     993     994     995     996     997     998     999

    Test for 3 begins(方法二):

            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      58      59

    60      61      62      63      64      65      66      67      68      69      70      71      72      73      74

    75      76      77      78      79      80      81      82      83      84      85      86      87      88      89

    90      91      92      93      94      95      96      97      98      99      100     101     102     103     104

    105     106     107     108     109     110     111     112     113     114     115     116     117     118     119

    120     121     122     123     124     125     126     127     128     129     130     131     132     133     134

    135     136     137     138     139     140     141     142     143     144     145     146     147     148     149

    150     151     152     153     154     155     156     157     158     159     160     161     162     163     164

    165     166     167     168     169     170     171     172     173     174     175     176     177     178     179

    180     181     182     183     184     185     186     187     188     189     190     191     192     193     194

    195     196     197     198     199     200     201     202     203     204     205     206     207     208     209

    210     211     212     213     214     215     216     217     218     219     220     221     222     223     224

    225     226     227     228     229     230     231     232     233     234     235     236     237     238     239

    240     241     242     243     244     245     246     247     248     249     250     251     252     253     254

    255     256     257     258     259     260     261     262     263     264     265     266     267     268     269

    270     271     272     273     274     275     276     277     278     279     280     281     282     283     284

    285     286     287     288     289     290     291     292     293     294     295     296     297     298     299

    300     301     302     303     304     305     306     307     308     309     310     311     312     313     314

    315     316     317     318     319     320     321     322     323     324     325     326     327     328     329

    330     331     332     333     334     335     336     337     338     339     340     341     342     343     344

    345     346     347     348     349     350     351     352     353     354     355     356     357     358     359

    360     361     362     363     364     365     366     367     368     369     370     371     372     373     374

    375     376     377     378     379     380     381     382     383     384     385     386     387     388     389

    390     391     392     393     394     395     396     397     398     399     400     401     402     403     404

    405     406     407     408     409     410     411     412     413     414     415     416     417     418     419

    420     421     422     423     424     425     426     427     428     429     430     431     432     433     434

    435     436     437     438     439     440     441     442     443     444     445     446     447     448     449

    450     451     452     453     454     455     456     457     458     459     460     461     462     463     464

    465     466     467     468     469     470     471     472     473     474     475     476     477     478     479

    480     481     482     483     484     485     486     487     488     489     490     491     492     493     494

    495     496     497     498     499     500     501     502     503     504     505     506     507     508     509

    510     511     512     513     514     515     516     517     518     519     520     521     522     523     524

    525     526     527     528     529     530     531     532     533     534     535     536     537     538     539

    540     541     542     543     544     545     546     547     548     549     550     551     552     553     554

    555     556     557     558     559     560     561     562     563     564     565     566     567     568     569

    570     571     572     573     574     575     576     577     578     579     580     581     582     583     584

    585     586     587     588     589     590     591     592     593     594     595     596     597     598     599

    600     601     602     603     604     605     606     607     608     609     610     611     612     613     614

    615     616     617     618     619     620     621     622     623     624     625     626     627     628     629

    630     631     632     633     634     635     636     637     638     639     640     641     642     643     644

    645     646     647     648     649     650     651     652     653     654     655     656     657     658     659

    660     661     662     663     664     665     666     667     668     669     670     671     672     673     674

    675     676     677     678     679     680     681     682     683     684     685     686     687     688     689

    690     691     692     693     694     695     696     697     698     699     700     701     702     703     704

    705     706     707     708     709     710     711     712     713     714     715     716     717     718     719

    720     721     722     723     724     725     726     727     728     729     730     731     732     733     734

    735     736     737     738     739     740     741     742     743     744     745     746     747     748     749

    750     751     752     753     754     755     756     757     758     759     760     761     762     763     764

    765     766     767     768     769     770     771     772     773     774     775     776     777     778     779

    780     781     782     783     784     785     786     787     788     789     790     791     792     793     794

    795     796     797     798     799     800     801     802     803     804     805     806     807     808     809

    810     811     812     813     814     815     816     817     818     819     820     821     822     823     824

    825     826     827     828     829     830     831     832     833     834     835     836     837     838     839

    840     841     842     843     844     845     846     847     848     849     850     851     852     853     854

    855     856     857     858     859     860     861     862     863     864     865     866     867     868     869

    870     871     872     873     874     875     876     877     878     879     880     881     882     883     884

    885     886     887     888     889     890     891     892     893     894     895     896     897     898     899

    900     901     902     903     904     905     906     907     908     909     910     911     912     913     914

    915     916     917     918     919     920     921     922     923     924     925     926     927     928     929

    930     931     932     933     934     935     936     937     938     939     940     941     942     943     944

    945     946     947     948     949     950     951     952     953     954     955     956     957     958     959

    960     961     962     963     964     965     966     967     968     969     970     971     972     973     974

    975     976     977     978     979     980     981     982     983     984     985     986     987     988     989

    990     991     992     993     994     995     996     997     998     999

    Test for 3 ends.

    Test for 0 begins(方法一):

    n必须为正整数,参数错误!

    Test for 0 begins(方法二):

    n必须为正整数,参数错误!

    Test for 0 ends.

    Test for -1 begins(方法一):

    n必须为正整数,参数错误!

    Test for -1 begins(方法二):

    n必须为正整数,参数错误!

    Test for -1 ends.

    请按任意键继续. . .

     

    考点:

    1.考查解决大数问题的能力;

    2.时间空间复杂度尽可能好;

    3.能否用递归做。

     

    总结:

        如果面试题是关于n位的整数并且没有限定n的取值范围,或者是输入任意大小的整数,那么这个题目很有可能是需要考虑大数问题。字符串是一个简单、有效的表示大数的方法。

    展开全文
  • 打印1到最大的n位数 剑指 Offer 17. 打印1到最大的n位数 输入数字 n,按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3,则打印出 1、2、3 一直到最大的 3 位数 999。 示例 1: 输入: n = 1 输出: [1,2,3,4,...

    剑指 Offer 17. 打印从1到最大的n位数

    剑指 Offer 17. 打印从1到最大的n位数

    输入数字 n,按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3,则打印出 1、2、3 一直到最大的 3 位数 999。

    示例 1:
    输入: n = 1
    输出: [1,2,3,4,5,6,7,8,9]

    说明:
    用返回一个整数列表来代替打印
    n 为正整数


    思路

    一开始想的,比如n = 3,那么最大值是999,999怎么来呢?
    999 = 9 * 100 + 9 * 10 + 9 * 1
    通过一个for循环,循环三次,每次将结果相加

    后来发现,不需要这么麻烦
    可以直接使用1000 - 1即可

    class Solution {
        public int[] printNumbers(int n) {
        	//边界条件
            if(n < 0) return null;
            
            int maxValue = (int)Math.pow(10, n) - 1;
            int[] arr = new int[maxValue];
            
            for(int i = 0; i < maxValue; i++)
            {
                arr[i] = i + 1;
            }
    
            return arr;
        }
    }
    

    难点
    对于Java的数组操作不熟练

    展开全文
  • 陷阱:考虑大数问题,就是输入的数字非常大的情况,如100怎么表示100位的数呢。用字符串保存 细节问题 1,字符串递增的溢出判断 2,打印时过滤0 源代码 #include "stdio.h" #include "stdlib.h"

    题目:输入数字n,按顺序打印出从1最大的n位十进制数。例如输入3,则打印出1,2,3,....,一直到最大的3位数即999

    陷阱:考虑大数问题,就是输入的数字非常大的情况,如100,怎么表示100位的数呢。用字符串保存

    细节问题

    1,字符串递增的溢出判断

    2,打印时过滤0

    源代码

    #include "stdio.h"  
    #include "stdlib.h"  
    #include "string.h"  
    bool Increase(char* num)  
    {  
        bool isOverFlow=true;  
        int len=strlen(num);  
        int takeover=0;  
        for(int i=0;i<len;i++)  
        {  
            int a=num[i]-'0'+takeover;  
            if(i==0)  
                a=a+1;  
            if(a>=10)  
            {  
                if(i==len-1)  
                {  
                    isOverFlow=false;  
                }  
                else  
                {  
                    a=a-10;  
                    takeover=1;  
                    num[i]='0'+a;  
                }  
            }  
            else  
            {  
                num[i]='0'+a;  
                break;  
            }  
        }  
        return isOverFlow;  
    }  
    void Print(char *p)  
    {  
        int len=strlen(p);  
        int i=len-1;  
        while(p[i]=='0')  
        {  
            i--;  
        }  
        for(;i>=0;i--)  
        {  
            printf("%c",p[i]);  
      
        }  
    }  
    void test(int &n)  
    {  
        n++;  
    }  
    void main()  
    {  
        int n;  
        printf("输入n:");  
        scanf("%d",&n);  
        char *p;  
        p=(char *)malloc((n+1)*sizeof(char));  
        memset(p,'0',n);  
          
        p[n]='\0';  
        printf("\n%s",p);  
        printf("长度:%d\n",strlen(p));  
        while(Increase(p))  
        {  
            Print(p);  
            printf("\t");  
        }  
    }  
    


    展开全文
  • 面试题12:打印1到最大的n位数

    千次阅读 2013-06-19 22:53:20
    陷阱:考虑大数问题,就是输入的数字非常大的情况,如100怎么表示100位的数呢。用字符串保存 细节问题 1,字符串递增的溢出判断 2,打印时过滤0 源代码 #include "stdio.h" #include "stdlib.h" #include ...
  • 输入数字n,按顺序打印1开始最大的n位十进制数,例如当n = 3,就输出从1~999. 解题思路 可能大家会想这么简单的题用一个for循环输出不就好了吗,其实这是最基本的情况。如果n为100呢?整型数据存不下的时候...
  • 写一个程序,打印数字1到100,3的倍数打印“Fizz”来替换这个数,5的倍数打印“Buzz”,对于既是3的倍数又是5的倍数的数字打印“FizzBuzz”for x in range(101):print("fizz"[x%3*4::]+"buzz"[x%5*4::]or x)解析:...
  • 本文介绍另外一种循环语句,for循环,直接看例子。 1.用for实现打印1到10的数字。 ...怎么样是不是很简单,下面我们来做个稍微有点难度...2.用for循环打印1到100的和 注意: range(1,101)函数,右边是不包括的
  • 第一行输入t表示case数(1<=t<=100) 每个case第一行输入n表示有n颗圣诞树(1) 每个case第二行n个数字ai表示圣诞树的高度(2) **输出格式 ** 对于每个case输出最终的样子 每个case之后需要加一个...
  • ◆在调试中怎么样MESSAGEBOX一个数字◆ 16 ◆如何控制控件的焦点◆ 16 ◆如何对析构函数中对象进行释放◆ 16 ◆如何关闭一个模态窗口◆ 17 ◆如何将一个提示的声音发声卡上◆ 17 ◆如何得到打开exe的带的参数◆ 17...
  • //g.drawRect(0,0,width-1,height-1); // 随机产生155条干扰线,使图象中的认证码不易被其它程序探测 g.setColor(getRandColor(160,200)); for (int i=0;i ;i++) { int x = random.nextInt(width); int y ...
  • i++,a++) //打印hello mfc和数字 { CString b; b.Format(TEXT("%d"), a); dc.TextOutW(0, i*linesize, TEXT("HELLO MFC"), 9); dc.TextOutW(240, i*linesize, b); } } int Cmywindow::...
  • 网管教程 从入门精通软件篇 ★一。★详细的xp修复控制台命令和用法!!! 放入xp(2000)的光盘,安装时候选R,修复! Windows XP(包括 Windows 2000)的控制台命令是在系统出现一些意外情况下的一种非常有效的...
  • C#初学者必读

    2018-07-03 23:53:21
    当我问到“你的.Net基础怎么样”的时候,很多人都回答“学过C#、.Net、ASP.Net,感觉基础还行”,但是我给了他一个很简单的题,比如“用for循环累加的方式计算1到100之间整数的和”、“提示用户输入两个数字,...
  • One编程组第四次题目

    2008-04-27 13:02:00
    现在有1-100个数,你心中想一个数字。计算机猜一个数字,如果大了,你就输入B,如果小了,你就输入L,如果相等就输入E,然后计算机将正确的数打印出来,并结束程序。这个过程一直计算机猜中你心中的数为止。如果你...
  • 1 理解计算机是怎么运行程序的 2 运行一个已解释的程序 3 运行一个已编译的程序 4 C++在哪里 5 理解Visual c++中的程序文件 6 创建源代码文件 7 理解并创建头文件 第二章 结构和语法 8 理解计算机语言 9 理解计算机...
  • CPCL打印机和编辑器

    2020-01-09 08:50:22
    1 => 每次打印的张数,默认1张/每次 就行. 2.模板宽度/宽度(一般为第二行起) PAGE-WIDTH 580 1 PAGE-WIDTH => 没啥好说的 580 => 模板的宽度,单位为mm 如果是模板长度还可以额外设置 PAGE-HEIGHT 1100 或 PH 1100...
  • if(i*100/cnt==10 && pan_10==0)//pan_10的目的是只允许打印一次进度情况 { printf("10%%"); pan_10=1; } if(i*100/cnt==20 && pan_20==0) { printf("[■□□□□]20%%"); ...
  • C语言编程要点

    2017-09-18 00:10:37
    17.12. 怎样按科学记数法打印数字? 232 17.13. 什么是ANSI驱动程序? 233 17.14. 怎样通过ANSI驱动程序来清屏? 233 17.15. 样通过ANSI驱动程序来存储光标位置? 233 17.16. 怎样通过ANSI驱动程序来恢复光标位置? 234 ...
  • 最新Java面试宝典pdf版

    热门讨论 2011-08-31 11:29:22
    1、用两种方式根据部门号从高低,工资从低高列出每个员工的信息。 91 2、列出各个部门中工资高于本部门的平均工资的员工数和部门号,并按部门号排序 91 3、存储过程与触发器必须讲,经常被面试? 92 4、数据库...
  • Java面试宝典-经典

    2015-03-28 21:44:36
    1、用两种方式根据部门号从高低,工资从低高列出每个员工的信息。 91 2、列出各个部门中工资高于本部门的平均工资的员工数和部门号,并按部门号排序 91 3、存储过程与触发器必须讲,经常被面试? 92 4、数据库...
  • 要理解这个表达式,请按下列顺序分析它:\d{1,3}匹配1到3位的数字,(\d{1,3}\.){3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次,最后再加上一个一到三位的数字(\d{1,3})。 IP地址中每个数字都不能...
  • Java面试宝典2012版

    2012-12-03 21:57:42
    1、用两种方式根据部门号从高低,工资从低高列出每个员工的信息。 91 2、列出各个部门中工资高于本部门的平均工资的员工数和部门号,并按部门号排序 91 3、存储过程与触发器必须讲,经常被面试? 92 4、...
  • 1、用两种方式根据部门号从高低,工资从低高列出每个员工的信息。 91 2、列出各个部门中工资高于本部门的平均工资的员工数和部门号,并按部门号排序 91 3、存储过程与触发器必须讲,经常被面试? 92 4、数据库...

空空如也

空空如也

1 2 3 4
收藏数 74
精华内容 29
关键字:

怎么打印数字1到100