被一个判断给难住了，大哥哥们帮帮我，头快炸了

xgywd

/*这是一个求多少个1的问题，前几天看到的，我看了以后想解出来，但在循环判断的时候出了问题，三个判断中第二个和第三个，总是只能一个有用，而另一个出错，如果删掉一个，另一个就好使。如果这两个判断一起好用，这个题就解开了。请帮帮我，这个解题思路是，先求出最高位能包含多少个1，然后去掉最高位再求最高位，一直到结束*/



#include <iostream>
#include  <ctime>
using namespace std;



int  quan(long);                 //这个函数的做用是求一个数的位数
int bit(long);                      //这个函数的做用是求一个数的最高位是什么
long  sumhigh(long);    //这个函数的做用是把一个数的最高位去掉
long pow(int x,int y);      //这个函数的做用是救一个数的正数次方



int main()
{
       
        long a,b,c;
        int x,y,z;
       
        cout <<"请输入一个整数，我们将判断它包含的数中有多少个1：\n";
        cin >>a;
       
        b=0;
       
        for (long i=quan(a);i>0;--i)
                {
                y=bit(a);
                if (y>1)
                        {
                        c=y*(i-1)*pow(10,i-2)+pow(10,i-1);
                        b=b+c;
                        }
               
                else if (y==1)
                        {
                        c=y*(i-1)*pow(10,i-2)+sumhigh(a);
                        b=b+c;
                       
                        }
                else (y==1&&!sumhigh(a))
                        {
                        c=y*(i-1)*pow(10,i-2)+1;
                        b=b+c;
                        }
               
                a=sumhigh(a);
                }
       
        cout <<"包含1的个数有："<<b<<"个\n";
       
}


int quan(long x)
{
        bool a=true;
        int b=0;
        do
        {
        if (x<1)
                {
                a=false;
                }
                else
                {
                x=x/10;
                b++;
                }
        }while(a);
return b;
}

int bit(long x)
{
        int a,b=1;
        do
        {
        if (x>=10)
                {       
                x=x/10;
                }
        else b=0;
        }while (b);
return x;
}

long sumhigh(long x)
{
        long a;
        a= x-bit(x)*pow(10,quan(x)-1);
return a;
}

long pow(int x,int y)
{
        long a=1;
        if (y>0)
                {
                for (int i=0;i<y;++i)
                        {
                        a=a*x;
                        }
                }
        else if (y==0) a=1;
       
       
return a;
}

哦，我想求的是从1数到n,一共有多少个1，例如1－12，1，10，11，12，一共遇到了5个1，是这样数的

jeff_yecn

递归：

2. int countOne(unsigned int value) {
3.   int count = 0;
4.   int low;
5.   if ( value < 10 ) {
6.     if ( value == 1 ) {
7.       return 1;
8.     } else {
9.       return 0;
10.     }
11.   }
12.   low = value % 10;
13.   if ( low == 1 ) {
14.     count = 1;
15.   }
16.   return count+countOne(value/10);
17. }

复制代码

大概是这个意思。

xgywd

今天看了一本书，上面说，如果你想编程，就要先把自己想做的先写在纸上，然后按流程去做。
我才突然发现，为什么我解决不了这个问题，原来，我一直在用脑子想，脑子再聪明也记不住所有环节。特别是编程。里面要注意的太多了。所以我就写了一份流程。在写的时候，就把问题给解决了，然后把源码打上，呵呵，原来一切如此简单。



#include <iostream>
using namespace std;



int  quan(long);            //求一个数的位数，也称这个数的最高权
int bit(long);                  //求一个数最高的位上面的数；
long  sumhigh(long);        //砍掉一个数的最高位；
long pow(int x,int y);      //算一个数的正整数幂



int main()
{
     
    long a,b,c,high,d;     //a,是放输入数的，b是放结果的，c是放过程结果的，high是最高位
    int y;                        //d是放a的值，y是放最高位的
   
    cout <<"请输入一个整数，我们将判断它包含的数中有多少个1：\n";
    cin >>a;
   
    d=a;
    b=0;
    high=0;
    for (long i=quan(a);i>0;--i)
        {
        
        
        if  (quan(a)<i)    y = 0 ;
        
        else y= bit(a);
        
        
        if (y==1)
            {
            c=high*pow(10,i-1)+sumhigh(a)+1;
            b=b+c;
            }
        
        else if (y>1)
            {
            c=high*pow(10,i-1)+pow(10,i-1);
            b=b+c;
            }
        else if (y==0&&i!=1)
            {
            c=high*pow(10,i-1);
            b=b+c;
            }
        else if(y==0&&i==1)
            {
            c=high;
            b=b+c;
            }
        
        high=d/pow(10,i-1);
        if (y!=0) a=sumhigh(a);
        
        }
   
    cout <<"包含1的个数有："<<b<<"个\n";
   
   
  
}


int quan(long x)
{
    bool a=true;
    int b=0;
    do
    {
    if (x<1)
        {
        a=false;
        }
        else
        {
        x=x/10;
        b++;
        }
    }while(a);
return b;
}

int bit(long x)
{
    int a,b=1;
    do
    {
    if (x>=10)
        {   
        x=x/10;
        }
    else b=0;
    }while (b);
return x;
}

long sumhigh(long x)
{
    long a;
    a= x-bit(x)*pow(10,quan(x)-1);
return a;
}

long pow(int x,int y)
{
    long a=1;
    if (y>0)
        {
        for (int i=0;i<y;++i)
            {
            a=a*x;
            }
        }
    else if (y==0) a=1;
   
   
return a;
}

xgywd

Post by jeff_yecn;1851659
递归：

1. 
   
2. int countOne(unsigned int value) {
   
3.   int count = 0;
   
4.   int low;
   
5.   if ( value < 10 ) {
   
6.     if ( value == 1 ) {
   
7.       return 1;
   
8.     } else {
   
9.       return 0;
   
10.     }
    
11.   }
    
12.   low = value % 10;
    
13.   if ( low == 1 ) {
    
14.     count = 1;
    
15.   }
    
16.   return count+countOne(value/10);
    
17. }
    

复制代码

大概是这个意思。

谢谢你让我看到了递归，以前只是在文章里看到过，还真没见过源码
看到了你的解法，让我想到了这个问题的新的解法，呵呵，我研究研究去。谢谢你，不过你的这个递归好像只能解决数字表面上有没有1。
我需要解决的是从1数到n,只要遇到1，就把这个1数下来，比如，1－11
有1，10，11，加起来4个1。

jeff_yecn

Post by xgywd;1852612
谢谢你让我看到了递归，以前只是在文章里看到过，还真没见过源码
看到了你的解法，让我想到了这个问题的新的解法，呵呵，我研究研究去。谢谢你，不过你的这个递归好像只能解决数字表面上有没有1。
我需要解决的是从1数到n,只要遇到1，就把这个1数下来，比如，1－11
有1，10，11，加起来4个1。

那就再加一层函数：

1. 
   
2. int countAllOnes(int n) {
   
3.   int total = 0;
   
4.   for(int i=1; i<=n; i++) {
   
5.     total += countOne(i);
   
6.   }
   
7.   return total;
   
8. }
   

复制代码

xgywd

好恐怖的大循环，呵呵，如果要算一个大数，这个可能要慢一些了，可是这个程序的可读性是相当的高