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

struct T{
    int bit[10];
};

void plus(T& a,const T& b,const int k){
    for(int i=0;i<10;i++)
        a.bit[i]+=b.bit[i]*k;
}

int main()
{
    int i,j,k,r,w,z,n,mask;
    T a[10];
    T ans;
    for(i=0;i<10;i++){
        k=n=i-2>0?i-2:0;
        for(j=0;j<n;j++)
            k=k*10+8;
        if(i>1)a[i].bit[0]=k*10+9;
        else a[i].bit[0]=0;
        for(j=1;j<=9;j++)
            a[i].bit[j]=i*pow(10,i-1);
    }
    while(cin>>n && n){
        for(i=0;i<10;i++)ans.bit[i]=0;
        mask=100000000;//10^9
        i=9;
        while(n/mask==0){
            mask/=10;
            i--;
        }
        z=0;
        while(n){
            i--;
            k=n/mask;
            n=n%mask;
            mask/=10;
            if(k==0){
                z++;
                continue;
            }
            if(z!=0){
                if(mask==0)ans.bit[0]+=z*k;
                else ans.bit[0]+=z*k*mask*10+n;
                z=0;
            }
            plus(ans,a[i],k);
            for(j=1;j<k;j++)
                if(mask)ans.bit[j]+=mask*10-1;
            ans.bit[k]+=n;
            for(j=1;j<=k;j++)
                ans.bit[j]++;
            ans.bit[0]+=i*k;
            
            r=0;
            w=9;
            for(j=i-2;j>0;j--){
                r+=w*j;
                w=w*10;
            }
            ans.bit[0]+=r*k;            
        }
        for(i=0;i<10;i++)
            cout<<ans.bit[i]<<endl;
        cout<<endl;
    }
    return 0;
}

#include <iostream>
#include <string>

int main()
{
    int num = 0;
    cout << "Please input a dec num:" ;
    cin >> num;

    int total = 0;
    for(int i = 1; i <= num; i++)
    {
        int value = i;
        
        while(value > 0)
        {
            int single = value % 10;
            if(single == 1)
                total ++;
            value /= 10;    
        }
    }

    cout << num << " include 1 total :" << total << endl;
    return 0;
}

char table16[16] = { 0,1,1,2, 1,2,2,3, 1,2,2,3, 2,3,3,4} ;
char table256[256];
unsigned int bitcount32_3(unsigned int x)
{
    return table16[x&0xf]+table16[(x>>4)&0xf]+table16[(x>>8)&0xf]+table16[(x>>12)&0xf] +
        table16[(x>>16)&0xf]+table16[(x>>20)&0xf]+table16[(x>>24)&0xf]+table16[(x>>28)&0xf];
}

unsigned int bitcount32_4(unsigned int x)
{
    return table256[x&0xff] + table256[(x>>8)&0xff]+
        table256[(x>>16)&0xff] + table256[(x>>24)&0xff];
}

void    SetData()
{
    for (int i = 0; i < 16; i++)
        for (int j = 0; j < 16; j++)
            table256[i*16+j] = table16[i] + table16[j];
}

unsigned int bitcount32_1(unsigned int x) 
{ 
    x = (x & 0x55555555UL) + ((x >> 1) & 0x55555555UL);  
    x = (x & 0x33333333UL) + ((x >> 2) & 0x33333333UL);  
    
    x = (x & 0x0f0f0f0fUL) + ((x >> 4) & 0x0f0f0f0fUL);  
    x = (x & 0x00ff00ffUL) + ((x >> 8) & 0x00ff00ffUL);  
    x = (x & 0x0000ffffUL) + ((x >> 16) & 0x0000ffffUL);  
    
    return x; 
}

unsigned int bitcount32_2(unsigned int x)
{
    x = x - ((x >> 1) & 0x55555555UL);  
    x = (x & 0x33333333UL) + ((x >> 2) & 0x33333333UL);  
    
    x = (x + (x >> 4)) & 0x0f0f0f0fUL;  
    x += x >> 8; 
    x += x >> 16;  
    
    return x & 0x3f; 
}

我写的代码:

#include    <iostream> 

using namespace std; 
const int MAX = 2008080808; 
const int IT = 7; 

template<int n, int curr, int last, int base, int weight> 
class A 
{ 
    enum{it = n/base%10}; 

public: 
    enum{result = A<n, (it-(it>IT))* weight+((it<IT)?curr:(it==IT?last:base+curr)), last+base*it, base*10, (weight?weight*9+base:1)> :: result}; 

}; 


template<int n, int curr, int base, int weight> 
class A<n, curr, n, base, weight> 
{ 
public: 
    enum {result = curr}; 

}; 

int main(int argc, char* argv[])  
{  
    cout << A<MAX+1, 0, 0, 1, 0>:: result << endl; 
    return 0;  
}  

//vitin的代码
#include <iostream> 
#include <cstdlib> 
using std::cout; 
using std::endl; 
using std::system; 

typedef unsigned __int64 num_type; 
typedef unsigned short digit_type; 

template <num_type base, size_t exp> 
class power 
{ 
public: 

    static const num_type value = base * power<base, exp-1>::value; 
}; 


template <num_type base> 
class power<base, 0> 
{ 
public: 
    static const num_type value = 1; 
}; 



template <num_type num, num_type base, bool bigger = (num >= base)> 
class log_round  
{ 
public: 
   static const size_t value = log_round<num/base, base>::value + 1; 

}; 


template <num_type num, num_type base> 
class log_round< num, base, false> 
{ 
public: 
    static const size_t value = 0; 
}; 

template <num_type num, digit_type digit> 
class count_of_num  
{ 
private: 
    static const num_type base = 10; 
    static const size_t exp = log_round<num, base>::value; 
    static const num_type m_digit = num / power<base, exp>::value; 
    static const num_type remain = num - m_digit * power<base, exp>::value; 
    static const num_type m_digit_count =  
        (m_digit > digit) ? (power<base, exp>::value - count_of_num<power<base, exp>::value-1, digit>::value) : 
        ((m_digit == digit) ? (remain+1-count_of_num<remain, digit>::value) : 0); 

public: 
    // 设 m_digit * (10^exp)  <= num < (m_digit+1)*(10^exp) 
    // 则总数目包含以下几项 
    // 1、m_digit * (1 到 (10^exp-1) 中的数目) 
    // 2、1 到 (num - m_digit * (10^exp)) 中的数目 
   // 3、最高位为 digit 的次数（去重） 
    // 4、... digit == 0 比较复杂，暂不考虑 
    static const num_type value