所以给了我一个小任务，我不得不用Python编写一个程序，打印一个0-999999的数字。
但我遇到了一些问题，我很乐意得到你的想法和帮助。
这是我到目前为止所写的：
numbers = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four', 5: 'Five', \
6: 'Six', 7: 'Seven', 8: 'Eight', 9: 'Nine', 10: 'Ten', \
11: 'Eleven', 12: 'Twelve', 13: 'Thirteen', 14: 'Fourteen', \
15: 'Fifteen', 16: 'Sixteen', 17: 'Seventeen', 18: 'Eighteen', \
19: 'Nineteen', 20: 'Twenty', 30: 'Thirty', 40: 'Forty', \
50: 'Fifty', 60: 'Sixty', 70: 'Seventy', 80: 'Eighty', \
90: 'Ninety', 0: 'Zero'}
def beta1(n):
if n == 0:
return numbers[0]
elif n >= 1 and n <= 19:
return numbers[n]
elif n >= 20 and n <= 99:
if n % 10 == 0:
return numbers[n]
else:
return numbers[n - n % 10] + " " + numbers[n % 10]
elif n>=100 and n<=999:
if n%10 == 0:
return numbers[n/100] + " Hundred"
else:
return numbers[n/100] + " Hundred" +" " +numbers[n%100 - n %10] + " " + numbers[n % 10]
elif n>=1000 and n<=999999:
if n>= 1000 and n <=9999:
if n%10 == 0:
return numbers[n/1000] + " Thousand"
else:
return numbers[n/1000] + " Thousand" + " " +numbers[(n%1000- n%100)/100] + " Hundred " + numbers[n%100- n%10] + " " + numbers[n%10]
问题在于我不会在这里处理这样的案件：
beta1(5050):
Five Thousand
beta1(550):
Five Hundred
beta1(515):
Five Hundred Ten Five
beta1(505):
Five Hundred Zero Five
我很想在这个主题上得到一些想法/帮助（没有包含库，我希望它纯粹编码。）
我是一个相当新的编码员，所以请放轻松我哈哈。 提前谢谢！
答案 0 :(得分：1)
您需要单独处理每个命名组（例如Twenty-Four Thousand Four Hundred Fifty-One）。递归将是你的朋友，所以你不会有if的长链
首先，如果提供的号码直接在您的号码字典中定义，您可以短路，不需要检查号码是否在某个范围内
if num in numbers:
return numbers[num]
此外，您应该使用特殊情况0并将其从数字词典中删除，以便我们最后不会将其除以
if num == 0:
return 'Zero'
我将定义您要处理的不同大量词
quantifiers = {
10 ** 2: 'Hundred',
10 ** 3: 'Thousand',
10 ** 6: 'Million',
}
然后将您的号码拆分为需要单独处理的部分。
num = 1234567
quantifier_amounts = []
r = num
for div in sorted(quantifiers.keys(), reverse=True):
n, r = divmod(r, div)
if n:
quantifier_amounts.append((n, quantifiers[div]))
if not r:
break
这应该给你
quantifier_amounts = [(1, 'Million'), (234, 'Thousand'), (5, 'Hundred')]
r = 67
然后，只需使用数字字典
以相同的方式处理剩余的r值
amounts = []
if r:
for div in sorted(numbers.keys(), reverse=True):
n, r = divmod(r, div)
if n:
amounts.append(numbers[div])
if not r:
break
这应该给你
amounts = ['Sixty', 'Seven']
然后递归处理每个量词部分并将文本添加到一起（该函数称为numtext）
text = []
for n, name in quantifier_amounts:
text.append('{} {}'.format(numtext(n), name))
if amounts:
text.append('-'.join(amounts))
return ' '.join(text)
你应该
一百二十三万三千五百六十七
答案 1 :(得分：0)
您可以通过先将字符串转换为字符串然后一次解析字符串一个字符来处理大数字。例如：
if n >= 1000:
place = {1:'', 2:'', 3:'hundred', 4:'thousand'}
return_val = ''
n = str(n)
while n != '':
c = n[0]
return_val += numbers[int(c)]
return_val += place[len(n)]
n = n[1:]
显然，这个答案并不完整，但我认为这是解决这个问题的最简单方法。此外，您可以对beta1函数进行递归调用，以避免严重嵌套的if-else语句。
希望有所帮助！
答案 2 :(得分：0)
你很亲密！我将从自上而下的方法开始（例如，从100000级别开始并向下工作）并使用递归调用。我还会使用代表%的{{1}}运算符（基本上为您提供余数mod）。
这是一个可以处理例如5050的想法：
5%2 = 1例如，如果我将numbers = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four', 5: 'Five', \
6: 'Six', 7: 'Seven', 8: 'Eight', 9: 'Nine', 10: 'Ten', \
11: 'Eleven', 12: 'Twelve', 13: 'Thirteen', 14: 'Fourteen', \
15: 'Fifteen', 16: 'Sixteen', 17: 'Seventeen', 18: 'Eighteen', \
19: 'Nineteen', 20: 'Twenty', 30: 'Thirty', 40: 'Forty', \
50: 'Fifty', 60: 'Sixty', 70: 'Seventy', 80: 'Eighty', \
90: 'Ninety', 0: 'Zero'}
mapping = {3:'Hundred', 4:'Thousand', ...}
def beta1(n):
numofdigits = len(n)
if not mapping[numofdigits]:
use your own code
else:
divider = (10 ** (numofdigits))
word = numbers[n/divider]
remainder = n%divider
return word + mapping[numofdigits] + beta1(remainder)
插入此功能。它将执行5050和5050的整数除法，即10^len(5050)，它会给你5。 5050/1000的余数为5050%1000。现在函数返回50，在这种情况下为word并与'Five'连接，mapping[4] +对函数进行递归调用以解析'Thousand'哪会返回50。因此，您的最终结果将是'Fifty'。
这是一个更优雅的解决方案，因为您不必非常难以编写代码。我会让你处理其他案件！祝你好运，如果你有任何疑问，请告诉我。
答案 3 :(得分：0)
我不会给你一个直接的答案，但提示。
首先，您需要以三位数组的形式解析数字，因为它与每组3的数字完全相同，唯一的区别是描述＆＃34; level＆＃34;的后缀，例如：
505和505,000基本相同： ＆＃34;五百五十＆＃34; 在第二，你只需要添加＆＃34;千＆＃34;
这意味着，你需要再增加一个表：
suffixes = ['', 'thousand', 'million', ...]
（第一级为空）
然后解析每个三元组很简单：
- 检查数百个// 100，从numbers获取此数字输入
- 余数 - 如果小于20 - 从numbers获取，否则，从numbers获取第一个数字（数字// 10 * 10）添加＆＃34;百（s）＆＃34 ;并从numbers获取提醒（编号％10）
- 别忘了添加＆＃34; s＆＃34;到后缀的末尾
答案 4 :(得分：0)
def beta1(n, returnZero=True):
if n == 0 and not returnZero: return [] # Prevent superfluous final "zero", e.g. 2900: "two thousand nine hundred zero"
if n in numbers: return [numbers[n]] # Direct mapping from n to text
if n >= 1000: return beta1(n // 1000) + ['Thousand'] + beta1(n%1000, False)
if n >= 100: return beta1(n // 100) + ['Hundred'] + beta1(n%100, False)
if n > 20: return [numbers[n//10*10]] + beta1(n%10, False)
# This function returns the elements as a list, so convert it to a string:
print( " ".join(beta1(12345)) )
当然，这可以很容易地扩展到处理大于999,999的数字：
if n >= 1000000000: return beta1(n // 1000000000) + ['Billion'] + beta1(n%1000000000, False)
if n >= 1000000: return beta1(n // 1000000) + ['Million'] + beta1(n%1000000, False)
并且，一些测试用例：
# Wrapper function that converts from a list to a string
# def beta1Text(n): return " ".join(beta1(n))
def beta1Text(n): return " ".join(beta1(n))
# Your test cases
print(beta1Text(5050)) # Five Thousand Fifty
print(beta1Text(550)) # Five Hundred Fifty
print(beta1Text(515)) # Five Hundred Fifteen
print(beta1Text(505)) # Five Hundred Five
# A few more test cases
print(beta1Text(290000)) # Two Hundred Ninety Thousand
print(beta1Text(123210)) # One Hundred Twenty Three Thousand Two Hundred Ten
print(beta1Text(990000)) # Nine Hundred Ninety Thousand
print(beta1Text(123456)) # One Hundred Twenty Three Thousand Four Hundred Fifty Six
for ii in range(20): print(beta1Text(ii)) # Zero, One, Two...Eighteen, Nineteen
# Test cases > 999,999
print(beta1Text(1000000)) # One Million
print(beta1Text(1000000000)) # One Billion
print(beta1Text(1234567898)) # One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety Eight
答案 5 :(得分：-2)
这可能看起来很乏味，但是将每个地方转换为单个数字然后添加单词的字符串。我在几分钟内完成了999。继续相同的模式，它应该是简单和非常基本的！
numbers = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four', 5: 'Five', \
6: 'Six', 7: 'Seven', 8: 'Eight', 9: 'Nine', 10: 'Ten', \
11: 'Eleven', 12: 'Twelve', 13: 'Thirteen', 14: 'Fourteen', \
15: 'Fifteen', 16: 'Sixteen', 17: 'Seventeen', 18: 'Eighteen', \
19: 'Nineteen', 20: 'Twenty', 30: 'Thirty', 40: 'Forty', \
50: 'Fifty', 60: 'Sixty', 70: 'Seventy', 80: 'Eighty', \
90: 'Ninety', 0: ''}
def beta1(n):
global numbers
if n == 0:
pass
elif n <= 20:
return numbers[n]
elif 10 < n < 100:
tens = int(str(n)[0]) * 10
ones = int(str(n)[1])
return numbers[tens] + " " + numbers[ones]
elif 100 < n < 1000:
hundreds = int(str(n)[0])
tens = int(str(n)[1]) * 10
ones = int(str(n)[2])
return numbers[hundreds] + " Hundred " + numbers[tens] + " "+ numbers[ones]
for n in range(1000):
print beta1(n)