学英语

//每3位处理一次，并对3位进行翻译
import java.util.*;

public class Main{
    
    public static String[] bit_num = {"zero","one","two","three","four","five","six","seven","eight","nine"};
    
    public static String[] ten_num = {"ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"};
    
    public static String[] twenty_more = {"twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"};
    
    public static String parse(long num){
        if(num < 0) return "error";
        StringBuffer sb = new StringBuffer();
        long billion = num / 1000000000;
        if(billion != 0){
            sb.append(trans(billion) + " billion ");
        }
        
        num %= 1000000000;
        long million = num / 1000000;
        if(million != 0){
            sb.append(trans(million) + " million ");
        }
        
        num %= 1000000;        
        long thousand = num / 1000;
        if(thousand != 0){
            sb.append(trans(thousand) + " thousand ");
        }
        
        num %= 1000;        
        long hundred = num;
        if(hundred != 0){
            sb.append(trans(hundred));
        }
        return sb.toString().trim();
    }
    public static String trans(long num){
        StringBuffer sb = new StringBuffer();
        int h = (int)(num / 100);
        if(h != 0){
            sb.append(bit_num[h] + " hundred");
        }
        
        num %= 100;
        int t = (int)(num / 10);
        if(t != 0){
            if(h != 0){
                sb.append(" and ");
            }
            if(t == 1){
                sb.append(ten_num[(int)(num%10)]);
            }
            else{
                sb.append(twenty_more[(int)(t - 2)] + " ");
                if(num % 10 != 0){
                    sb.append(bit_num[(int)(num%10)]);
                }
            }
        }
        else if(num % 10 != 0){
            if(h != 0){
                sb.append(" and ");
            }
            sb.append(bit_num[(int)(num%10)]);
        }
        return sb.toString().trim();
    }
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            long num = in.nextLong();
            System.out.println(parse(num));
        }
        in.close();
    }
}

#没用字典，用的列表，有些边界值额外处理了以下
def spk(number):  #每3位数分开处理
    list1 = ["","one","two","three","four","five","six","seven","eight","nine","ten"]
    list2 = ["","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"]
    list3 = ["","","twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"]
    if number < 11:     #处理 1-10
        r = list1[number]
    elif 10 < number < 20:    #处理 11-19
        r = list2[number%10]
    elif 19 < number < 100:   #处理 20-99
        r = list3[number//10] + " " + list1[number%10]
    elif number == 100:      # 单独处理 100，用字典就没这么麻烦
        r = "one hundred"
    else:      #处理 101-999，方法和上面一样
        h = list1[number//100] + " hundred and"   
        if number%100 < 11:
            t = list1[number%100]
        elif 10 < number%100 < 20:
            t = list2[number%100%10] 
        elif 19 < number%100 < 100:
            t = list3[number%100//10] + " " + list1[number%100%10]
        r = h + " " + t     #把结果组合起来
    return r    #返回结果

while True:
    try:
        strs = input()
        if len(strs) < 4:    #只有3位的情况
            number = int(strs)
            res = spk(number)
            print(res)
        elif 3 < len(strs) < 7:    # 有4-6位的情况
            number = int(strs)//1000
            r1 = spk(number)
            number = int(strs)%1000
            r2 = spk(number)
            res = r1 + " thousand " + r2   #因为前面函数是每3位一组，现在组合结果
            res = res.replace("  "," ")    #因为用的前面列表，会有双空格的情况，额外处理
            print(res)
        elif 6 < len(strs) < 8:     #7位数的情况
            number = int(strs)//1000000
            r1 = spk(number)
            number = int(strs)%1000000//1000
            r2 = spk(number)
            number = int(strs)%1000000%1000
            r3 = spk(number)
            res = r1 + " million " + r2 + " thousand " + r3   #因为前面函数是每3位一组，现在组合结果         
            res = res.replace("  "," ")    #因为用的前面列表，会有双空格的情况，额外处理
            print(res)                
    except:
        break

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        // 预设字典
        String[] dic1 = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
        String[] dic2 = {"ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
        String[] dic3 = {"zero","ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
        String[] dic4 = {"", "thousand", "million", "billion"};
        while(in.hasNextLine()){
            // 输入的处理
            String num = in.nextLine();
            StringBuilder res = new StringBuilder();
            String zero = "";
            if((num.length() % 3) != 0){
                for(int i = 0; i < (3 - num.length() % 3); i++){
                    zero += "0";
                }
            }
            num = zero + num;
            // 每三个一位进行处理，最多处理到billion
            int n = num.length();
            int i = 0;
            List<String> list = new ArrayList<>();
            while(n >= 3){
                StringBuilder builder = new StringBuilder();
                String str = num.substring(n - 3, n);
                int a = str.charAt(0) - '0';
                int b = str.charAt(1) - '0';
                int c = str.charAt(2) - '0';
                boolean aIsZero = false;
                boolean bIsZero = false;
                boolean cIsZero = false;
                // 百位
                if(a != 0){
                    builder.append(dic1[a] + " hundred");
                }else{
                    aIsZero = true;
                }
                if(!aIsZero && (b != 0 || c != 0)){
                    builder.append(" and");
                }
                String kongge = aIsZero ? "" : " ";
                // 十位
                if(b != 0){
                    if(b == 1){
                        int temp = b * 10 + c - 10;
                        builder.append(kongge + dic2[temp]);
                    }else{
                        builder.append(kongge + dic3[b] + (c == 0 ? "" : (" " + dic1[c])));
                    }
                }else{
                    bIsZero = true;
                }
                // 个位
                if(c != 0){
                    if(bIsZero){
                        builder.append(kongge + dic1[c]);
                    }
                }else{
                    cIsZero = true;
                }
                // 最后的单位
                if(!aIsZero || !bIsZero || !cIsZero){
                    builder.append((i == 0 ? "" : " ") + dic4[i]);
                    list.add(builder.toString());
                }
                // 更新索引
                n -= 3;
                i++;
            }
            // 输出的处理
            for(int j = list.size() - 1; j >= 0; j--){
                if(j != 0){
                    res.append(list.get(j) + " ");
                }else{
                    res.append(list.get(j));
                }
            }
            System.out.println(res);
        }
    }
}

import java.util.Scanner;

public class Main {
    public static String[] ones = new String[]{"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
    public static String[] teens = new String[]{"ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
    public static String[] tys = new String[]{"zero", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
    public static String[] hundreds = new String[] {"hundred", "thousand", "million", "billion"};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            System.out.println(numToEn(sc.next()));
        }
    }

    // 数字转英文
    public static String numToEn(String num) {
        String temp;
        // 个位
        if (num.length() == 1) {
            return ones[num.charAt(0)-48];
        }
        // 十位
        if (num.length() == 2) {
            if (num.startsWith("0")) {
                return ones[num.charAt(1)-48];
            }
            if (num.startsWith("1")) {
                return teens[num.charAt(1)-48];
            } else {
                temp = tys[num.charAt(0)-48];
                if (num.endsWith("0")) {
                    return temp;
                } else {
                    return temp + " " + ones[num.charAt(1)-48];
                }
            }
        }
        // 百位（递归） 注意：hundred后用and来连接
        if (num.length() == 3) {
            if (num.startsWith("0")) {
                return numToEn(num.substring(1));
            }
            temp = numToEn(num.substring(0, 1)) + " " +  hundreds[0];
            if (num.endsWith("00")) {
                return temp;
            } else {
                return temp + " and " + numToEn(num.substring(1));
            }
        }
        // 千位（递归）
        if (num.length() < 7) {
            if (num.startsWith("0")) {
                return numToEn(num.substring(1));
            }
            temp = numToEn(num.substring(0, num.length()-3)) + " " + hundreds[1];
            if (num.endsWith("000")) {
                return temp;
            } else {
                return temp + " " + numToEn(num.substring(num.length()-3));
            }
        }
        // 百万位（递归）
        if (num.length() < 10) {
            if (num.startsWith("0")) {
                return numToEn(num.substring(1));
            }
            temp = numToEn(num.substring(0, num.length()-6)) + " " + hundreds[2];
            if (num.endsWith("000000")) {
                return temp;
            } else {
                return temp + " " + numToEn(num.substring(num.length()-6));
            }
        }
        // 十亿位（递归）
        temp = numToEn(num.substring(0, num.length()-10)) + " " + hundreds[3];
        if (num.endsWith("000000000")) {
            return temp;
        } else {
            return temp + " " + numToEn(num.substring(num.length()-10));
        }
    }
}

//3位一处理，这道题好tm烦人，写了几个小时！！！
import java.util.Scanner;

public class Main{
    private static String[] ge = {"one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
    private static String[] shi = {"twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
    private static String[] teen = {"ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen","nineteen"};
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            long num = sc.nextLong();
            String s = toEnglish(num);
            System.out.println(s);
        }
    }
    
    //转为英语，3位一起处理
    private static String toEnglish(long num){
        String str = String.valueOf(num);
        StringBuilder sb = new StringBuilder();
        int len = str.length();
        int m=len/3, n=len%3;
        int sep = 0;
        for(; sep<m; sep++){
            String s = str.substring(len-3-3*sep,len-3*sep);
            sb.insert(0,english1(s, sep));
        }
        if(n!=0) sb.insert(0, english2(str.substring(0, n), sep));
        return sb.toString();
    }
    
    //处理三位数
    private static String english1(String s, int i){
        StringBuilder sb = new StringBuilder();
        char c1 = s.charAt(0);
        char c2 = s.charAt(1);
        char c3 = s.charAt(2);
        if(c1=='0' && c2=='0' && c3=='0') return "";
        if(c1!='0') sb.append(ge[c1-'0'-1]).append(" hundred");
        if(c2!='0' || c3!='0'){
            if(c1!='0') sb.append(" and ");
            if(c2=='1') sb.append(teen[c3-'0']);
            else if(c2=='0') sb.append(ge[c3-'0'-1]);
            else{
                sb.append(shi[c2-'0'-2]);
                if(c3!='0'){
                    sb.append(" ").append(ge[c3-'0'-1]);
                }
            }
        }
        switch(i){
            case 0: break;
            case 1: sb.append(" ").append("thousand ");break;
            case 2: sb.append(" ").append("million ");break;
            case 3: sb.append(" ").append("billion ");break;
            default: ;
        }
        return sb.toString();
    }
    
    //处理剩余数字
    private static String english2(String s, int i){
        StringBuilder sb = new StringBuilder();
        int len = s.length();
        if(len==1) sb.append(ge[s.charAt(0)-'0'-1]);
        else{
            int c1 = s.charAt(0);
            int c2 = s.charAt(1);
            if(c1=='1') sb.append(teen[c2-'0']);
            else{
                if(c2=='0') sb.append(shi[c1-'0'-2]);
                else{
                    sb.append(shi[c1-'0'-2]).append(" ").append(ge[c2-'0'-1]);
                }
            }
        }
        switch(i){
            case 0: break;
            case 1: sb.append(" ").append("thousand ");break;
            case 2: sb.append(" ").append("million ");break;
            case 3: sb.append(" ").append("billion ");break;
            default: ;
        }
        return sb.toString();
    }
}

while True:
    try:
        to19 = 'one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen seventeen eighteen nineteen'.split()
        tens = 'twenty thirty forty fifty sixty seventy eighty ninety'.split()

        num = input()
        n = len(num)
        def hundred(num):
            #print(num)
            ans = ''
            ten = num % 100
            num = num // 100
            if 0<ten < 20:
                ans = to19[ten-1]
            elif ten > 20 and ten % 10 != 0:
                ans = tens[(ten-20)//10] +' ' +to19[(ten%10)-1]
            else:
                ans = tens[(ten-20)//10]
            if num % 10 != 0:
                ans = to19[(num % 10)-1]+' ' +'hundred '+'and ' + ans
            return ans
        index = 0
        ans = ''
        pos = ['','thousand','million']
        while n-index*3-3>0:
            tmp = hundred(int(num[n-index*3-3:n-index*3]))
            ans = tmp+' '+ pos[index]+' ' + ans
            index += 1
        #print(index)
        tmp = hundred(int(num[:n-index*3]))
        ans = tmp + ' '+ pos[index]+' ' + ans
        print(ans)
    except:
        break

// 测试用例通过90%，但感觉测试用例好像不太对，比如1538088
//答案输出：one million five hundred and thirty eight thousand eighty eight //程序输出：one million five hundred and thirty eight thousand and eighty eight(翻译软件也是这样的) #include <stdlib.h>
#include <stdio.h>
#include <string.h>

char* onePos[] = {"one", "two", "three", "four", "five", "six", \
                  "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen",\
                 "fifteen", "sixteen", "seventee", "eighteen", "nineteen"};
char* tenPos[] = {"twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
void handleThreePos(int val, int flag) {
    int ten = val % 100;
    int hun = val % 1000 / 100;
    if(flag) printf(" ");
    if(hun) {
        printf("%s hundred", onePos[hun - 1]);
    }
    if(ten && hun) printf(" and ");
    else if(ten && flag) printf("and ");
    if(ten > 19) {
        int tt = ten / 10;
        int tg = ten % 10;
        if(tg) {
            printf("%s %s", tenPos[tt - 2], onePos[tg - 1]);
        } else {
            printf("%s", tenPos[tt - 2]);
        }
    } else if(ten > 0) {
        printf("%s", onePos[ten - 1]);
    }
}
void do_thousand(int val) {
    if(val) {
        handleThreePos(val / 1000, 0);
        printf(" thousand");
        handleThreePos(val % 1000, 1);
    }
}
void do_millon(int val) {
    handleThreePos(val / 1000000, 0);
    printf(" million ");
    do_thousand(val % 1000000);
}
int main(void) {
    char num[10];
    while(scanf("%s", num) != EOF) {
        int val = atoi(num);
        int len = (int)strlen(num);
        if(len > 6) {
            do_millon(val);
        } else if(len > 3) {
            do_thousand(val);
        } else {
            handleThreePos(val, 0);
        }
        printf("\n");
    }
    return 0;
}

#0是非法数据，因此用空格做占位符
s0_19  = ' one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighth nineteenth'.split(' ')
s20_90  = 'twenty thirty forty fifty sixty seventy eighty ninety'.split(' ')

def num2words(n):
    if n <= 0:
        return('error')
    elif n < 20:
        return(str(s0_19[n]))
    elif n < 100 and n%10 == 0: #整十处理
        return(str(s20_90[n//10 - 2]))        
    elif n < 100:
        return(str(s20_90[n//10 - 2]+' '+num2words(n%10))) 
    elif n < 1000 and n%100 == 0: #整百处理
        return(str(num2words(n//100)+' hundred'))
    elif n < 1000:
        return(str(num2words(n//100)+' hundred and '+num2words(n%100))) #三位数必带and
    elif n < 1000000 and n%1000%100 == 0:
        return(str(num2words(n//1000)+' thousand'))
    elif n < 1000000:
        return(str(num2words(n//1000)+' thousand '+num2words(n%1000))) #这里有缺陷，中间有零要拼接“and”，但是此处没考虑（如2020，但还是通过了），下同
    elif n < 1000000000 and n%1000000%1000 == 0:
        return(str(num2words(n//1000000)+' million'))
    elif n < 1000000000:
        return(str(num2words(n//1000000)+' million '+num2words(n%1000000)))
    else:
        return('error') 


while True:
    try:
        print(num2words(int(input())).strip())
    except:break

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Scanner;
import java.util.logging.LoggingMXBean;

public class Main {

	public static HashMap<Long, String> ji = new LinkedHashMap<>();
	public static HashMap<Long, String> shiji = new LinkedHashMap<>();
	public static HashMap<Long, String> jishi = new LinkedHashMap<>();

	static {
		ji.put(0L, "zero");
		ji.put(1L, "one");
		ji.put(2L, "two");
		ji.put(3L, "three");
		ji.put(4L, "four");
		ji.put(5L, "five");
		ji.put(6L, "six");
		ji.put(7L, "seven");
		ji.put(8L, "eight");
		ji.put(9L, "nine");

		shiji.put(10L, "ten");
		shiji.put(11L, "eleven");
		shiji.put(12L, "twelve");
		shiji.put(13L, "thirteen");
		shiji.put(14L, "fourteen");
		shiji.put(15L, "fifteen");
		shiji.put(16L, "sixteen");
		shiji.put(17L, "seventeen");
		shiji.put(18L, "eighteen");
		shiji.put(19L, "nineteen");

		jishi.put(2L, "twenty");
		jishi.put(3L, "thirty");
		jishi.put(4L, "forty");
		jishi.put(5L, "fifty");
		jishi.put(6L, "sixty");
		jishi.put(7L, "seventy");
		jishi.put(8L, "eighty");
		jishi.put(9L, "ninety");
	}

	public static String hundred = "hundred";
	public static String thousand = "thousand";
	public static String million = "million";
	public static String billion = "billion";
	public static String and = "and";

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);

		while (scanner.hasNext()) {
			try {
				long purpose = scanner.nextLong();
				if (purpose < 0) {
					System.out.println("error");
					continue;
				}
				if (purpose == 0) {
					System.out.println("zero");
				}

				String spurpose = purpose + "";
				if (spurpose.length() > 9) {
					System.out.println("error");
					continue;
				}
				String lastpart = sanweishu(purpose % 1000);

				if (purpose / 1000 > 0) {
					String th = sanweishu((purpose / 1000) % 1000);
					if (th.length() > 0) {
						lastpart = th + " " + thousand + " " + lastpart;
					}
				}

				if (purpose / 1000000 > 0) {
					lastpart = sanweishu((purpose / 1000000)) + " " + million + " " + lastpart;
				}

				System.out.println(lastpart);

			} catch (Exception e) {
				System.out.println("error");
			}

		}

		scanner.close();
	}

	public static String sanweishu(long l) {
		if (l == 0) {
			return "";
		}
		StringBuilder sBuilder = new StringBuilder();
		long last1 = l % 10;
		long last2 = l % 100;
		long first = l / 100;
		long second = (l / 10) % 10;
		if (first != 0) {
			sBuilder.append(ji.get(first)).append(" ").append(hundred).append(" ");
		}
		if (last2 != 0) {
			if (sBuilder.length() > 0) {
				sBuilder.append(and).append(" ");
			}
			if (second == 0) {
				sBuilder.append(ji.get(last1));
			} else if (second == 1) {
				sBuilder.append(shiji.get(last2));
			} else {
				if (last1 == 0) {
					sBuilder.append(jishi.get(second));
				} else {
					sBuilder.append(jishi.get(second)).append(" ").append(ji.get(last1));
				}

			}
		}
		return sBuilder.toString().trim();
	}
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>


char index_units[10][16] = {
    "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"
};

char index_ten[10][16] = {
    "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"
};

char index_tens[10][16] = {
    "heihei", "heihei", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"
};


char *parse_2(int num)
{
    int n;
    char res[100];
    char *p;

    if(0<=num && num<10) {
        strcpy(res, index_units[num]);
        n = strlen(res);
    } else if(10<=num && num<20) {
        strcpy(res, index_ten[num-10]);
        n = strlen(res);
    } else if(20<=num && num<100) {
        strcpy(res, index_tens[num/10]);
        n = strlen(res);
        if((num%10) != 0) {
            res[n] = ' ';
            strcpy(res+n+1, index_units[num%10]);
            n = strlen(res);
        }
    } else {
        printf("parse_2: error input\n");
        while(1);
    }

    p = (char *)malloc(n+1);
    strcpy(p, res);
    return p;
}

char *parse_3(int num)
{
    int n;
    char res[100];
    char *p;

    if(0<=num && num<100) {
        p = parse_2(num);
        strcpy(res, p);
        free(p);
        n = strlen(res);
    } else if(100<=num && num<1000) {
        strcpy(res, index_units[num/100]);
        n = strlen(res);
        res[n] = ' ';
        strcpy(res+n+1, "hundred");
        n = strlen(res);
        if(num%100 != 0) {
            res[n] = ' ';
            strcpy(res+n+1, "and ");
            n += 5;
            p = parse_2(num%100);
            strcpy(res+n, p);
            free(p);
            n = strlen(res);
        }
    } else {
        printf("parse_3: error input\n");
        while(1);
    }

    p = (char *)malloc(n+1);
    strcpy(p, res);
    return p;
}

char *parse(int num)
{
    int nn;
    int tmp;
    char *p;

    int n;
    char res[100];

    nn = 0;
    tmp = num;
    while(tmp) {
        nn++;
        tmp /= 10;
    }
    if(nn == 0) {
        strcpy(res, "zero");
        n = strlen(res);
    } else if(1<=nn && nn<=3) {
        p = parse_3(num);
        strcpy(res, p);
        free(p);
        n = strlen(res);
    } else if(4<=nn && nn<=6) {
        p = parse_3(num/1000);
        strcpy(res, p);
        free(p);
        n = strlen(res);
        res[n] = ' ';
        strcpy(res+n+1, "thousand");
        n = strlen(res);
        if(num%1000) {
            res[n] = ' ';
            p = parse_3(num%1000);
            strcpy(res+n+1, p);
            free(p);
            n = strlen(res);
        }
    } else if(7<=nn && nn<=9) {
        p = parse_3(num/1000000);
        strcpy(res, p);
        free(p);
        n = strlen(res);
        res[n] = ' ';
        strcpy(res+n+1, "million");
        n = strlen(res);
        if((num%1000000)/1000) {
            res[n] = ' ';
            p = parse_3((num%1000000)/1000);
            strcpy(res+n+1, p);
            free(p);
            n = strlen(res);
            res[n] = ' ';
            strcpy(res+n+1, "thousand");
            n = strlen(res);
        }
        if((num%1000000)%1000) {
            res[n] = ' ';
            p = parse_3((num%1000000)%1000);
            strcpy(res+n+1, p);
            free(p);
            n = strlen(res);
        }
    }
    p = (char *)malloc(n+1);
    strcpy(p, res);
    return p;
}


int main()
{
    int n;
    int res;
    char *p;

    while(1) {
        res = scanf("%d", &n);
        if(res == EOF)
            break;

        p = parse(n);
        printf("%s\n", p);
        free(p);
    }
}

# include <stdio.h>
# include <stdlib.h>
# include <string.h>
char s1[10][10] = { {'\0' }, "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
char s2[10][10] = { "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };
char s3[8][10] = { "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };
char s4[3][10] = { {'\0'}, "thousand", "million" };
int main()
{
	long int n;
	while (scanf("%ld", &n) != EOF)
	{
        if(n==0)
        {
            printf("zero\n");
            continue;
        }
        else if(n<0||n>999999999)
        {
            printf("error\n");
            continue;
        }
		char str[150] = { '\0' };
		int a[9];
		for (int i = 0; i < 9; i++)
        {
            a[i] = 0;
        }
		int i = 0;
		while (n > 0)
		{
			a[i++] = n % 10;
			n = n / 10;
		}
		for (i = 2; i >= 0; i-- )
		{
			if (a[3 * i + 2] > 0)
			{
				strcat(str, s1[a[3 * i+2]]);
				strcat(str, " hundred ");
				if (a[3 * i + 1] + a[3 * i] > 0)
					strcat(str, "and ");
			}
			if (a[3 * i + 1] == 0)
			{
				if (a[3 * i] > 0)
					strcat(str, s1[a[3 * i]]);
			}
			else if (a[3 * i + 1] == 1)
			{
				strcat(str, s2[a[3 * i]]);
			}
			else
			{
				strcat(str, s3[a[3 * i+1]-2]);
				if (a[3 * i] > 0)
				{
					strcat(str, " ");
					strcat(str, s1[a[3 * i]]);
				}
			}
            if (a[3 * i + 1] + a[3 * i] > 0 && i>0)
            {
                strcat(str, " ");
            }
			if (a[3 * i + 2] + a[3 * i + 1] + a[3 * i] > 0)
			{
				strcat(str, s4[i]);
				if (i>0)
					strcat(str, " ");
			}		
		}
		puts(str);
	}
	return 0;
}

import java.util.*;
/**
 * @author zhangxf0406
 * 学英语
 * million thousand分开处理
 */
public class Main {
	public static boolean validate(String str){
		//不能超过9位
		if(str.length() > 9)
			return false;
		//不能有小数
		String [] s1 = str.split("\\.");
		if(s1.length != 1)
			return false;
		//每一位都是数字
		char[] cc = str.toCharArray();
		for(int i = 0 ; i < cc.length ; i++){
			if(!Character.isDigit(cc[i]))
				return false;
		}
		return true;
	}
	public static boolean parse(String str){
		String[] table1 = {"zero", "one", "two", "three", "four", 
				 "five", "six", "seven", "eight", "nine"};
		String[] table2 = {"ten","eleven","twelve","thirteen","fourteen","fifteen",
				 "sixteen","seventeen","eighteen","nighteen"};
		String[] table3 = {"twenty","thirty","forty","fifty",
				 "sixty","seventy","eighty","ninety"};
		int a1 = Integer.parseInt(str)/100; 	//1
		int a2 = Integer.parseInt(str)/10%10;	//2
		int a3 = Integer.parseInt(str)%10; 		//3
		if(a1 == 0 && a2 == 0 && a3 == 0)
			return false;
		
//		System.out.println("a1:"+a1+"..a2:"+a2+"..a3:"+a3);
		if(a1 != 0 ){
			System.out.print(table1[a1]+" hundred");
			if(a2 == 0){
				if(a3 != 0)
					System.out.print(" and " + table1[a3]);
			}
			else if(a2 == 1){
//				if(a3 != 0)
					System.out.print(" and "+table2[a3]);
			}
			else{
				if(a3 != 0)
					System.out.print(" and "+table3[a2-2]+" "+table1[a3]);
				else
					System.out.print(" and "+table3[a2-2]+" ");
			}
		}
		if(a1 == 0){
			if(a2 == 0){
					System.out.print(table1[a3]);
			}
			else if(a2 == 1){
//				if(a3 != 0)
					System.out.print(table2[a3]);
			}
			else{
				if(a3 != 0)
					System.out.print(" and "+table3[a2-2]+" "+table1[a3]);
				else
					System.out.print(" and "+table3[a2-2]+" ");
			}
		}
		return true;
	}
	
	
	
	public static void main(String[] args) {
		
		Scanner scanner = new Scanner(System.in);
		while(scanner.hasNext()){
			String num = scanner.next();
			if(!validate(num)){
				System.out.println("error");
				continue;
			}
			//补齐9位
			int len = num.length();
			while(len != 9){
				num = "0" + num;
				len++;
			}
//			System.out.println(num);
			String str1 = num.substring(0,len - 6); 	// million
			boolean flag1 = parse(str1);
			if(flag1)
				System.out.print(" million ");
	
			String str2 = num.substring(len - 6 , len - 6 + 3);
//			System.out.println();
			boolean flag2 = parse(str2);
			if(flag2)
				System.out.print(" thousand ");
			String str3 = num.substring(len - 6 + 3 , num.length());
			parse(str3);
			System.out.println("");
		}
		scanner.close();
	}

} 不通过 

Python的解法。使用递归来解，通过所有的测试了：

def numberToWords(num):
    to19='one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen seventeen eighteen nineteen'.split()
    tens="twenty thirty forty fifty sixty seventy eighty ninety".split()
    def words(n):
        if n<20:return to19[n-1:n]
        if n<100:return [tens[n//10-2]]+words(n%10)
        if n<1000:
            return [to19[n//100-1]]+["hundred"]+["and"]+words(n%100)
        for p,w in enumerate(('thousand',"million","billion"),1):
            if n<1000**(p+1):
                return words(n//1000**p)+[w]+words(n%1000**p)
    return " ".join(words(num)) or "Zero"
while True:
    try:
        print(numberToWords(int(input())))
    except:break