------- 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位的数呢，可以用字符串保存。
 
细节问题：
1.字符串递增的溢出判断
2.打印时过滤0
 
方法一：
      使用字符串数组表示大数，最直观的方法是字符串里每个字符都是’0’到’9’之间的某一个字符，用来表示数字中的一位。因为数字最大是n位的，因此我们需要一个长度为n+l的字符串（字符串中最后一个是结束号’\0’）。当实际数字不够n位的时候，在字符串的前半部分补0。
      首先把字符串中的每一个数字都初始化为’0’，然后每一次为字符串表示的数字加1，再打印出来。因此只需要做两件事：一是在字符串表达的数字上模拟加法，二是把字符串表达的数字打印出来。
      在这里定义了函数PrintNumber，在这个函数里，只有在碰到第一个非0的字符之后才开始打印，直至字符串的结尾。
 
[cpp] view plain copy
// ====================方法一====================  
void Print1ToMaxOfNDigits_1(int n)  
{  
    if (n <= 0)  
    {  
        printf("n必须为正整数，参数错误！");  
        return;  
    }  
  
    char* number = new char[n + 1];  
    memset(number, '0', n);  
    number[n] = '\0';  
  
    while (!Increment(number))  
    {  
        PrintNumber(number);  
    }  
  
    delete[] number;  
}  
  
  
// 字符串number表示一个数字，在 number上增加1,如果做加法溢出，则返回true；否则为false  
bool Increment(char* number)  
{  
    bool isOverflow = false;  
    int nTakeOver = 0;  
    int nLength = strlen(number);  
  
    for (int i = nLength - 1; i >= 0; i--)  
    {  
        //将字符串number变为整数，后面才可以自++运算  
        int nSum = number[i] - '0' + nTakeOver;  
  
        if (i == nLength - 1)  
        {  
            nSum++;  
        }  
  
        if (nSum >= 10)  
        {  
            if (i == 0)//由9变为10，这里用0代替，加法溢出了  
            {  
                isOverflow = true;  
            }  
            else  
            {  
                nSum -= 10;  
                nTakeOver = 1;  
                number[i] = '0' + nSum;//将整数number变为字符串，方便后面进行打印  
            }  
        }  
        else  
        {  
            number[i] = '0' + nSum;  
            break;  
        }  
    }  
  
    return isOverflow;  
}  

方法二：

思路：将n位数看做排列组合问题，以3位数为例，有3个位置，每个位上从0到9中选一个数字放进去，求所有的排列情况。三个位置是依次放进去数字的，这可以用递归。每个位置上0到9的十种情况可以用for循环来遍历。另外，记得函数最开始进入时要检查边界条件。
 
[cpp] view plain copy
// ====================方法二====================  
void Print1ToMaxOfNDigits_2(int n)  
{  
    if (n <= 0)  
    {  
        printf("n必须为正整数，参数错误！");  
        return;  
    }  
  
    char* number = new char[n + 1];  
    number[n] = '\0';  
  
    for (int i = 0; i < 10; i++)  
    {  
        number[0] = i + '0';//整数转为字符串  
  
        Print1ToMaxOfNDigitsRecursively(number, n, 0);  
    }  
  
    delete[] number;  
}  
  
//数字全排列递归法  
void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index)  
{  
    //到了最后一位数字，递归结束  
    if (index == length - 1)  
    {  
        PrintNumber(number);  
        return;  
    }  
  
    for (int i = 0; i < 10; i++)  
    {  
        //整数转为字符串  
        number[index + 1] = i + '0';  
  
        Print1ToMaxOfNDigitsRecursively(number, length, index + 1);  
    }  
}  

测试用例：
1.功能测试（输入1，2，3，…）；
 
2.特殊输入测试（输入-1，0）。
 
完整代码及测试用例实现：
 
[cpp] view plain copy
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
  
//打印1到最大N位数字  
void PrintNumber(char* number);  
//字符串number表示一个数字，在 number上增加1，如果做加法溢出，返回true；否则为false  
bool Increment(char* number);  
//数字全排列递归法  
void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index);  
  
  
// ====================方法一====================  
void Print1ToMaxOfNDigits_1(int n)  
{  
    if (n <= 0)  
    {  
        printf("n必须为正整数，参数错误！");  
        return;  
    }  
  
    char* number = new char[n + 1];  
    memset(number, '0', n);  
    number[n] = '\0';  
  
    while (!Increment(number))  
    {  
        PrintNumber(number);  
    }  
  
    delete[] number;  
}  
  
  
// 字符串number表示一个数字，在 number上增加1,如果做加法溢出，则返回true；否则为false  
bool Increment(char* number)  
{  
    bool isOverflow = false;  
    int nTakeOver = 0;  
    int nLength = strlen(number);  
  
    for (int i = nLength - 1; i >= 0; i--)  
    {  
        //将字符串number变为整数，后面才可以自++运算  
        int nSum = number[i] - '0' + nTakeOver;  
  
        if (i == nLength - 1)  
        {  
            nSum++;  
        }  
  
        if (nSum >= 10)  
        {  
            if (i == 0)//由9变为10，这里用0代替，加法溢出了  
            {  
                isOverflow = true;  
            }  
            else  
            {  
                nSum -= 10;  
                nTakeOver = 1;  
                number[i] = '0' + nSum;//将整数number变为字符串，方便后面进行打印  
            }  
        }  
        else  
        {  
            number[i] = '0' + nSum;  
            break;  
        }  
    }  
  
    return isOverflow;  
}  
  
  
// ====================方法二====================  
void Print1ToMaxOfNDigits_2(int n)  
{  
    if (n <= 0)  
    {  
        printf("n必须为正整数，参数错误！");  
        return;  
    }  
  
    char* number = new char[n + 1];  
    number[n] = '\0';  
  
    for (int i = 0; i < 10; i++)  
    {  
        number[0] = i + '0';//整数转为字符串  
  
        Print1ToMaxOfNDigitsRecursively(number, n, 0);  
    }  
  
    delete[] number;  
}  
  
//数字全排列递归法  
void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index)  
{  
    //到了最后一位数字，递归结束  
    if (index == length - 1)  
    {  
        PrintNumber(number);  
        return;  
    }  
  
    for (int i = 0; i < 10; i++)  
    {  
        //整数转为字符串  
        number[index + 1] = i + '0';  
  
        Print1ToMaxOfNDigitsRecursively(number, length, index + 1);  
    }  
}  
  
// ====================公共函数====================  
// 字符串number表示一个数字，数字有若干个0开头， 打印出这个数字，并忽略前面的0  
void PrintNumber(char* number)  
{  
    bool isBeginning = true;  
    int nLength = strlen(number);  
  
    for (int i = 0; i < nLength; i++)  
    {  
        if (isBeginning&&number[i] != '0')  
        {  
            isBeginning = false;  
        }  
        if (!isBeginning)  
        {  
            printf("%c", number[i]);  
        }  
    }  
  
    printf("\t");  
}  
  
  
// ====================测试代码====================  
void Test(int n)  
{  
    printf("Test for %d begins(方法一):\n", n);  
    Print1ToMaxOfNDigits_1(n);  
    printf("\n");  
  
    printf("Test for %d begins(方法二):\n", n);  
    Print1ToMaxOfNDigits_2(n);  
    printf("\n");  
  
    printf("Test for %d ends.\n", n);  
}  
  
int main(int argc, int* argv[])  
{  
    Test(1);  
    Test(2);  
    Test(3);  
    Test(0);  
    Test(-1);  
    system("pause");  
    return 0;  
}  

运行结果：
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的取值范围，或者是输入任意大小的整数，那么这个题目很有可能是需要考虑大数问题。字符串是一个简单、有效的表示大数的方法。

剑指 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的数组操作不熟练

题目：输入数字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");  
    }  
}