int num=0;
                for(int y=1;y<1000;y++)
                {
                        int a;//百
                        int b;//十
                        int c;//个
                        a=(y/100)%10;
                        b=(y/10)%10;
                        c=y%10;
                        if(a==1|b==1|c==1)
                        {
                                num++;
                                System.out.println("1到1000包含1的个数为："+num);
                        }


这段代码哪错了？
编译可以通过，但是数目不对，应该是计算的问题啊···
求出1-1000以内包含多少个1  
比如：1中包含一个  10中包含1个  111中包含3个        

public static void main(String[] args) {
                int num=0;
        for(int y=1;y<1000;y++)
        {
                int a =0 ;//百
                int b = 0;//十
                int c = 0;//个
                a=y/100;
                b=y%100/10;
                c=y%10;
                if(a==1||b==1||c==1)
                {
                        num++;
                        System.out.println("1到1000包含1的数为："+(a*100+b*10+c));
                }
        }
        System.out.println("1到1000包含1的数总共有："+num+"个");
        }

方志亮 发表于 2012-8-17 22:29
public static void main(String[] args) {
                int num=0;
        for(int y=1;y

不好意思 ，你的答案是错误的，
我的那个代码也是271

不好意思,1-1000
少算了个1000
多加一个千位判断
答案272

你可以用排列组合算001~999
不为1的数,百位9种,十位9种,各位9种,再除去000
1000-9*9*9+1=272

int num=0;
                for(int y=1;y<1000;y++)
                {
                        int a;//百
                        int b;//十
                        int c;//个
                        a=(y/100)%10;
                        b=(y/10)%10;
                        c=y%10;
                        if(a==1|b==1|c==1)
                        {
                                num++;
                                System.out.println("1到1000包含1的个数为："+num);

    }
楼主要求出1-1000以内包含多少个1  ，上述红色标记的代码只能表示a,b,c中有一个为1时，计数一次，而忽略了，当abc中同时有两个或三个为1的情况，有几个1就得计数几次，所以必须要分开判断。
还有一个问题，要求1到1000以内，包含了1000这个四位数，所以还需要再定义一个千位进行判断。
为了方便楼主观看，我直接将千位定义为d，直接加上上面了，下面贴出详细的代码：

1. class  Test
   
2. {
   
3.        
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 int num=0;
   
7.                 int i=0;
   
8.                 int j=0;
   
9.                 int k=0;
   
10.                 int g=0;
    
11.                  for(int y=1;y<=1000;y++)
    
12.                  {
    
13.                          int a;//百
    
14.                          int b;//十
    
15.                          int c;//个
    
16.                                                  int d;//千
    
17.                        
    
18.                                                  a=(y/100)%10;
    
19.                          b=(y/10)%10;
    
20.                          c=y%10;
    
21.                                                 d=(y/1000)%10;
    
22.                          if(a==1)
    
23.                          {
    
24.                            i++;
    
25.                                 
    
26.                          }
    
27.                                                  if (b==1)
    
28.                                                  {
    
29.                                                          j++;
    
30.                                                  }
    
31.                                                  if (c==1)
    
32.                                                  {
    
33.                                                          k++;
    
34.                                                  }
    
35.                                                  if (d==1)
    
36.                                                  {
    
37.                                                          g++;
    
38.                                                  }
    
39.   
    
40.                                         }
    
41.                                         num = i+j+k+g;
    
42.                                          System.out.println("1到1000包含1的个数为："+num);
    
43.                                          
    
44.         }
    
45.        
    
46. 
    
47. }

复制代码

打印结果为：1到1000包含1的个数为：301

1. class  Test
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int num=0;
   
6.                 int i=0;
   
7.                 int j=0;
   
8.                 int k=0;
   
9.                 int g=0;
   
10. 
    
11.                 for (int y=0; y<=1000; y++)
    
12.                 {
    
13.                         int d;//千
    
14.                         int a;//百
    
15.             int b;//十
    
16.             int c;//个
    
17.                         
    
18.                         d=(y/1000)%10;
    
19.                     a=(y/100)%10;
    
20.             b=(y/10)%10;
    
21.             c=y%10;
    
22. 
    
23.                         if (a==1)
    
24.                         {
    
25.                                 i++;
    
26.                         }
    
27.                         if (b==1)
    
28.                         {
    
29.                                 j++;
    
30.                         }
    
31.                         if (c==1)
    
32.                         {
    
33.                                 k++;
    
34.                         }
    
35.                         if (d==1)
    
36.                         {
    
37.                                 g++;
    
38.                         }
    
39.                 }
    
40.                 num = i+j+k+g;
    
41.                 System.out.println("1到1000包含1的个数为："+num);
    
42.                                                 
    
43.                
    
44.         }
    
45. }

复制代码

上面代码贴的有点乱，我再重新贴一个试试。


这种循环判断当前各个位数的方法比较低效，其实还有更高效的做法；就是根据结果与数之间的映射关系。

黄珊珊 发表于 2012-8-18 00:03
上面代码贴的有点乱，我再重新贴一个试试。

谢谢哈  知道自己哪里出错了:hug: