《算法的乐趣》4.阿拉伯数字与中文数字------python

2024-02-18 10:48
文章标签 python 算法 乐趣 ------ 阿拉伯数字 中文数字

本文主要是介绍《算法的乐趣》4.阿拉伯数字与中文数字------python，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

        • 注意问题
        • 阿拉伯数字转中文数字
        • 中文数字转阿拉伯数字

中文数字直接用"数字+权位"的方式组成数字。数字：“零一二三四五六七八九”，权位：“十，百，千，万，亿”。
特点：1.每个基础数字都跟着一个权位，这个权位就是这个数字的量值，相当于阿拉伯数字中的数位。
2.以"万"为小节。

注意问题

中文数字中的零：
1.以10000为小节，小节的结尾即使是0，也不使用零；
2.小节内两个非0数字之间要使用零；
3.当小节的千为是0时，若本小姐的前一节无其他数字，则不适用零，否则就要用零。

阿拉伯数字转中文数字
chn_num_char = ["零", "一", "二", "三", "四", "五", "六", "七", "八", "九"]
chn_unit_section = ["", "万", "亿", "万亿"]
chn_unit_char = ["", "十", "百", "千"]


def transfrom(section):"""节内数字转换args:section: 四位以内的整数return:chn_section: 中文数字"""chn_section = ""str_ins = ""# 权位unit_pos = 0# 零的标志位zero = Truewhile section > 0:v = section % 10if v == 0:if not zero:zero = Truechn_section = chn_num_char[v] + chn_sectionelse:zero = Falsestr_ins = chn_num_char[v]str_ins += chn_unit_char[unit_pos]chn_section = str_ins + chn_sectionunit_pos += 1section //= 10return chn_section
print(1, transfrom(1))
print(10, transfrom(10))
print(11, transfrom(11))
print(100, transfrom(100))
print(110, transfrom(110))
print(101, transfrom(101))
print(111, transfrom(111))
print(1000, transfrom(1000))
print(1100, transfrom(1100))
print(1010, transfrom(1010))
print(1001, transfrom(1001))
print(1011, transfrom(1011))
print(1101, transfrom(1101))
print(1110, transfrom(1110))
print(1111, transfrom(1111))

1 一
10 一十
11 一十一
100 一百
110 一百一十
101 一百零一
111 一百一十一
1000 一千
1100 一千一百
1010 一千零一十
1001 一千零一
1011 一千零一十一
1101 一千一百零一
1110 一千一百一十
1111 一千一百一十一

def Arabic_to_Chinese(number):"""阿拉伯数字转中文数字：args:number: 阿拉伯整数return:chn_number: 中文数字"""chn_number = ""str_ins = ""if number == 0:chn_number = chn_num_char[0]return chn_numberunit_pos = 0 # 权位zero = Falsewhile number > 0:section = number % 10000if zero:chn_number = chn_num_char[0] + chn_numberif section > 0:str_ins = transfrom(section) + chn_unit_section[unit_pos]chn_number = str_ins + chn_numberzero = (section<1000 and section>0)number //= 10000unit_pos += 1return chn_number

print(0, Arabic_to_Chinese(0))
print(1, Arabic_to_Chinese(1))
print(2, Arabic_to_Chinese(2))
print(3, Arabic_to_Chinese(3))
print(4, Arabic_to_Chinese(4))
print(5, Arabic_to_Chinese(5))
print(6, Arabic_to_Chinese(6))
print(7, Arabic_to_Chinese(7))
print(8, Arabic_to_Chinese(8))
print(9, Arabic_to_Chinese(9))
print(10, Arabic_to_Chinese(10))
print(11, Arabic_to_Chinese(11))
print(110, Arabic_to_Chinese(110))
print(111, Arabic_to_Chinese(111))
print(100, Arabic_to_Chinese(100))
print(102, Arabic_to_Chinese(102))
print(1020, Arabic_to_Chinese(1020))
print(1001, Arabic_to_Chinese(1001))
print(1015, Arabic_to_Chinese(1015))
print(1000, Arabic_to_Chinese(1000))
print(10000, Arabic_to_Chinese(10000))
print(100000, Arabic_to_Chinese(100000))
print(1000000, Arabic_to_Chinese(1000000))
print(10000000, Arabic_to_Chinese(10000000))
print(100000000, Arabic_to_Chinese(100000000))
print(1000000000, Arabic_to_Chinese(1000000000))
print(1000001000, Arabic_to_Chinese(1000001000))
print(1000000100, Arabic_to_Chinese(1000000100))
print(200010, Arabic_to_Chinese(200010))
print(2000105, Arabic_to_Chinese(2000105))
print(20001007, Arabic_to_Chinese(20001007))
print(2000100190, Arabic_to_Chinese(2000100190))
print(1040010000, Arabic_to_Chinese(1040010000))
print(200012301, Arabic_to_Chinese(200012301))
print(2005010010, Arabic_to_Chinese(2005010010))
print(4009060200, Arabic_to_Chinese(4009060200))
print(4294967295, Arabic_to_Chinese(4294967295))
0 零
1 一
2 二
3 三
4 四
5 五
6 六
7 七
8 八
9 九
10 一十
11 一十一
110 一百一十
111 一百一十一
100 一百
102 一百零二
1020 一千零二十
1001 一千零一
1015 一千零一十五
1000 一千
10000 一万
100000 一十万
1000000 一百万
10000000 一千万
100000000 一亿
1000000000 一十亿
1000001000 一十亿一千
1000000100 一十亿零一百
200010 二十万零一十
2000105 二百万零一百零五
20001007 二千万一千零七
2000100190 二十亿零一十万零一百九十
1040010000 一十亿四千零一万
200012301 二亿零一万二千三百零一
2005010010 二十亿零五百零一万零一十
4009060200 四十亿零九百零六万零二百
4294967295 四十二亿九千四百九十六万七千二百九十五
中文数字转阿拉伯数字
cn_sum = {"零":0, '一': 1, '二': 2, '三': 3, '四': 4, '五': 5, '六': 6,\'七': 7, '八': 8, '九': 9, '十': 10, '百': 100, '千': 1000, '万': 10000, '亿': 100000000} def Chinese_to_Arabic(chn_number):"""中文数字转阿拉伯数字args:chn_number: 中文数字return:number: 阿拉伯数字"""pos = 0number = 0section = 0num = 0if cn_sum[chn_number[pos]] == "零":return numberwhile pos < len(chn_number):if cn_sum[chn_number[pos]] < 10 and cn_sum[chn_number[pos]] > 0:num = cn_sum[chn_number[pos]]else:if cn_sum[chn_number[pos]] > 1000:# 一节结束section = (section + num) * cn_sum[chn_number[pos]]num = 0number += sectionsection = 0elif cn_sum[chn_number[pos]] < 1001 and cn_sum[chn_number[pos]] > 9:# 节内计算section += num * cn_sum[chn_number[pos]]num = 0# 最后一节直接输出if pos == len(chn_number)-1:section += numnumber += sectionpos += 1return number

print("零", Chinese_to_Arabic("零"))
print("一", Chinese_to_Arabic("一"))
print("二", Chinese_to_Arabic("二"))
print("三", Chinese_to_Arabic("三"))
print("四", Chinese_to_Arabic("四"))
print("五", Chinese_to_Arabic("五"))
print("六", Chinese_to_Arabic("六"))
print("七", Chinese_to_Arabic("七"))
print("八", Chinese_to_Arabic("八"))
print("九", Chinese_to_Arabic("九"))
print("一十", Chinese_to_Arabic("一十"))
print("一十一", Chinese_to_Arabic("一十一"))
print("一百一十", Chinese_to_Arabic("一百一十"))
print("一百一十一", Chinese_to_Arabic("一百一十一"))
print("一百", Chinese_to_Arabic("一百"))
print("一百零二", Chinese_to_Arabic("一百零二"))
print("一千零二十", Chinese_to_Arabic("一千零二十"))
print("一千零一", Chinese_to_Arabic("一千零一"))
print("一千零一十五", Chinese_to_Arabic("一千零一十五"))
print("一万", Chinese_to_Arabic("一万"))
print("一万", Chinese_to_Arabic("一万"))
print("一十万", Chinese_to_Arabic("一十万"))
print("一百万", Chinese_to_Arabic("一百万"))
print("一千万", Chinese_to_Arabic("一千万"))
print("一亿", Chinese_to_Arabic("一亿"))
print("一十亿", Chinese_to_Arabic("一十亿"))
print("一十亿一千", Chinese_to_Arabic("一十亿一千"))
print("一十亿零一百", Chinese_to_Arabic("一十亿零一百"))
print("二十万零一十", Chinese_to_Arabic("二十万零一十"))
print("二百万零一百零五", Chinese_to_Arabic("二百万零一百零五"))
print("二千万一千零七", Chinese_to_Arabic("二千万一千零七"))
print("二十亿零一十万零一百九十", Chinese_to_Arabic("二十亿零一十万零一百九十"))
print("一十亿四千零一万", Chinese_to_Arabic("一十亿四千零一万"))
print("二亿零一万二千三百零一", Chinese_to_Arabic("二亿零一万二千三百零一"))
print("二十亿零五百零一万零一十", Chinese_to_Arabic("二十亿零五百零一万零一十"))
print("四十亿零九百零六万零二百", Chinese_to_Arabic("四十亿零九百零六万零二百"))
print("四十二亿九千四百九十六万七千二百九十五", Chinese_to_Arabic("四十二亿九千四百九十六万七千二百九十五"))

零 0
一 1
二 2
三 3
四 4
五 5
六 6
七 7
八 8
九 9
一十 10
一十一 11
一百一十 110
一百一十一 111
一百 100
一百零二 102
一千零二十 1020
一千零一 1001
一千零一十五 1015
一万 10000
一万 10000
一十万 100000
一百万 1000000
一千万 10000000
一亿 100000000
一十亿 1000000000
一十亿一千 1000001000
一十亿零一百 1000000100
二十万零一十 200010
二百万零一百零五 2000105
二千万一千零七 20001007
二十亿零一十万零一百九十 2000100190
一十亿四千零一万 1040010000
二亿零一万二千三百零一 200012301
二十亿零五百零一万零一十 2005010010
四十亿零九百零六万零二百 4009060200
四十二亿九千四百九十六万七千二百九十五 4294967295

这篇关于《算法的乐趣》4.阿拉伯数字与中文数字------python的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/720909。

相关文章

不懂推荐算法也能设计推荐系统

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例，告诉我们不懂推荐算法的产品，也能从产品侧出发， 设计出一款不错的推荐系统。 相信很多新手产品，看到算法二字，多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法（注：传统是指科班出身的产品都会接触过）。但对于推荐算法，多数产品对着网上搜到的资源，都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后，更是加大了理解的难度。 但，不了解推荐算法，就无法做推荐系
阅读更多...
python: 多模块(.py)中全局变量的导入

python: 多模块(.py)中全局变量的导入

文章目录 global关键字可变类型和不可变类型数据的内存地址单模块(单个py文件)的全局变量示例总结 多模块(多个py文件)的全局变量from x import x导入全局变量示例 import x导入全局变量示例 总结 global关键字 global 的作用范围是模块(.py)级别： 当你在一个模块（文件）中使用 global 声明变量时，这个变量只在该模块的全局命名空
阅读更多...
康拓展开（hash算法中会用到）

康拓展开（hash算法中会用到）

康拓展开是一个全排列到一个自然数的双射（也就是某个全排列与某个自然数一一对应） 公式： X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0! 其中,a[i]为整数,并且0<=a[i]<i,1<=i<=n。（a[i]在不同应用中的含义不同）； 典型应用： 计算当前排列在所有由小到大全排列中的顺序，也就是说求当前排列是第
阅读更多...
csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

这是一道扩展欧几里得算法的简单应用题，这题是在湖南多校训练赛中队友ac的一道题，在比赛之后请教了队友，然后自己把它a掉 这也是自己独自做扩展欧几里得算法的题目 题意：把题意转变下就变成了：求d1*x - d2*y = f2 - f1的解,很明显用exgcd来解 下面介绍一下exgcd的一些知识点：求ax + by = c的解 一、首先求ax + by = gcd(a,b)的解 这个
阅读更多...
综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

LntonAIServer视频质量诊断功能中的抖动检测是一个专门针对视频稳定性进行分析的功能。抖动通常是指视频帧之间的不必要运动，这种运动可能是由于摄像机的移动、传输中的错误或编解码问题导致的。抖动检测对于确保视频内容的平滑性和观看体验至关重要。 优势 1. 提高图像质量 - 清晰度提升：减少抖动，提高图像的清晰度和细节表现力，使得监控画面更加真实可信。 - 细节增强：在低光条件下，抖
阅读更多...
【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

前言：快速排序的实现最重要的是找基准值，下面让我们来了解如何实现找基准值 基准值的注释：在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。 在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。 快速排序实现主框架： //快速排序 void QuickSort(int* arr, int left, int rig
阅读更多...
【Python编程】Linux创建虚拟环境并配置与notebook相连接

【Python编程】Linux创建虚拟环境并配置与notebook相连接

1.创建 使用 venv 创建虚拟环境。例如，在当前目录下创建一个名为 myenv 的虚拟环境： python3 -m venv myenv 2.激活 激活虚拟环境使其成为当前终端会话的活动环境。运行： source myenv/bin/activate 3.与notebook连接 在虚拟环境中，使用 pip 安装 Jupyter 和 ipykernel： pip instal
阅读更多...
poj 3974 and hdu 3068 最长回文串的O（n）解法(Manacher算法)

poj 3974 and hdu 3068 最长回文串的O（n）解法(Manacher算法)

求一段字符串中的最长回文串。 因为数据量比较大，用原来的O（n^2）会爆。 小白上的O(n^2)解法代码：TLE啦~ #include<stdio.h>#include<string.h>const int Maxn = 1000000;char s[Maxn];int main(){char e[] = {"END"};while(scanf("%s", s) != EO
阅读更多...
【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程（Gaussian Process，简称GP）是一种概率模型，用于描述一组随机变量的联合概率分布，其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数（或核函数） 1.3 核函数1.4 高斯过程回归（Gauss
阅读更多...
秋招最新大模型算法面试，熬夜都要肝完它

秋招最新大模型算法面试，熬夜都要肝完它

💥大家在面试大模型LLM这个板块的时候，不知道面试完会不会复盘、总结，做笔记的习惯，这份大模型算法岗面试八股笔记也帮助不少人拿到过offer ✨对于面试大模型算法工程师会有一定的帮助，都附有完整答案，熬夜也要看完，祝大家一臂之力 这份《大模型算法工程师面试题》已经上传CSDN，还有完整版的大模型 AI 学习资料，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2