黑马程序员技术交流社区

标题: 一个问题(谢谢，已解决) [打印本页]
作者: 戎石锁    时间: 2012-8-17 22:07
标题: 一个问题(谢谢，已解决)
本帖最后由 戎石锁 于 2012-8-20 21:37 编辑

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个        
作者: 方志亮    时间: 2012-8-17 22:29
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:36
方志亮 发表于 2012-8-17 22:29
public static void main(String[] args) {
                int num=0;
        for(int y=1;y

不好意思 ，你的答案是错误的，
我的那个代码也是271
作者: 李知伦    时间: 2012-8-17 23:42
本帖最后由 李知伦 于 2012-8-17 23:49 编辑

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

你可以用排列组合算001~999
不为1的数,百位9种,十位9种,各位9种,再除去000
1000-9*9*9+1=272
作者: 黄珊珊    时间: 2012-8-17 23:52
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.        

  47. }
复制代码
打印结果为：1到1000包含1的个数为：301


作者: 黄珊珊    时间: 2012-8-18 00:03
本帖最后由 黄珊珊 于 2012-8-18 00:09 编辑
  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;

  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;

  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:56
黄珊珊 发表于 2012-8-18 00:03
上面代码贴的有点乱，我再重新贴一个试试。

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



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2