把數字數值轉換成單詞形式

本文轉載自查看原文 2014-11-25 22:35 337 C/C++

《C和指針》第7章第6道編程題：

編寫函數

void written_amount( unsigned int amount, char *buffer );

它把 amount 表示的值轉換為單詞形式，並存儲於 buffer 中。這個函數可以在一個打印支票的程序中使用。例如，如果 amount 的值是 16 312，那么 buffer 中存儲的字符串應該是

　　SIXTEEN THOUSAND THREE HUNDRED TWELVE

調用程序保證 buffer 緩沖區的空間足夠大。例如，1 200 可以是 ONE THOUSAND TWO HUNDRED 或 TWELVE HUNDRED。你可以選擇一種你喜歡的形式。

  1 /*
  2 ** 把非負整數數值轉化為單詞形式
  3 */
  4 
  5 #include <stdio.h>
  6 #include <string.h>
  7 
  8 void written_amount( unsigned int amount, char *buffer );
  9 
 10 int 
 11 main()
 12 {
 13     unsigned int num;
 14     scanf( "%u", &num );
 15     char b[100] = { 0 };
 16     
 17     written_amount( num, b );
 18     
 19     puts( b );
 20     
 21     return 0;
 22 }
 23 
 24 /*
 25 ** 函數功能：把amount的值轉化為單詞形式，結果存儲在buffer中
 26 */
 27 void 
 28 written_amount( unsigned int amount, char *buffer )
 29 {
 30     /*
 31     ** 數字對應的單詞，分為4組
 32     */
 33     char word_1_9[10][6] = { "ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE",
 34                             "SIX", "SEVEN", "EIGHT", "NINE" };
 35     char word_10_19[10][10] = {"TEN", "ELEVEN", "TWELVE", "THIRTEEN", "FOURTEEN", "FIFTEEN",
 36                             "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN" };
 37     char word_ty[10][8] = { "", "", "TWENTY", "THIRTY", "FORTY", "FIFTY", 
 38                             "SIXTY", "SEVENTY", "EIGHTY", "NINETY" };
 39     char word_div[4][9] = { "HUNDRED", "THOUSAND", "MILLION", "BILLION" };
 40     
 41     static int count = 0;  // 記錄千分位的個數
 42     unsigned int tmp = amount / 1000; 
 43     
 44     /*
 45     ** 用遞歸函數，直到數值< 1000
 46     */
 47     if( tmp )
 48     {
 49         count ++;  // 千分位的個數增加
 50         written_amount( tmp, buffer ); // 遞歸，處理下一個千分位
 51     }
 52     
 53     int val = amount % 1000; // 3位3位地進行轉化單詞
 54     
 55     /*
 56     ** 值大於100，先把百位上的數的單詞存到buffer中
 57     ** 后面加上 HUNDRED
 58     ** 把值%100，變成兩位數，后續繼續處理
 59     */
 60     if( val >= 100 )
 61     {
 62         strcat( buffer, word_1_9[ val / 100 ] );
 63         strcat( buffer, " " );
 64         strcat( buffer, word_div[ 0 ] );
 65         val %= 100;
 66     }
 67     
 68     /*
 69     ** 值在20至99之間，先把幾十對應的單詞加到buffer中
 70     ** 再%10，后續處理個位上的數
 71     */
 72     if( val >= 20 && val <= 99 )
 73     {
 74         strcat( buffer, " " );
 75         strcat( buffer, word_ty[ val / 10 ] );
 76         val %= 10;
 77     }
 78     
 79     /*
 80     ** 值在10到19之間，直接把對應的單詞加到buffer中
 81     */
 82     if( val >= 10 && val <= 19 )
 83     {
 84         strcat( buffer, " " );
 85         strcat( buffer, word_10_19[ val % 10 ] );
 86     }
 87     
 88     /*
 89     ** 值在0到9之間，把對應的單詞加到buffer中
 90     */
 91     if( val >= 0 && val <= 9 )
 92     {
 93         strcat( buffer, " " );
 94         strcat( buffer, word_1_9[ val ] );
 95     }
 96     
 97     /*
 98     ** 一個千位處理完后，后面加上對應的分位單詞"THOUSAND"、"MILLION"等
 99     */
100     if( count > 0 )
101     {
102         strcat( buffer, " " );
103         strcat( buffer, word_div[ count-- ] );
104         strcat( buffer, " " );
105     }
106 }

以上版本處理個位是0的數字會多顯示ZERO，下面這個版本進行改進：

  1 /*
  2 ** 把非負整數數值轉化為單詞形式
  3 ** 2.0版本，改進：
  4 **       個位為 0 的數字多輸出 ZERO 的問題
  5 */
  6 
  7 #include <stdio.h>
  8 #include <string.h>
  9 
 10 void written_amount( unsigned int amount, char *buffer );
 11 
 12 int 
 13 main()
 14 {
 15     unsigned int num1, num2;
 16     scanf( "%u%u", &num1, &num2 );
 17     char b1[100] = { 0 };
 18     char b2[100] = { 0 };
 19     
 20     written_amount( num1, b1 );
 21     
 22     puts( b1 );
 23     
 24     written_amount( num2, b2 );
 25     
 26     puts( b2 );
 27     
 28     return 0;
 29 }
 30 
 31 /*
 32 ** 函數功能：把amount的值轉化為單詞形式，結果存儲在buffer中
 33 */
 34 void 
 35 written_amount( unsigned int amount, char *buffer )
 36 {
 37     /*
 38     ** 數字對應的單詞，分為4組
 39     */
 40     char word_1_9[10][6] = { "ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE",
 41                             "SIX", "SEVEN", "EIGHT", "NINE" };
 42     char word_10_19[10][10] = {"TEN", "ELEVEN", "TWELVE", "THIRTEEN", "FOURTEEN", "FIFTEEN",
 43                             "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN" };
 44     char word_ty[10][8] = { "", "", "TWENTY", "THIRTY", "FORTY", "FIFTY", 
 45                             "SIXTY", "SEVENTY", "EIGHTY", "NINETY" };
 46     char word_div[4][9] = { "HUNDRED", "THOUSAND", "MILLION", "BILLION" };
 47     
 48     /*
 49     ** 如果amount=0,則直接輸出ZERO
 50     */
 51     if( amount == 0 )
 52         strcat( buffer, word_1_9[ 0 ] );
 53     
 54     /*
 55     ** amount不等於0，用下面的方法處理
 56     */
 57     static int count = 0;  // 記錄千分位的個數
 58     unsigned int tmp = amount / 1000; 
 59     
 60     /*
 61     ** 用遞歸函數，直到數值< 1000
 62     */
 63     if( tmp )
 64     {
 65         count ++;  // 千分位的個數增加
 66         written_amount( tmp, buffer ); // 遞歸，處理下一個千分位
 67     }
 68     
 69     int val = amount % 1000; // 3位3位地進行轉化單詞
 70     
 71     /*
 72     ** 值大於100，先把百位上的數的單詞存到buffer中
 73     ** 后面加上 HUNDRED
 74     ** 把值%100，變成兩位數，后續繼續處理
 75     */
 76     if( val >= 100 )
 77     {
 78         strcat( buffer, word_1_9[ val / 100 ] );
 79         strcat( buffer, " " );
 80         strcat( buffer, word_div[ 0 ] );
 81         val %= 100;
 82     }
 83     
 84     /*
 85     ** 值在20至99之間，先把幾十對應的單詞加到buffer中
 86     ** 再%10，后續處理個位上的數
 87     */
 88     if( val >= 20 && val <= 99 )
 89     {
 90         strcat( buffer, " " );
 91         strcat( buffer, word_ty[ val / 10 ] );
 92         val %= 10;
 93     }
 94     
 95     /*
 96     ** 值在10到19之間，直接把對應的單詞加到buffer中
 97     */
 98     if( val >= 10 && val <= 19 )
 99     {
100         strcat( buffer, " " );
101         strcat( buffer, word_10_19[ val % 10 ] );
102     }
103     
104     /*
105     ** 值在0到9之間，把對應的單詞加到buffer中
106     */
107     if( val > 0 && val <= 9 )
108     {
109         strcat( buffer, " " );
110         strcat( buffer, word_1_9[ val ] );
111     }
112     
113     /*
114     ** 一個千位處理完后，后面加上對應的分位單詞"THOUSAND"、"MILLION"等
115     */
116     if( count > 0 )
117     {
118         strcat( buffer, " " );
119         strcat( buffer, word_div[ count-- ] );
120         strcat( buffer, " " );
121     }
122 }

以上2.0版本，1000000 、1000000000 等數字多輸出分位單詞，以下3.0版本對此進行修正：

  1 /*
  2 ** 把非負整數數值轉化為單詞形式
  3 ** 3.0版本，在2.0的基礎上改進：
  4 **       1000000 多輸出 THOUSAND 的問題
  5 */
  6 
  7 #include <stdio.h>
  8 #include <string.h>
  9 
 10 void written_amount( unsigned int amount, char *buffer );
 11 
 12 int 
 13 main()
 14 {
 15     unsigned int num1, num2;
 16     scanf( "%u%u", &num1, &num2 );
 17     char b1[100] = { 0 };
 18     char b2[100] = { 0 };
 19     
 20     written_amount( num1, b1 );
 21     
 22     puts( b1 );
 23     
 24     written_amount( num2, b2 );
 25     
 26     puts( b2 );
 27     
 28     return 0;
 29 }
 30 
 31 /*
 32 ** 函數功能：把amount的值轉化為單詞形式，結果存儲在buffer中
 33 */
 34 void 
 35 written_amount( unsigned int amount, char *buffer )
 36 {
 37     /*
 38     ** 數字對應的單詞，分為4組
 39     */
 40     char word_1_9[10][6] = { "ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE",
 41                             "SIX", "SEVEN", "EIGHT", "NINE" };
 42     char word_10_19[10][10] = {"TEN", "ELEVEN", "TWELVE", "THIRTEEN", "FOURTEEN", "FIFTEEN",
 43                             "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN" };
 44     char word_ty[10][8] = { "", "", "TWENTY", "THIRTY", "FORTY", "FIFTY", 
 45                             "SIXTY", "SEVENTY", "EIGHTY", "NINETY" };
 46     char word_div[4][9] = { "HUNDRED", "THOUSAND", "MILLION", "BILLION" };
 47     
 48     /*
 49     ** 如果amount=0,則直接輸出ZERO
 50     */
 51     if( amount == 0 )
 52     {
 53         strcat( buffer, word_1_9[ 0 ] );
 54         return ;
 55     }
 56     
 57     /*
 58     ** amount不等於0，用下面的方法處理
 59     */
 60     static int count = 0;  // 記錄千分位的個數
 61     unsigned int tmp = amount / 1000; 
 62     
 63     /*
 64     ** 用遞歸函數，直到數值< 1000
 65     */
 66     if( tmp )
 67     {
 68         count ++;  // 千分位的個數增加
 69         written_amount( tmp, buffer ); // 遞歸，處理下一個千分位
 70     }
 71     
 72     int val = amount % 1000; // 3位3位地進行轉化單詞
 73     
 74     if( val == 0 )
 75     {
 76         count = 0;
 77         return ;
 78     }
 79     /*
 80     ** 值大於100，先把百位上的數的單詞存到buffer中
 81     ** 后面加上 HUNDRED
 82     ** 把值%100，變成兩位數，后續繼續處理
 83     */
 84     if( val >= 100 )
 85     {
 86         strcat( buffer, word_1_9[ val / 100 ] );
 87         strcat( buffer, " " );
 88         strcat( buffer, word_div[ 0 ] );
 89         val %= 100;
 90     }
 91     
 92     /*
 93     ** 值在20至99之間，先把幾十對應的單詞加到buffer中
 94     ** 再%10，后續處理個位上的數
 95     */
 96     if( val >= 20 && val <= 99 )
 97     {
 98         strcat( buffer, " " );
 99         strcat( buffer, word_ty[ val / 10 ] );
100         val %= 10;
101     }
102     
103     /*
104     ** 值在10到19之間，直接把對應的單詞加到buffer中
105     */
106     if( val >= 10 && val <= 19 )
107     {
108         strcat( buffer, " " );
109         strcat( buffer, word_10_19[ val % 10 ] );
110     }
111     
112     /*
113     ** 值在0到9之間，把對應的單詞加到buffer中
114     */
115     if( val > 0 && val <= 9 )
116     {
117         strcat( buffer, " " );
118         strcat( buffer, word_1_9[ val ] );
119     }
120     
121     /*
122     ** 一個千位處理完后，后面加上對應的分位單詞"THOUSAND"、"MILLION"等
123     */
124     if( count > 0 )
125     {
126         strcat( buffer, " " );
127         strcat( buffer, word_div[ count-- ] );
128         strcat( buffer, " " );
129     }
130 }

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 C# 數字轉換成漢字大寫數值轉換成漢字大寫 js將數字轉換成中文 js轉換成數字將字符轉換成數字 List