将阿拉伯数字（长长整型）转换为中文单词在C中

13 浏览
0 Comments

将阿拉伯数字（长长整型）转换为中文单词在C中

我想将一个数字转换成英文单词，例如1024或2345787654，使得对于1024，它应该输出one thousand twenty four等等。

然而，我的代码给了我一个分段错误。我尝试使用gdb运行它，但它提示问题在于my_strcat函数内部。然而，我没有看到这个函数有任何问题。请帮忙解决。

#include 
#include 
const char *digits[] = { NULL, "one ", "two ", "three ", "four ", "five ", "six ", "seven ", "eight ", "nine " };
const char *tens[] = { NULL, "ten ", "twenty ", "thirty ", "forty ", "fifty ", "sixty ", "seventy ", "eighty ", "ninety " };
const char *teens[] = { "ten ", "eleven ", "twelve ", "thirteen ", "fourteen ", "fifteen ", "sixteen ", "seventeen ", "eighteen ", "nineteen " };
const char *scales[] = { "", "thousand ", "million ", "billion " };
char *my_strcat(char **dest, const char *src)
{
    char *tab = malloc(sizeof(char) * (strlen(*dest) + strlen(src) + 1));
    if (NULL == tab)
        return NULL;
    strcpy(tab, *dest);
    strcat(tab, src);
    free(*dest);
    *dest = malloc(sizeof(char) * (strlen(tab) + 1));
    strcpy(*dest, tab);
    return tab;
}
char *LongToEnglish(unsigned long x)
{
    switch (x)
    {
    case 0:
        return "Zero";
    case 1:
        return "One";
    case 2:
        return "Two";
    case 3:
        return "Three";
    case 4:
        return "Four";
    case 5:
        return "Five";
    case 6:
        return "Six";
    case 7:
        return "Seven";
    case 8:
        return "Eight";
    case 9:
        return "Nine";
    case 10:
        return "Ten";
    case 11:
        return "Eleven";
    case 12:
        return "Twelve";
    case 13:
        return "Thirteen";
    case 14:
        return "Fourteen";
    case 15:
        return "Fifteen";
    case 16:
        return "Sixteen";
    case 17:
        return "Seventeen";
    case 18:
        return "Eighteen";
    case 19:
        return "Nineteen";
    case 20:
        return "Twenty";
    case 30:
        return "Thirty";
    case 40:
        return "Forty";
    case 50:
        return "Fifty";
    case 60:
        return "Sixty";
    case 70:
        return "Seventy";
    case 80:
        return "Eighty";
    case 90:
        return "Ninety";
    case 100:
        return "One Hundred";
    case 1000:
        return "One Thousand";
    case 1000000:
        return "One Million";
    case 1000000000:
        return "One Billion";
    }
    // less than 100
    for (long i = 1; i <= 9; i++)
    {
        long j = i * 10;
        if ((x >= j) && (x < j + 10))
        {
            long r = x - j;
            if (r > 0)
                return my_strcat(&my_strcat(LongToEnglish(j), " "), LongToEnglish(r));
            else
                return my_strcat(&my_strcat(LongToEnglish(j), ""), "");
        }
    }
    // less than 1000
    for (long i = 1; i <= 9; i++)
    {
        long j = i * 100;
        if ((x >= j) && (x < j + 100))
        {
            long r = x - j;
            if (r > 0)
                return my_strcat(&my_strcat(LongToEnglish(i), " Hundred "), LongToEnglish(r));
            else
                return my_strcat(&my_strcat(LongToEnglish(i), " Hundred"), "");
        }
    }
    // less than 10000
    for (long i = 1; i <= 9; i++)
    {
        long j = i * 1000;
        if ((x >= j) && (x < j + 1000))
        {
            long r = x - j;
            if (r > 0)
                return my_strcat(&my_strcat(LongToEnglish(i), " Thousand "), LongToEnglish(r));
            else
                return my_strcat(&my_strcat(LongToEnglish(i), " Thousand"), "");
        }
    }
    // Million
    for (long i = 1; i <= 9; i++)
    {
        long j = i * 1000000;
        if ((x >= j) && (x < j + 1000000))
        {
            long r = x - j;
            if (r > 0)
                return my_strcat(&my_strcat(LongToEnglish(i), " Million "), LongToEnglish(r));
            else
                return my_strcat(&my_strcat(LongToEnglish(i), " Million"), "");
        }
    }
    // Billion
    for (long i = 1; i <= 4; i++)
    {
        long j = i * 1000000000;
        if ((x >= j) && (x < j + 1000000000))
        {
            long r = x - j;
            if (r > 0)
                return my_strcat(&my_strcat(LongToEnglish(i), " Billion "), LongToEnglish(r));
            else
                return my_strcat(&my_strcat(LongToEnglish(i), " Billion"), "");
        }
    }
    // Divide the number into 3-digit groups from left to right
    char *output = "";
    long cnt = 0;
    while (x > 0)
    {
        long y = x % 1000;
        x /= 1000;
        if (y > 0)   // skip middle-chunk zero
        {
            char *t = "";
            if (cnt == 1) t = " Thousand ";
            if (cnt == 2) t = " Million ";
            if (cnt == 3) t = " Billion ";
            output = my_strcat(&my_strcat(LongToEnglish(y), t), output);
        }
        cnt++;
    }
    return output;
}
char *numberToWords(int num)
{
    return LongToEnglish(num);
}
int main(int argc, char **argv)
{
    char *dst = NULL;
    dst = malloc(sizeof(char) * 10000000);
    unsigned long long n = 122334;
    dst = numberToWords(n);
    printf("%s", dst);
    free(dst);
    return 0;
}

0

2 答案

0 Comments

问题的原因是需要将一个长整型的阿拉伯数字转化为对应的英文单词表示。而解决方法是使用递归的方式，将数字从右往左每三位一组进行处理，然后将处理结果拼接起来。

具体的解决方法如下：

1. 首先，定义了三个字符串数组digits、tens和scales，分别用来存储数字和单位的英文单词。

2. 然后，定义了一个函数long2words，接收两个参数，一个是要转化的数字x，另一个是当前的组号grp（从0开始）。

3. 在函数内部，首先分配了一个足够大的缓冲区buf来存储转化结果，然后定义了三个变量e、t和h，分别表示个位、十位和百位的数字。

4. 接下来，通过对x进行取余和除法操作，分别得到e、t和h的值，并将x更新为去除最右边三位的结果。

5. 如果x不为0，则递归调用long2words函数，并将结果拼接到buf的末尾，然后释放之前分配的内存。

6. 如果h不为0，则将对应的英文单词拼接到buf的末尾。

7. 如果t小于2，则将对应的英文单词拼接到buf的末尾。

8. 如果t大于等于2，则将十位的英文单词和个位的英文单词分别拼接到buf的末尾。

9. 最后，将当前组的单位拼接到buf的末尾，并返回buf。

10. 在main函数中，调用long2words函数并将结果打印出来。

通过以上的解决方法，可以将一个长整型的阿拉伯数字转化为对应的英文单词表示。

0
0 Comments

问题原因：

代码中出现了一个问题，当输入n=3时，numberToWords函数返回了一个静态字符串"Three"，然后尝试调用free函数释放这个静态字符串。

解决方法：

应该避免在特定情况下释放静态字符串。可以通过判断字符串是否为静态字符串，来决定是否调用free函数进行释放。

以下是修正后的代码示例：

#include

#include

#include

const char* numberToWords(long long int n){

char* words;

if(n == 3){

words = strdup("Three");

}else{

// 其他情况的处理

}

return words;

}

int main(){

long long int n = 3;

const char* result = numberToWords(n);

if(result != "Three"){

free((char*)result);

}

return 0;

}

0