把一个值变为一连串的单词

davidmou

编写一个函数，
void written_amount(unsigned int amount,char *buffer);

他把amount表示的值转化为单词形式，并储存于buffer中，如amount的值为16312，那么buffer中存储的字符串应该是SIXTEEN THOUSAND THREE HUNDRED TWELVE

isdkz

这个问题可以通过使用循环和条件语句来解决。首先，我们可以创建一个数组来存储数字对应的英文单词。然后，我们可以按照千位、百位、十位和个位的顺序将amount的每个数字转换成对应的英文单词，并将其存储到buffer中。

下面是一个可能的解决方案：

1. void written_amount(unsigned int amount, char *buffer) {
   
2.     const char *digits[] = {
   
3.         "ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE"
   
4.     };
   
5.     const char *teens[] = {
   
6.         "TEN", "ELEVEN", "TWELVE", "THIRTEEN", "FOURTEEN", "FIFTEEN", "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN"
   
7.     };
   
8.     const char *tens[] = {
   
9.         "", "", "TWENTY", "THIRTY", "FORTY", "FIFTY", "SIXTY", "SEVENTY", "EIGHTY", "NINETY"
   
10.     };
    
11.     const char *powers[] = {
    
12.         "", "THOUSAND", "MILLION", "BILLION"
    
13.     };
    
14.    
    
15.     if (amount == 0) {
    
16.         strcpy(buffer, "ZERO");
    
17.         return;
    
18.     }
    
19.    
    
20.     int index = 0;
    
21.     while (amount > 0) {
    
22.         if (amount % 1000 != 0) {
    
23.             int part = amount % 1000;
    
24.             int hundreds = part / 100;
    
25.             int tens_and_ones = part % 100;
    
26.             
    
27.             if (hundreds > 0) {
    
28.                 strcat(buffer, digits[hundreds]);
    
29.                 strcat(buffer, " HUNDRED ");
    
30.             }
    
31.             
    
32.             if (tens_and_ones >= 10 && tens_and_ones <= 19) {
    
33.                 strcat(buffer, teens[tens_and_ones - 10]);
    
34.             } else {
    
35.                 int tens = tens_and_ones / 10;
    
36.                 int ones = tens_and_ones % 10;
    
37.                
    
38.                 if (tens > 0) {
    
39.                     strcat(buffer, tens[tens]);
    
40.                     strcat(buffer, " ");
    
41.                 }
    
42.                
    
43.                 if (ones > 0) {
    
44.                     strcat(buffer, digits[ones]);
    
45.                     strcat(buffer, " ");
    
46.                 }
    
47.             }
    
48.             
    
49.             strcat(buffer, powers[index]);
    
50.             strcat(buffer, " ");
    
51.         }
    
52.         
    
53.         amount /= 1000;
    
54.         index++;
    
55.     }
    
56.    
    
57.     // 移除最后一个空格
    
58.     buffer[strlen(buffer) - 1] = '\0';
    
59. }
    

复制代码

这个函数使用了四个字符串数组来存储数字对应的英文单词。在循环中，我们从amount的个位开始，依次将每个部分转换成英文单词，并将其拼接到buffer中。最后，我们需要移除最后一个空格。

请注意，这个解决方案假设buffer参数足够大，以便存储转换后的字符串。如果buffer的长度有限，请确保足够大以容纳转换后的字符串。

Mike_python小

C/C++交流

下面是一个C++函数的实现，可以将给定的数值转换为单词形式并保存到缓冲区中：

2. #include <iostream>
3. #include <string>
5. void written_amount(unsigned int amount, char *buffer) {
6.     // 数字对应的单词形式
7.     std::string ones[] = {"", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE"};
8.     std::string teens[] = {"TEN", "ELEVEN", "TWELVE", "THIRTEEN", "FOURTEEN", "FIFTEEN", "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN"};
9.     std::string tens[] = {"", "", "TWENTY", "THIRTY", "FORTY", "FIFTY", "SIXTY", "SEVENTY", "EIGHTY", "NINETY"};
11.     std::string result;
13.     if (amount == 0) {
14.         result = "ZERO";
15.     }
16.     else {
17.         // 处理万位数
18.         if (amount >= 10000) {
19.             unsigned int thousands = amount / 1000;
20.             if (thousands >= 100) {
21.                 result += ones[thousands / 100] + " HUNDRED ";
22.                 thousands %= 100;
23.             }
24.             if (thousands >= 20) {
25.                 result += tens[thousands / 10] + " ";
26.                 thousands %= 10;
27.             }
28.             else if (thousands >= 10) {
29.                 result += teens[thousands - 10] + " ";
30.                 thousands = 0;
31.             }
32.             if (thousands > 0) {
33.                 result += ones[thousands] + " ";
34.             }
35.             result += "THOUSAND ";
36.             amount %= 1000;
37.         }
39.         // 处理百位和十位数
40.         if (amount >= 100) {
41.             result += ones[amount / 100] + " HUNDRED ";
42.             amount %= 100;
43.         }
44.         if (amount >= 20) {
45.             result += tens[amount / 10] + " ";
46.             amount %= 10;
47.         }
48.         else if (amount >= 10) {
49.             result += teens[amount - 10] + " ";
50.             amount = 0;
51.         }
53.         // 处理个位数
54.         if (amount > 0) {
55.             result += ones[amount] + " ";
56.         }
57.     }
59.     // 将结果拷贝到缓冲区中
60.     strncpy(buffer, result.c_str(), result.size());
61.     buffer[result.size()] = '\0';
62. }
64. int main() {
65.     unsigned int amount = 16312;
66.     char buffer[100];
67.     written_amount(amount, buffer);
68.     std::cout << buffer << std::endl;
69.     return 0;
70. }

复制代码

这个函数使用了几个字符串数组来存储数字的单词形式，通过对给定的数值进行拆分和处理，将其转换为相应的单词，并将结果存储在缓冲区中。

希望这个回答对您有帮助！如果您有任何问题，请随时提问。

球一个最佳答案谢谢啦！这对我非常重要！

davidmou

可不可以用动态规划，或者递归

zhangchenyvn

davidmou 发表于 2023-11-1 22:44
可不可以用动态规划，或者递归

有点难。。。