将数字转换成汉语大写

时间看来

看到有讨论用shell script写这个，学习了哈。sed，gawk复制的用法还没有搞懂~
尝试了下用c写，请多多指教！欢迎您贴出您的代码，供我们菜鸟学习。

1. /*
   
2. *输入12，如何转换成壹拾贰，输入1020，转成壹千零贰拾
   
3. */
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <string.h>
   
7. 
   
8. void get4num(char *dest, char *src);
   
9. void output4num(char *src);
   
10. int output_unit(int left_bits);
    
11. 
    
12. char *my_array[10] = {"零","壹","贰","叁","肆",\
    
13.                           "伍","陆","柒","捌","玖"};
    
14. char *my_unit[5] = {"拾","佰","仟","万","亿"};
    
15. int FLAG_FIRST;
    
16. int
    
17. main(int argc, char *argv[])
    
18. {
    
19.         /*test my_array*/
    
20.         int i;
    
21.         for(i=0; i<10; i++){
    
22.                 printf("%s\n", *(my_array+i));
    
23.         }
    
24. 
    
25.         char input_num[100];
    
26.         printf("input_num:\n");
    
27.         scanf("%s", input_num);
    
28.         printf("%s\n", input_num);
    
29.        
    
30.         int input_len = strlen(input_num);
    
31.         char nums_4[6];
    
32. 
    
33.         /*output first nums*/
    
34.         FLAG_FIRST = 1;
    
35.         int first_num = input_len % 4;
    
36.         if(first_num != 0){
    
37.                 strncpy(nums_4, input_num, first_num);
    
38.                 output4num(nums_4);
    
39.                 output_unit(input_len);
    
40.         }
    
41. 
    
42.         /*output the left 4 nums*/
    
43.         FLAG_FIRST = 1;
    
44.         for(i=first_num; i<input_len; i+=4){
    
45.                 get4num(nums_4, input_num+i);
    
46.                 output4num(nums_4);
    
47.                 output_unit(input_len-i);
    
48.                 FLAG_FIRST = 0;
    
49.         }
    
50. 
    
51.         printf("\0");
    
52.         return 0;
    
53. }
    
54. 
    
55. /*
    
56. *get 4 numbers
    
57. */
    
58. void
    
59. get4num(char *dest, char *src)
    
60. {
    
61.         int i = 4;
    
62.         strncpy(dest, src, i);
    
63. }
    
64. 
    
65. /*
    
66. * output 4 numbers
    
67. */
    
68. void
    
69. output4num(char *src)
    
70. {
    
71.         int i, j;
    
72.         int num, nums[4];
    
73.         num = atoi(src);
    
74.         j = strlen(src);
    
75. 
    
76.         /*low number is at low place*/
    
77.         for(i=0; i<4; i++){
    
78.                 nums[i] = (num % 10);
    
79.                 num /= 10;
    
80.         }
    
81. 
    
82.         /*output first nums*/
    
83.         if(nums[j-1] == 0){
    
84.                 if((j == 4) && (FLAG_FIRST == 0)){
    
85.                         printf("%s", *(my_array+nums[j-1]));
    
86.                 }
    
87.         }else{
    
88.                 printf("%s", *(my_array+nums[j-1]));
    
89.                 printf("%s", *(my_unit+j-2));
    
90.         }
    
91. 
    
92.         /*output number and unit*/
    
93.         for(i=j-2; i>=1; i--){
    
94.                 if(nums[i] == 0){
    
95.                         if(nums[i+1] != 0){
    
96.                                 printf("%s", *(my_array+nums[i]));
    
97.                         }
    
98.                 }else{
    
99.                         printf("%s", *(my_array+nums[i]));
    
100.                         printf("%s", *(my_unit+i-1));
     
101.                 }
     
102.         }
     
103.         if(nums[0] != 0){
     
104.                 printf("%s", *(my_array+nums[i]));
     
105.         }
     
106. }
     
107. 
     
108. /*
     
109. * output the unit of 4 nums
     
110. */
     
111. int
     
112. output_unit(int left_bits)
     
113. {
     
114.         int m, n;
     
115.         m = (left_bits-1) / 4;
     
116.         switch(m){
     
117.                 case 0:
     
118.                         return 0;
     
119.                 case 1:
     
120.                         printf("%s", my_unit[3]);
     
121.                         return 0;
     
122.                 default:
     
123.                         for(n=m; n>=2; n--){
     
124.                                 printf("%s", my_unit[4]);
     
125.                         }
     
126.         }
     
127. 
     
128.         printf(",");
     
129. }
     
130. 
     
131. 
     

复制代码

input_num:
9283749817509843219827409812365908
9283749817509843219827409812365908
玖拾贰亿亿亿亿亿亿亿,捌仟叁佰柒拾肆亿亿亿亿亿亿,玖仟捌佰壹拾柒亿亿亿亿亿,伍仟零玖拾捌亿亿亿亿,肆仟叁佰贰拾壹亿亿亿,玖仟捌佰贰拾柒亿亿,肆仟零玖拾捌亿,壹仟贰佰叁拾陆万伍仟玖佰零捌

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2012.12.1
非常感谢楼下的回复，陪我写玩具程序。

发现我上面的程序每4位输出的单位上万亿后都是错的。把重写了int output_unit(int left_bits)，还有修改了穿过来的left_bits是4的整数倍。
根据人的读数习惯（以4个位数为一个单元），第一感觉也就这么写了。相信还有跟好的方法。
2楼的就是根据每位数来判断单位，不过我编译运行你的程序后，输出是乱码，这个我没有搞明白。我可是很想抓你小辫子哦！哇咔咔~对你再次表示感谢。

1. /*
   
2. *输入12，如何转换成壹拾贰，输入1020，转成壹千零贰拾
   
3. */
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <string.h>
   
7. 
   
8. void get4num(char *dest, char *src);
   
9. void output4num(char *src);
   
10. int output_unit(int left_bits);
    
11. 
    
12. char *my_array[10] = {"零","壹","贰","叁","肆",\
    
13.                           "伍","陆","柒","捌","玖"};
    
14. char *my_unit[5] = {"拾","佰","仟","万","亿"};
    
15. int FLAG_FIRST;
    
16. int
    
17. main(int argc, char *argv[])
    
18. {
    
19.         /*test my_array*/
    
20.         int i;
    
21.         for(i=0; i<10; i++){
    
22.                 printf("%s\n", *(my_array+i));
    
23.         }
    
24. 
    
25.         char input_num[100];
    
26.         printf("input_num:\n");
    
27.         scanf("%s", input_num);
    
28.         printf("%s\n", input_num);
    
29.        
    
30.         int input_len = strlen(input_num);
    
31.         char nums_4[6];
    
32. 
    
33.         /*output first nums*/
    
34.         FLAG_FIRST = 1;
    
35.         int first_num = input_len % 4;
    
36.         if(first_num != 0){
    
37.                 strncpy(nums_4, input_num, first_num);
    
38.                 output4num(nums_4);
    
39.                 output_unit(input_len - first_num);
    
40.         }
    
41. 
    
42.         /*output the left 4 nums*/
    
43.         FLAG_FIRST = 1;
    
44.         for(i=first_num; i<input_len; i+=4){
    
45.                 get4num(nums_4, input_num+i);
    
46.                 output4num(nums_4);
    
47.                 output_unit(input_len - i - 4);
    
48.                 FLAG_FIRST = 0;
    
49.         }
    
50. 
    
51.         printf("\0\0");
    
52.         return 0;
    
53. }
    
54. 
    
55. /*
    
56. *get 4 numbers
    
57. */
    
58. void
    
59. get4num(char *dest, char *src)
    
60. {
    
61.         int i = 4;
    
62.         strncpy(dest, src, i);
    
63. }
    
64. 
    
65. /*
    
66. * output 4 numbers
    
67. */
    
68. void
    
69. output4num(char *src)
    
70. {
    
71.         int i, j;
    
72.         int num, nums[4];
    
73.         num = atoi(src);
    
74.         j = strlen(src);
    
75. 
    
76.         /*low number is at low place*/
    
77.         for(i=0; i<4; i++){
    
78.                 nums[i] = (num % 10);
    
79.                 num /= 10;
    
80.         }
    
81. 
    
82.         /*output first nums*/
    
83.         if(nums[j-1] == 0){
    
84.                 if((j == 4) && (FLAG_FIRST == 0)){
    
85.                         printf("%s", *(my_array+nums[j-1]));
    
86.                 }
    
87.         }else{
    
88.                 printf("%s", *(my_array+nums[j-1]));
    
89.                 printf("%s", *(my_unit+j-2));
    
90.         }
    
91. 
    
92.         /*output number and unit*/
    
93.         for(i=j-2; i>=1; i--){
    
94.                 if(nums[i] == 0){
    
95.                         if(nums[i+1] != 0){
    
96.                                 printf("%s", *(my_array+nums[i]));
    
97.                         }
    
98.                 }else{
    
99.                         printf("%s", *(my_array+nums[i]));
    
100.                         printf("%s", *(my_unit+i-1));
     
101.                 }
     
102.         }
     
103.         if(nums[0] != 0){
     
104.                 printf("%s", *(my_array+nums[i]));
     
105.         }
     
106. }
     
107. 
     
108. /*
     
109. * output the unit of 4 nums
     
110. */
     
111. int
     
112. output_unit(int left_bits)
     
113. {
     
114.         int m, n;
     
115.         /*the last one*/
     
116.         if(left_bits < 4){
     
117.                 return 0;
     
118.         } else{
     
119.                 m = left_bits % 8;
     
120.                 switch(m){
     
121.                         case 4:
     
122.                                 printf("%s", my_unit[3]);
     
123.                                 break;
     
124.                         case 0:
     
125.                                 n = left_bits / 8;
     
126.                                 for(m=0; m<n; m++){
     
127.                                         printf("%s", my_unit[4]);
     
128.                                 }
     
129.                 }
     
130.         }
     
131. 
     
132.         printf(",");
     
133.         return 0;
     
134. }
     
135. 
     
136. 
     

复制代码

input_num:
123456789012345678901234567890
123456789012345678901234567890
壹拾贰万,叁仟肆佰伍拾陆亿亿亿,柒仟捌佰玖拾万,壹仟贰佰叁拾肆亿亿,伍仟陆佰柒拾捌万,玖仟零壹拾贰亿,叁仟肆佰伍拾陆万,柒仟捌佰玖拾

cokeboL

只有一个功能不用把那个write_unit()拆出来，写完懒得改了

1. #include <stdio.h>
   
2. #include <string.h>
   
3. 
   
4. int write_unit(int len, char *dst)
   
5. {
   
6.         char tmp[32] = {0};
   
7.         int i;
   
8.         switch(len % 4)
   
9.         {
   
10.                 case 0:
    
11.                         strncpy(tmp, "仟", 2);
    
12.                         break;
    
13.                 case 1:
    
14.                         if(len % 8 == 1){
    
15.                                 for(i = 0; i < len/8; i++)
    
16.                                         strncpy(tmp + i*2, "亿", 2);
    
17.                         }
    
18.                         else{
    
19.                                 strncpy(tmp, "万", 2);
    
20.                         }
    
21.                         break;
    
22.                 case 2:
    
23.                         strncpy(tmp, "拾", 2);
    
24.                         break;
    
25.                 case 3:
    
26.                         strncpy(tmp, "佰", 2);
    
27.                         break;
    
28.         }
    
29.         strcpy(dst, tmp);
    
30.         return strlen(tmp);
    
31. }
    
32.                                
    
33. char *str_convert(const char *src, char *dst)
    
34. {
    
35.         char *tmp = src;
    
36.         int i, write_len = 0;
    
37.         char number[] = "零壹贰叁肆伍陆柒捌玖";
    
38. 
    
39.         printf("src: %s\n", src);
    
40.         if(*tmp <= '0')
    
41.                 return NULL;
    
42.         while(*tmp){
    
43.                 if(*tmp < '0' || *tmp > '9')
    
44.                         return NULL;
    
45.                 tmp++;
    
46.         }
    
47. 
    
48.         tmp = dst;
    
49.         for(i = 0; i < strlen(src); i++){
    
50.                 strncpy(tmp + write_len, number + (src[i] - '0') * 2, 2);
    
51.                 write_len += 2;
    
52.                 write_len += write_unit(strlen(src + i), tmp + write_len);
    
53.         }
    
54.         if(('0' == src[i-1]) && (strlen(src) > 1))
    
55.                 dst[write_len - 2] = 0;
    
56. 
    
57.         printf("dst: %s\n", dst);
    
58.         return dst;
    
59. }
    
60. 
    
61. int main()
    
62. {
    
63.         char tmp[100] = {0};
    
64.         char tmp2[100] = {0};
    
65.         scanf("%s", tmp);
    
66.         str_convert(tmp, tmp2);
    
67. }
    

复制代码

时间看来

回复 2# cokeboL


非常感谢你的回复，陪我写玩具程序。

发现我上面第一个程序每4位输出的单位上万亿后都是错的。把重写了int output_unit(int left_bits)，还有修改了穿过来的left_bits是4的整数倍。
根据人的读数习惯（以4个位数为一个单元），第一感觉也就这么写了。相信还有跟好的方法。
2楼的就是根据每位数来判断单位，不过我编译运行你的程序后，输出是乱码，这个我没有搞明白。
我可是很想抓你小辫子哦！哇咔咔~对你再次表示感谢。

cokeboL

回复 3# 时间看来


不知道你用啥编译的。。。我的运行输入：1234567890，打印出来的是：

src: 1234567890
dst: 壹拾贰亿叁仟肆佰伍拾陆万柒仟捌佰玖拾

把单位的算法先明确了就能写明白了。我的如果有错你直接修改下就行了，我那拆出来的函数也没必要，就一转换函数，挪到里面就行了。

zighouse

这个有点实用价值，但也懒得写代码也懒得分析，提供一下想法：
1、先把数字逐个压入一个栈中，然后再逐个弹出来，并按新规则重新解释，得到一个字符串，然后反一下次序输出。
2、重新解释新规则时，使用状态机或者状态迁移表来帮助分析，然后再翻译成程序。
好的代码应该也会超过100行。

时间看来

回复 4# cokeboL


    嗯，我是gcc4.1.2编译的。在你提示处理好单位后，我又重新写了一个。
    差不多是一个一个数字读，不是先划分4个数为一组。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. char *my_array[10] = {"零","壹","贰","叁","肆",\
   
6.      "伍","陆","柒","捌","玖"};
   
7. char *my_unit[5] = {"拾","佰","仟","万","亿"};
   
8. 
   
9. void
   
10. output_unit(int position)
    
11. {
    
12.         if(position == 1){
    
13.                 return;
    
14.         }
    
15. 
    
16.         int left_bits = position -1;
    
17.         int i, many_yi;
    
18.         int case_unit;
    
19.         if(left_bits % 8 == 0){
    
20.                 many_yi = left_bits / 8;
    
21.                 for(i=0; i<many_yi; i++){
    
22.                         printf("%s", my_unit[4]);
    
23.                 }
    
24.                 printf(";");
    
25.         } else{
    
26.                 case_unit = left_bits % 4;
    
27.                 switch(case_unit){
    
28.                     case 0:
    
29.                                 printf("%s,", my_unit[3]);
    
30.                                 break;
    
31.                     case 1:
    
32.                         printf("%s", my_unit[0]);
    
33.                             break;
    
34.                     case 2:
    
35.                         printf("%s", my_unit[1]);
    
36.                         break;
    
37.                     case 3:
    
38.                         printf("%s", my_unit[2]);
    
39.                             break;
    
40.                 }
    
41.         }
    
42. }
    
43. 
    
44. int
    
45. str_convert(char *src)
    
46. {
    
47.         int i;
    
48.         /*check the input string*/
    
49.         int src_len = strlen(src);
    
50.         if(src_len < 1){
    
51.                 printf("dont't have enough digital");
    
52.         }
    
53. 
    
54.         /*keep the string is legal*/
    
55.         for(i=0; i<src_len; i++){
    
56.                 if(*(src+i) >= '0' && *(src+i) <= '9'){
    
57.                         continue;
    
58.                 } else{
    
59.                         printf("the number is illegal\n");
    
60.                         return 0;
    
61.                 }
    
62.         }
    
63. 
    
64.         /*output Chinese*/
    
65.         int first_bit = 0;
    
66.         for(i=0; i<src_len && *(src+i) == '0'; i++){
    
67.                 ;
    
68.         }
    
69.         first_bit = i;
    
70. 
    
71.         char *cur_bit;
    
72.         int cur_dig;
    
73.         for(i=first_bit; i<src_len; i++){
    
74.                 cur_bit = src + i;
    
75.                 cur_dig = *cur_bit - '0';
    
76.                 printf("%s",*(my_array + cur_dig));
    
77.                 output_unit(src_len - i);
    
78.         }
    
79. 
    
80.         printf("\n");
    
81.         return 0;
    
82. }
    
83. 
    
84. int main(int argc, char *argv[])
    
85. {
    
86.         char tmp[100];
    
87.         printf("input a number\n");
    
88.         scanf("%s", tmp);
    
89.         printf("src:%s\n", tmp);
    
90.         str_convert(tmp);
    
91. 
    
92.         fflush(stdout);
    
93.         return 0;
    
94. }
    

复制代码

input a number
src:00123 4567 | 8901 2345 | 6789 0123 | 4567 8901
壹佰贰拾叁万,肆仟伍佰陆拾柒亿亿亿;捌仟玖佰零拾壹万,贰仟叁佰肆拾伍亿亿;陆仟柒佰捌拾玖万,零仟壹佰贰拾叁亿;肆仟伍佰陆拾柒万,捌仟玖佰零拾壹

时间看来

回复 5# zighouse


    嗯，用递归，应该不错。
    我下面给的代码不超过100行啊。谢谢你的夸奖。哇咔咔~

zighouse

回复 7# 时间看来


    递归等同于栈的操作。

时间看来

回复 8# zighouse


    嗯，就是。
   

时间看来

回复 2# cokeboL


    比较奇怪，我输入0123的时候，并没有得到“零仟壹佰贰拾叁”，可能也与我开发环境的相关。