蓝桥杯试题 基础练习 数的读法

最新推荐文章于 2023-01-15 21:26:36 发布
最新推荐文章于 2023-01-15 21:26:36 发布
阅读量137 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： python 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42023999/article/details/123689555
版权

蓝桥杯试题 基础练习 数的读法

Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法：十二亿三千四百五十六万七千零九
用汉语拼音表示为
shi er yi san qian si bai wu shi liu wan qi qian ling jiu
这样他只需要照着念就可以了。
你的任务是帮他设计这样一个系统：给定一个阿拉伯数字串，你帮他按照中文读写的规范转为汉语拼音字串，相邻的两个音节用一个空格符格开。
注意必须严格按照规范，比如说“10010”读作“yi wan ling yi shi”而不是“yi wan ling shi”，“100000”读作“shi wan”而不是“yi shi wan”，“2000”读作“er qian”而不是“liang qian”。

输入：有一个数字串，数值大小不超过2,000,000,000。
输出：是一个由小写英文字母，逗号和空格组成的字符串，表示该数的英文读法。 
样例输入：1234567009
样例输出：shi er yi san qian si bai wu shi liu wan qi qian ling jiu
首先判断输入的串的位数，根据位数分为三类，第一类是大于8位，第二类是大于4位并且小于9位，第三类是小于5位，读的时候分为三个级别，个级、万级、亿级，分别写三个函数。这里说一下第一个难点是每个级别的两位数的读法，分为四种情况，这里以个级别为例，
if ge[0]==1:     #高位为1的情况，读的时候应该读shi
	if ge[1]==0: #低位的0不读
		return(n_2[0])
    else:        #其他情况
        return(n_2[0]+' '+n_1[ge[1]])
else:            #其他情况
    if ge[1]==0: #低位的0不读
        return(n_1[ge[0]]+' '+n_2[0])
    else:        #其他情况
        return(n_1[ge[0]]+' '+n_2[0]+' '+n_1[ge[1]])

#试题 基础练习 数的读法
n_1=['ling','yi','er','san','si','wu','liu','qi','ba','jiu']
n_2=['shi','bai','qian','wan','yi']
def reader_ge(ge):
    ge=list(map(int,ge))
    if len(ge) == 4:
        if ge[0]==0:
            if ge[1]==0 and ge[2]==0 and ge[3]==0:
                return('')
            elif ge[1]==0 and ge[2]==0 and ge[3]!=0:
                return(n_1[ge[1]]+' '+n_1[ge[3]])
            elif ge[1]==0 and ge[2]!=0 and ge[3]==0:
                return(n_1[ge[1]]+' '+n_1[ge[2]]+' '+n_2[0])
            elif ge[1]==0 and ge[2]!=0 and ge[3]!=0:
                return(n_1[ge[1]]+' '+n_1[ge[2]]+' '+n_2[0]+' '+n_1[ge[3]])
            elif ge[1]!=0 and ge[2]==0 and ge[3]==0:
                return(n_1[ge[0]]+' '+n_1[ge[1]]+' '+n_2[1])
            elif ge[1]!=0 and ge[2]==0 and ge[3]!=0:
                return(n_1[ge[0]]+' '+n_1[ge[1]]+' '+n_2[1]+' '+n_1[ge[2]]+' '+n_1[ge[3]])
            elif ge[1]!=0 and ge[2]!=0 and ge[3]==0:
                return(n_1[ge[0]]+' '+n_1[ge[1]]+' '+n_2[1]+' '+n_1[ge[2]]+' '+n_2[0])
            else:
                return(n_1[ge[0]]+' '+n_1[ge[1]]+' '+n_2[1]+' '+n_1[ge[2]]+' '+n_2[0]+' '+n_1[ge[3]])
        else:
            if ge[1]==0 and ge[2]==0 and ge[3]==0:
                return(n_1[ge[0]]+' '+n_2[2])
            elif ge[1]==0 and ge[2]==0 and ge[3]!=0:
                return(n_1[ge[0]]+' '+n_2[2]+' '+n_1[ge[1]]+' '+n_1[ge[3]])
            elif ge[1]==0 and ge[2]!=0 and ge[3]==0:
                return(n_1[ge[0]]+' '+n_2[2]+' '+n_1[ge[1]]+' '+n_1[ge[2]]+' '+n_2[0])
            elif ge[1]==0 and ge[2]!=0 and ge[3]!=0:
                return(n_1[ge[0]]+' '+n_2[2]+' '+n_1[ge[1]]+' '+n_1[ge[2]]+' '+n_2[0]+' '+n_1[ge[3]])
            elif ge[1]!=0 and ge[2]==0 and ge[3]==0:
                return(n_1[ge[0]]+' '+n_2[2]+' '+n_1[ge[1]]+' '+n_2[1])
            elif ge[1]!=0 and ge[2]==0 and ge[3]!=0:
                return(n_1[ge[0]]+' '+n_2[2]+' '+n_1[ge[1]]+' '+n_2[1]+' '+n_1[ge[2]]+' '+n_1[ge[3]])
            elif ge[1]!=0 and ge[2]!=0 and ge[3]==0:
                return(n_1[ge[0]]+' '+n_2[2]+' '+n_1[ge[1]]+' '+n_2[1]+' '+n_1[ge[2]]+' '+n_2[0])
            else:
                return(n_1[ge[0]]+' '+n_2[2]+' '+n_1[ge[1]]+' '+n_2[1]+' '+n_1[ge[2]]+' '+n_2[0]+' '+n_1[ge[3]])
    
    elif len(ge) == 3:
        if ge[1] == 0 and ge[2] == 0:
            return(n_1[ge[0]]+' '+n_2[1])
        elif ge[1] == 0 and ge[2] !=0:
            return(n_1[ge[0]]+' '+n_2[1]+' '+n_1[ge[1]]+' '+n_1[ge[2]])
        elif ge[1]!=0 and ge[2]==0:
            return(n_1[ge[0]]+' '+n_2[1]+' '+n_1[ge[1]]+' '+n_2[0])
        else:
            return(n_1[ge[0]]+' '+n_2[1]+' '+n_1[ge[1]]+' '+n_2[0]+' '+n_1[ge[2]])
    elif len(ge) == 2:
        if ge[0]==1:
            if ge[1]==0:
                return(n_2[0])
            else:
                return(n_2[0]+' '+n_1[ge[1]])
        else:
            if ge[1]==0:
                return(n_1[ge[0]]+' '+n_2[0])
            else:
                return(n_1[ge[0]]+' '+n_2[0]+' '+n_1[ge[1]])
    else:
        return(n_1[ge[0]])
def reader_wan(wan,ge):
    wan=list(map(int,wan))
    ge=list(map(int,ge))
    if len(wan) == 4:
        if wan[0]==0:
            if wan[1]==0 and wan[2]==0 and wan[3]==0:
                if ge[0]!=0:
                    return('ling')
                else:
                    return('')
            elif wan[1]==0 and wan[2]==0 and wan[3]!=0:
                return(n_1[wan[0]]+' '+n_1[wan[3]]+' '+n_2[3])
            elif wan[1]==0 and wan[2]!=0 and wan[3]==0:
                return(n_1[wan[0]]+' '+n_1[wan[2]]+' '+n_2[0]+' '+n_2[3])
            elif wan[1]==0 and wan[2]!=0 and wan[3]!=0:
                return(n_1[wan[0]]+' '+n_1[wan[2]]+' '+n_2[0]+' '+n_1[wan[3]]+' '+n_2[3])
            elif wan[1]!=0 and wan[2]==0 and wan[3]==0:
                return(n_1[wan[0]]+' '+n_1[wan[1]]+' '+n_2[1]+' '+n_2[3])
            elif wan[1]!=0 and wan[2]==0 and wan[3]!=0:
                return(n_1[wan[0]]+' '+n_1[wan[1]]+' '+n_2[1]+' '+n_1[wan[2]]+' '+n_1[wan[3]]+' '+n_2[3])
            elif wan[1]!=0 and wan[2]!=0 and wan[3]==0:
                return(n_1[wan[0]]+' '+n_1[wan[1]]+' '+n_2[1]+' '+n_1[wan[2]]+' '+n_2[0]+' '+n_2[3])
            else:
                return(n_1[wan[0]]+' '+n_1[wan[1]]+' '+n_2[1]+' '+n_1[wan[2]]+' '+n_2[0]+' '+n_1[wan[3]]+' '+n_2[3])
        else:
            if wan[1]==0 and wan[2]==0 and wan[3]==0:
                return(n_1[wan[0]]+' '+n_2[2]+' '+n_2[3])
            elif wan[1]==0 and wan[2]==0 and wan[3]!=0:
                return(n_1[wan[0]]+' '+n_2[2]+' '+n_1[wan[1]]+' '+n_1[wan[3]]+' '+n_2[3])
            elif wan[1]==0 and wan[2]!=0 and wan[3]==0:
                return(n_1[wan[0]]+' '+n_2[2]+' '+n_1[wan[1]]+' '+n_1[wan[2]]+' '+n_2[0]+' '+n_2[3])
            elif wan[1]==0 and wan[2]!=0 and wan[3]!=0:
                return(n_1[wan[0]]+' '+n_2[2]+' '+n_1[wan[1]]+' '+n_1[wan[2]]+' '+n_2[0]+' '+n_1[wan[3]]+' '+n_2[3])
            elif wan[1]!=0 and wan[2]==0 and wan[3]==0:
                return(n_1[wan[0]]+' '+n_2[2]+' '+n_1[wan[1]]+' '+n_2[1]+' '+n_2[3])
            elif wan[1]!=0 and wan[2]==0 and wan[3]!=0:
                return(n_1[wan[0]]+' '+n_2[2]+' '+n_1[wan[1]]+' '+n_2[1]+' '+n_1[wan[2]]+' '+n_1[wan[3]]+' '+n_2[3])
            elif wan[1]!=0 and wan[2]!=0 and wan[3]==0:
                return(n_1[wan[0]]+' '+n_2[2]+' '+n_1[wan[1]]+' '+n_2[1]+' '+n_1[wan[2]]+' '+n_2[0]+' '+n_2[3])
            else:
                return(n_1[wan[0]]+' '+n_2[2]+' '+n_1[wan[1]]+' '+n_2[1]+' '+n_1[wan[2]]+' '+n_2[0]+' '+n_1[wan[3]]+' '+n_2[3])
    
    elif len(wan) == 3:
        if wan[1] == 0 and wan[2] == 0:
            return(n_1[wan[0]]+' '+n_2[1]+' '+n_2[3])
        elif wan[1] == 0 and wan[2] !=0:
            return(n_1[wan[0]]+' '+n_2[1]+' '+n_1[wan[1]]+' '+n_1[wan[2]]+' '+n_2[3])
        elif ge[1]!=0 and ge[2]==0:
            return(n_1[ge[0]]+' '+n_2[1]+' '+n_1[ge[1]]+' '+n_2[0]+' '+n_2[3])
        else:
            return(n_1[wan[0]]+' '+n_2[1]+' '+n_1[wan[1]]+' '+n_2[0]+' '+n_1[wan[2]]+' '+n_2[3])
    elif len(wan) == 2:
        if wan[0]==1:
            if wan[1]==0:
                return(n_2[0]+' '+n_2[3])
            else:
                return(n_2[0]+' '+n_1[wan[1]]+' '+n_2[3])
        else:
            if wan[1]==0:
                return(n_1[wan[0]]+' '+n_2[0]+' '+n_2[3])
            else:
                return(n_1[wan[0]]+' '+n_2[0]+' '+n_1[wan[1]]+' '+n_2[3])
    else:
        return(n_1[wan[0]]+' '+n_2[3])

def reader_yi(yi):
    yi=list(map(int,yi))
    if len(yi) == 4:
        if yi[1]==0 and yi[2]==0 and yi[3]==0:
            return(n_1[yi[0]]+' '+n_2[2]+' '+n_2[4])
        elif yi[1]==0 and yi[2]==0 and yi[3]!=0:
            return(n_1[yi[0]]+' '+n_2[2]+' '+n_1[yi[1]]+' '+n_1[yi[3]]+' '+n_2[4])
        elif yi[1]==0 and yi[2]!=0 and yi[3]==0:
            return(n_1[yi[0]]+' '+n_2[2]+' '+n_1[yi[1]]+' '+n_1[yi[2]]+' '+n_2[0]+' '+n_2[4])
        elif yi[1]==0 and yi[2]!=0 and yi[3]!=0:
            return(n_1[yi[0]]+' '+n_2[2]+' '+n_1[yi[1]]+' '+n_1[yi[2]]+' '+n_2[0]+' '+n_1[yi[3]]+' '+n_2[4])
        elif yi[1]!=0 and yi[2]==0 and yi[3]==0:
            return(n_1[yi[0]]+' '+n_2[2]+' '+n_1[yi[1]]+' '+n_2[1]+' '+n_2[4])
        elif yi[1]!=0 and yi[2]==0 and yi[3]!=0:
            return(n_1[yi[0]]+' '+n_2[2]+' '+n_1[yi[1]]+' '+n_2[1]+' '+n_1[yi[2]]+' '+n_1[yi[3]]+' '+n_2[4])
        elif yi[1]!=0 and yi[2]!=0 and yi[3]==0:
            return(n_1[yi[0]]+' '+n_2[2]+' '+n_1[yi[1]]+' '+n_2[1]+' '+n_1[yi[2]]+' '+n_2[0]+' '+n_2[4])
        else:
            return(n_1[yi[0]]+' '+n_2[2]+' '+n_1[yi[1]]+' '+n_2[1]+' '+n_1[yi[2]]+' '+n_2[0]+' '+n_1[yi[3]]+' '+n_2[4])
    
    elif len(yi) == 3:
        if yi[1] == 0 and yi[2] == 0:
            return(n_1[yi[0]]+' '+n_2[1]+' '+n_2[4])
        elif yi[1] == 0 and yi[2] !=0:
            return(n_1[yi[0]]+' '+n_2[1]+' '+n_1[yi[1]]+' '+n_1[yi[2]]+' '+n_2[4])
        elif yi[1]!=0 and yi[2]==0:
            return(n_1[yi[0]]+' '+n_2[1]+' '+n_1[yi[1]]+' '+n_2[0]+' '+n_2[4])
        else:
            return(n_1[yi[0]]+' '+n_2[1]+' '+n_1[yi[1]]+' '+n_2[0]+' '+n_1[yi[2]]+' '+n_2[4])
    elif len(yi) == 2:
        if yi[0]==1:
            if yi[1]==0:
                return(n_2[0]+' '+n_2[4])
            else:
                return(n_2[0]+' '+n_1[yi[1]]+' '+n_2[4])
        else:
            if yi[1]==0:
                return(n_1[yi[0]]+' '+n_2[0]+' '+n_2[4])
            else:
                return(n_1[yi[0]]+' '+n_2[0]+' '+n_1[yi[1]]+' '+n_2[4])
    else:
        return(n_1[yi[0]]+' '+n_2[4])

a=list(input().strip())
if len(a) > 8:
    ge=a[-4::]
    wan=a[-8:-4:1]
    yi=a[0:-8:1]
    print(reader_yi(yi)+' '+reader_wan(wan,ge)+' '+reader_ge(ge))
elif len(a) >4 and len(a) <9:
    ge=a[-4::]
    wan=a[0:-4:1]
    print(reader_wan(wan,ge)+' '+reader_ge(ge))
else:
    ge=a
    print(reader_ge(ge))
yusaisai大鱼
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
蓝桥杯BASIC-20 基础练习 数的读法
qq_43541423的博客
04-16 745
蓝桥杯BASIC-20 基础练习 数的读法 问题描述 　　Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。 　　所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法： 　...
蓝桥杯试题 基础练习 数的读法(C++版）
qq_45214414的博客
04-10 754
问题描述 　　Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。 　　所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法： 　　十二亿三千四百五十六万七千零九 　　用汉语...
试题 基础练习 数的读法
liuliuliuliuqi的博客
04-08 272
问题描述 　　Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。 　　所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法： 　　十二亿三千四百五十六万七千零九 　　用汉语...
java解决数的读法
qq_41857047的博客
03-08 327
Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。 　　所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法： 　　十二亿三千四百五十六万七千零九 　　用汉语拼音表示为 　...
蓝桥杯——数的读法
floating_fight的博客
03-08 290
问题描述 Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。 　　所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法： 　　十二亿三千四百五十六万七千零九 　　用汉语拼音...
蓝桥杯试题 基础练习 数的读法 BASIC-20 JAVA
12-21
目录参考试题 基础练习 数的读法要点本题代码 参考 大佬博客《基础练习 数的读法》 试题 基础练习 数的读法 资源限制 时间限制：1.0s 内存限制：512.0MB 问题描述 　Tom教授正在给研究生讲授一门关于基因的课程，有...
蓝桥杯Python 基础练习 数的读法
01-20
试题 基础练习 数的读法 资源限制 时间限制：1.0s 内存限制：512.0MB 问题描述 　Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万...
蓝桥杯练习系统-基础题全解C++
03-06
【标题】"蓝桥杯练习系统-基础题全解C++"揭示了这是一份针对蓝桥杯竞赛的C++编程训练资料，旨在帮助参赛者掌握C++的基础知识和编程技巧，以提升在比赛中的表现。 【描述】的简洁性表明这份资料可能包含了对蓝桥杯...
蓝桥杯国赛题之C++数的读法.zip
最新发布
06-02
【标题】"蓝桥杯国赛题之C++数的读法"主要涉及的是在C++编程语言中处理数字输入的技巧，这是编程竞赛中常见的问题。蓝桥杯全国软件和信息技术专业人才大赛是一个权威的编程竞赛，对于参赛者来说，理解和掌握C++中的...
数字读法--蓝桥杯（这题真不会！！！根本没思路啊！）
qq_36063677的博客
02-23 630
问题描述　　Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。　　所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法：　　十二亿三千四百五十六万七千零九　　用汉语拼音表示为...
数的读法(java)
m0_67160380的博客
01-15 95
a4
蓝桥杯 [BASIC-20] 数的读法
不忘初心 方得始终
05-21 3543
基础练习 数的读法 时间限制：1.0s 内存限制：512.0MB 问题描述 　　Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。 　　所以，他迫切地需要一个系统
蓝桥杯-基础练习-数的读法（Java）
qq_23934649的博客
03-03 739
写了好久啊，我好菜啊 import java.util.Scanner; public class Main{ public static void main(String[] args){ Scanner scanner = new Scanner(System.in); String number = scanner.nextLine(); ...
蓝桥杯：数的读法
知足~的博客
03-07 6084
题目： Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。 　　所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法： 　　十二亿三千四百五十六万七千零九 　　用
蓝桥杯BASIC-20(数的读法)
kaishihaohaozuoshi的博客
12-23 1120
问题描述 　　Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。 　　所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法： 　　十二亿三千四百五十六万七千零九
蓝桥杯 基础练习 数的读法 C语言实现
qq_47888755的博客
09-13 1165
蓝桥杯 基础练习 数的读法 C语言实现 问题描述　　Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法： 十二亿三千四百五十六万七千零九，用汉语拼音表示为：shi er yi san qian si bai wu shi liu wan
蓝桥杯-数的读法
Vivinia的博客
01-23 482
package jiChu; import java.util.Scanner; /** 问题描述 Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。 所以，他迫切地需要一个系统，然后当他输入1234
蓝桥杯python数的读法
04-02
对于一个数n，我们可以将其拆分成若干组数位相同的数字，然后读出每一组数字的数值和单位。例如： - 对于 123456789，我们可以将其拆分成 1 亿，2345 万，6789。 - 对于 200000，我们可以将其拆分成 2 十万。 具体的读法可以参考以下规则： - 对于 1~9 的数字，直接读出其汉字，如 1 读作“一”，9 读作“九”。 - 对于 10~99 的数字，读出十位数的汉字，如果个位数不为 0，则加上个位数的汉字，如 22 读作“二十二”，55 读作“五十五”。 - 对于 100~999 的数字，读出百位数的汉字，如果十位数为 0，则只读出“几百”，否则在“几百”后加上十位数和个位数的汉字，如 234 读作“二百三十四”，707 读作“七百零七”。 - 对于 1000~9999 的数字，读出千位数的汉字，如果百位数为 0，则只读出“几千”，否则在“几千”后加上百位数、十位数和个位数的汉字，如 5678 读作“五千六百七十八”。 - 对于 10000~99999 的数字，读出万位数的汉字，如果千位数为 0，则只读出“几万”，否则在“几万”后加上千位数、百位数、十位数和个位数的汉字，如 12345 读作“一万二千三百四十五”。 - 对于 100000~999999 的数字，读出十万位数的汉字，如果万位数为 0，则只读出“几十万”，否则在“几十万”后加上万位数、千位数、百位数、十位数和个位数的汉字，如 234567 读作“二十三万四千五百六十七”。 - 对于 1000000~99999999 的数字，读出百万位数的汉字，如果十万位数为 0，则只读出“几百万”，否则在“几百万”后加上十万位数、万位数、千位数、百位数、十位数和个位数的汉字，如 12345678 读作“一千二百三十四万五千六百七十八”。 - 对于 100000000~999999999 的数字，读出亿位数的汉字，如果百万位数为 0，则只读出“几亿”，否则在“几亿”后加上百万位数、十万位数、万位数、千位数、百位数、十位数和个位数的汉字，如 987654321 读作“九亿八千七百六十五万四千三百二十一”。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值