Bootstrap

华为OD机试 - 人民币转换（Python/JS/C/C++ 牛客练习题 HJ95）

在这里插入图片描述

2025华为OD机试题库（按算法分类）：2025华为OD统一考试题库清单（持续收录中）以及考点说明（Python/JS/C/C++）。

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。

一、题目描述

考试题目和要点：

  1. 中文大写金额数字前应标明“人民币”字样。中文大写金额数字应用壹、贰、叁、肆、伍、陆、柒、捌、玖、拾、佰、仟、万、亿、元、角、分、零、整等字样填写。
  2. 中文大写金额数字到“元”为止的，在“元”之后，应写“整字，如532.00应写成“人民币伍佰叁拾贰元整”。在”角“和”分“后面不写”整字。
  3. 阿拉伯数字中间有“0”时，中文大写要写“零”字，阿拉伯数字中间连续有几个“0”时，中文大写金额中间只写一个“零”字，如6007.14，应写成“人民币陆仟零柒元壹角肆分“。
  4. 10应写作“拾”，100应写作“壹佰”。例如，1010.00应写作“人民币壹仟零拾元整”，110.00应写作“人民币壹佰拾元整”
  5. 十万以上的数字接千不用加“零”，例如，30105000.00应写作“人民币叁仟零拾万伍仟元整”

二、输入描述

输入一个double数。

三、输出描述

输出人民币格式。

四、测试用例

测试用例1

1、输入

532.00

2、输出

人民币伍佰叁拾贰元整

3、说明

整数部分532转换为“伍佰叁拾贰”，小数部分为00，故输出“人民币伍佰叁拾贰元整”。

测试用例2

1、输入

6007.14

2、输出

人民币陆仟零柒元壹角肆分

3、说明

6007转换为“陆仟零柒”（中间的两个0只输出一个“零”），小数部分14转换为“壹角肆分”，合并后输出“人民币陆仟零柒元壹角肆分”。

五、解题思路

将输入金额分成整数部分和小数部分分别转换。

整数部分：采用分组法——将整数部分按每四位分为一组（最低组可能不足4位），对每一组调用辅助函数转换为中文大写，转换时注意：
千、百、十、个位依次转换。

若十位数字为1（且不是整个数唯一的数字），则直接输出“拾”而不写“壹拾”。

对于组内连续的0只输出一个“零”。

当低组不足4位时（即数值小于1000）但又位于高组后面时，需在前面加上“零”以连接。

小数部分：处理“角”和“分”，若为0则不输出，且当小数部分为00时，在整数部分后加“整”。

详细的解题步骤：

  1. 输入一个double数；
  2. 使用split(“\.”)将输入的数分割为整数部分和小数部分，并存储在字符串数组s中；
  3. 判断小数部分是否为"00"，如果是，则输出整数部分的中文大写金额数字后跟"元整"；
  4. 判断整数部分是否为"0"，如果是，则输出小数部分的中文大写金额数字；
  5. 如果不满足以上两种情况，输出整数部分的中文大写金额数字后跟"元"，再输出小数部分的中文大写金额数字；
  6. 实现solveXiao函数，接收小数部分的字符串作为参数，返回小数部分的中文大写金额数字；
    • 将小数部分的第一个字符转换为整数，表示角；
    • 将小数部分的第二个字符转换为整数，表示分；
    • 如果角不为0，则添加角的中文大写金额数字和"角"；
    • 如果分不为0，则添加分的中文大写金额数字和"分"；
    • 返回拼接后的字符串；
  7. 实现solveZheng函数，接收整数部分的double数作为参数，返回整数部分的中文大写金额数字；
    • 使用StringBuilder来拼接中文大写金额数字；
    • 使用pow变量来表示权值的索引，初始值为0；
    • 使用循环，当整数部分不为0时进行迭代；
    • 在每次迭代中，根据权值索引添加"万"或"亿"到拼接的字符串中；
    • 将整数部分模10000得到四位数的临时值temp；
    • 提取临时值的个位、十位、百位和千位的数字；
    • 判断个位是否为0，如果不为0，则添加个位的中文大写金额数字；
    • 判断十位是否为0，如果不为0，则添加"拾"和十位的中文大写金额数字（如果十位为1，则不添加十位的中文大写金额数字）；
    • 判断百位是否为0，如果不为0，则添加"佰"和百位的中文大写金额数字；
    • 判断千位是否为0，如果不为0，则添加"仟"和千位的中文大写金额数字；
    • 更新整数部分为整数部分除以10000的结果，用于下一次迭代；
    • 更新权值索引，当索引超过2时，重置为1；
    • 循环结束后，将拼接的字符串反转，并返回作为结果；
  8. 在主函数中，使用while循环读取输入的每个测试用例；
  9. 根据题目要求，输出人民币格式的中文大写金额数字

六、Python算法源码

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 定义数字对应的中文大写
digitChinese = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"]

def convert(amount):
    """
    将金额转换为中文大写人民币格式
    """
    # 分离整数部分和小数部分
    integerPart = int(amount)
    decimalPart = round((amount - integerPart) * 100)
    
    # 转换整数部分
    intStr = convertInteger(integerPart)
    # 转换小数部分
    decStr = convertDecimal(decimalPart)
    
    result = "人民币"
    # 整数部分为0时输出“零元”
    if integerPart == 0:
        result += "零元"
    else:
        result += intStr + "元"
    # 若小数部分为0则加“整”，否则拼接角分部分
    if decimalPart == 0:
        result += "整"
    else:
        result += decStr
    return result

def convertInteger(num):
    """
    将整数部分转换，每四位一组处理
    """
    if num == 0:
        return "零"
    parts = []
    groupIndex = 0  # 组号：0-无单位，1-“万”，2-“亿”
    while num > 0:
        groupNum = num % 10000  # 取低4位
        num //= 10000
        groupStr = convertFourDigit(groupNum)
        if groupIndex > 0 and 0 < groupNum < 1000:
            # 低组不足4位需前置“零”
            groupStr = "零" + groupStr
        if groupStr:
            if groupIndex == 1:
                groupStr += "万"
            elif groupIndex == 2:
                groupStr += "亿"
        parts.append(groupStr)
        groupIndex += 1
    # 逆序后拼接各组字符串
    parts.reverse()
    return "".join(parts)

def convertFourDigit(num):
    """
    将0~9999的数字转换为中文大写
    """
    if num == 0:
        return ""
    sb = []
    thousand = num // 1000          # 千位
    hundred = (num % 1000) // 100    # 百位
    ten = (num % 100) // 10          # 十位
    one = num % 10                 # 个位
    
    # 处理千位
    if thousand != 0:
        sb.append(digitChinese[thousand] + "仟")
    # 处理百位
    if hundred != 0:
        sb.append(digitChinese[hundred] + "佰")
    else:
        if thousand != 0 and num % 100 != 0:
            sb.append("零")
    # 处理十位
    if ten != 0:
        # 十位为1时直接输出“拾”
        if ten == 1:
            sb.append("拾")
        else:
            sb.append(digitChinese[ten] + "拾")
    else:
        if (hundred != 0 or thousand != 0) and one != 0:
            # 若十位为0且个位不为0，并且前面没有“零”
            if not (sb and sb[-1] == "零"):
                sb.append("零")
    # 处理个位
    if one != 0:
        sb.append(digitChinese[one])
    return "".join(sb)

def convertDecimal(num):
    """
    将小数部分转换，处理角和分
    """
    if num == 0:
        return ""
    jiao = num // 10
    fen = num % 10
    sb = []
    if jiao != 0:
        sb.append(digitChinese[jiao] + "角")
    if fen != 0:
        sb.append(digitChinese[fen] + "分")
    return "".join(sb)

if __name__ == '__main__':
    # 下面可输入多组测试数据，每行一个测试用例
    test_cases = ["532.00", "6007.14", "1010.00", "110.00", "30105000.00"]
    for tc in test_cases:
        amount = float(tc)
        print("输入:", tc, "输出:", convert(amount))

七、JavaScript算法源码

// 定义数字对应的中文大写
const digitChinese = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"];

/**
 * 将金额转换为中文大写人民币格式
 * @param {number} amount - 输入的金额
 * @returns {string} - 转换后的结果
 */
function convert(amount) {
    // 分离整数部分和小数部分
    const integerPart = Math.floor(amount);
    const decimalPart = Math.round((amount - integerPart) * 100);
    
    const intStr = convertInteger(integerPart);
    const decStr = convertDecimal(decimalPart);
    
    let result = "人民币";
    // 整数部分为0时输出“零元”
    if (integerPart === 0) {
        result += "零元";
    } else {
        result += intStr + "元";
    }
    // 小数部分为0时输出“整”，否则拼接角分部分
    if (decimalPart === 0) {
        result += "整";
    } else {
        result += decStr;
    }
    return result;
}

/**
 * 将整数部分转换，每四位一组处理
 * @param {number} num - 整数部分
 * @returns {string} - 转换后的中文字符串
 */
function convertInteger(num) {
    if (num === 0) return "零";
    const parts = [];
    let groupIndex = 0; // 组号：0-无单位，1-“万”，2-“亿”
    while (num > 0) {
        const groupNum = num % 10000; // 取低4位
        num = Math.floor(num / 10000);
        let groupStr = convertFourDigit(groupNum);
        if (groupIndex > 0 && groupNum < 1000 && groupNum > 0) {
            // 低组不足4位需前置“零”
            groupStr = "零" + groupStr;
        }
        if (groupStr !== "") {
            if (groupIndex === 1) {
                groupStr += "万";
            } else if (groupIndex === 2) {
                groupStr += "亿";
            }
        }
        parts.push(groupStr);
        groupIndex++;
    }
    // 逆序拼接各组字符串
    parts.reverse();
    return parts.join("");
}

/**
 * 辅助函数：转换0~9999之间的数字为中文大写
 * @param {number} num - 数值
 * @returns {string} - 转换后的字符串
 */
function convertFourDigit(num) {
    if (num === 0) return "";
    let sb = "";
    const thousand = Math.floor(num / 1000);          // 千位
    const hundred = Math.floor((num % 1000) / 100);     // 百位
    const ten = Math.floor((num % 100) / 10);           // 十位
    const one = num % 10;                             // 个位
    
    // 处理千位
    if (thousand !== 0) {
        sb += digitChinese[thousand] + "仟";
    }
    // 处理百位
    if (hundred !== 0) {
        sb += digitChinese[hundred] + "佰";
    } else {
        if (thousand !== 0 && (num % 100) !== 0) {
            sb += "零";
        }
    }
    // 处理十位
    if (ten !== 0) {
        // 当十位为1时直接输出“拾”
        if (ten === 1) {
            sb += "拾";
        } else {
            sb += digitChinese[ten] + "拾";
        }
    } else {
        if ((hundred !== 0 || thousand !== 0) && one !== 0) {
            if (!sb.endsWith("零")) {
                sb += "零";
            }
        }
    }
    // 处理个位
    if (one !== 0) {
        sb += digitChinese[one];
    }
    return sb;
}

/**
 * 将小数部分转换，处理角和分
 * @param {number} num - 小数部分（0~99）
 * @returns {string} - 转换后的字符串
 */
function convertDecimal(num) {
    if (num === 0) return "";
    const jiao = Math.floor(num / 10);
    const fen = num % 10;
    let sb = "";
    if (jiao !== 0) {
        sb += digitChinese[jiao] + "角";
    }
    if (fen !== 0) {
        sb += digitChinese[fen] + "分";
    }
    return sb;
}

// 测试用例
const testCases = ["532.00", "6007.14", "1010.00", "110.00", "30105000.00"];
testCases.forEach(tc => {
    const amount = parseFloat(tc);
    console.log("输入:", tc, "输出:", convert(amount));
});

八、C算法源码

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

// 定义数字对应的中文大写（UTF-8编码）
const char *digitChinese[] = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};

// 辅助函数声明
void convertFourDigit(int num, char *out);
void convertInteger(long num, char *out);
void convertDecimal(int num, char *out);

/**
 * 将金额转换为中文大写人民币格式，结果存入result缓冲区
 */
void convert(double amount, char *result) {
    long integerPart = (long) amount;
    int decimalPart = (int) round((amount - integerPart) * 100);
    
    char intStr[256] = {0};
    char decStr[64] = {0};
    
    // 转换整数部分
    convertInteger(integerPart, intStr);
    // 转换小数部分
    convertDecimal(decimalPart, decStr);
    
    // 拼接结果
    if (integerPart == 0) {
        sprintf(result, "人民币零元%s", (decimalPart == 0 ? "整" : decStr));
    } else {
        sprintf(result, "人民币%s元%s", intStr, (decimalPart == 0 ? "整" : decStr));
    }
}

/**
 * 将整数部分转换，每四位一组处理，结果存入out中
 */
void convertInteger(long num, char *out) {
    if(num == 0) {
        strcpy(out, "零");
        return;
    }
    // 用临时数组保存各组结果
    char parts[10][64] = {{0}};
    int groupIndex = 0;
    while(num > 0) {
        int groupNum = num % 10000;
        num /= 10000;
        char groupStr[64] = {0};
        convertFourDigit(groupNum, groupStr);
        // 若低组不足4位且不为0，则前置“零”
        if(groupIndex > 0 && groupNum < 1000 && groupNum > 0) {
            char temp[64] = {0};
            sprintf(temp, "零%s", groupStr);
            strcpy(groupStr, temp);
        }
        // 添加组单位
        if(strlen(groupStr) > 0) {
            if(groupIndex == 1) {
                strcat(groupStr, "万");
            } else if(groupIndex == 2) {
                strcat(groupStr, "亿");
            }
        }
        strcpy(parts[groupIndex], groupStr);
        groupIndex++;
    }
    // 将各组逆序拼接
    char temp[256] = {0};
    for(int i = groupIndex - 1; i >= 0; i--) {
        strcat(temp, parts[i]);
    }
    strcpy(out, temp);
}

/**
 * 辅助函数：转换0~9999之间的数字为中文大写，结果存入out中
 */
void convertFourDigit(int num, char *out) {
    if(num == 0) {
        out[0] = '\0';
        return;
    }
    char buf[64] = {0};
    int pos = 0;
    int thousand = num / 1000;          // 千位
    int hundred = (num % 1000) / 100;     // 百位
    int ten = (num % 100) / 10;           // 十位
    int one = num % 10;                 // 个位
    
    // 处理千位
    if(thousand != 0) {
        pos += sprintf(buf+pos, "%s仟", digitChinese[thousand]);
    }
    // 处理百位
    if(hundred != 0) {
        pos += sprintf(buf+pos, "%s佰", digitChinese[hundred]);
    } else {
        if(thousand != 0 && (num % 100) != 0) {
            pos += sprintf(buf+pos, "零");
        }
    }
    // 处理十位
    if(ten != 0) {
        if(ten == 1) {
            pos += sprintf(buf+pos, "拾");
        } else {
            pos += sprintf(buf+pos, "%s拾", digitChinese[ten]);
        }
    } else {
        if((hundred != 0 || thousand != 0) && one != 0) {
            int len = strlen(buf);
            if(len == 0 || strcmp(buf + len - strlen("零"), "零") != 0) {
                pos += sprintf(buf+pos, "零");
            }
        }
    }
    // 处理个位
    if(one != 0) {
        pos += sprintf(buf+pos, "%s", digitChinese[one]);
    }
    strcpy(out, buf);
}

/**
 * 将小数部分转换（处理角和分），结果存入out中
 */
void convertDecimal(int num, char *out) {
    if(num == 0) {
        out[0] = '\0';
        return;
    }
    int jiao = num / 10;
    int fen = num % 10;
    char buf[64] = {0};
    int pos = 0;
    if(jiao != 0) {
        pos += sprintf(buf+pos, "%s角", digitChinese[jiao]);
    }
    if(fen != 0) {
        pos += sprintf(buf+pos, "%s分", digitChinese[fen]);
    }
    strcpy(out, buf);
}

int main() {
    // 下面定义5个测试用例进行验证
    char *testCases[] = {"532.00", "6007.14", "1010.00", "110.00", "30105000.00"};
    int n = 5;
    char result[512] = {0};
    for (int i = 0; i < n; i++) {
        double amount = atof(testCases[i]);
        convert(amount, result);
        printf("输入: %s  输出: %s\n", testCases[i], result);
    }
    return 0;
}

九、C++算法源码

#include <iostream>
#include <sstream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;

// 定义数字对应的中文大写（UTF-8编码）
const vector<string> digitChinese = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};

/**
 * 辅助函数：转换0~9999之间的数字为中文大写
 */
string convertFourDigit(int num) {
    if(num == 0) return "";
    string res;
    int thousand = num / 1000;          // 千位
    int hundred = (num % 1000) / 100;     // 百位
    int ten = (num % 100) / 10;           // 十位
    int one = num % 10;                 // 个位
    
    // 处理千位
    if(thousand != 0)
        res += digitChinese[thousand] + "仟";
    // 处理百位
    if(hundred != 0)
        res += digitChinese[hundred] + "佰";
    else {
        if(thousand != 0 && (num % 100) != 0)
            res += "零";
    }
    // 处理十位
    if(ten != 0) {
        if(ten == 1)
            res += "拾";
        else
            res += digitChinese[ten] + "拾";
    } else {
        if((hundred != 0 || thousand != 0) && one != 0) {
            if(res.empty() || res.substr(res.size()-3) != "零")
                res += "零";
        }
    }
    // 处理个位
    if(one != 0)
        res += digitChinese[one];
    return res;
}

/**
 * 将整数部分转换，每四位一组处理
 */
string convertInteger(long num) {
    if(num == 0) return "零";
    vector<string> parts;
    int groupIndex = 0; // 组号：0-无单位，1-“万”，2-“亿”
    while(num > 0) {
        int groupNum = num % 10000;
        num /= 10000;
        string groupStr = convertFourDigit(groupNum);
        if(groupIndex > 0 && groupNum < 1000 && groupNum > 0)
            groupStr = "零" + groupStr;
        if(!groupStr.empty()){
            if(groupIndex == 1)
                groupStr += "万";
            else if(groupIndex == 2)
                groupStr += "亿";
        }
        parts.push_back(groupStr);
        groupIndex++;
    }
    reverse(parts.begin(), parts.end());
    string res;
    for(auto &s : parts)
        res += s;
    return res;
}

/**
 * 将小数部分转换，处理角和分
 */
string convertDecimal(int num) {
    if(num == 0) return "";
    int jiao = num / 10;
    int fen = num % 10;
    string res;
    if(jiao != 0)
        res += digitChinese[jiao] + "角";
    if(fen != 0)
        res += digitChinese[fen] + "分";
    return res;
}

/**
 * 将金额转换为中文大写人民币格式
 */
string convert(double amount) {
    long integerPart = (long) amount;
    int decimalPart = (int) round((amount - integerPart) * 100);
    
    string intStr = convertInteger(integerPart);
    string decStr = convertDecimal(decimalPart);
    
    string result = "人民币";
    if(integerPart == 0)
        result += "零元";
    else
        result += intStr + "元";
    if(decimalPart == 0)
        result += "整";
    else
        result += decStr;
    return result;
}

int main() {
    // 定义5个测试用例进行验证
    vector<string> testCases = {"532.00", "6007.14", "1010.00", "110.00", "30105000.00"};
    for(auto &tc : testCases) {
        double amount = stod(tc);
        cout << "输入: " << tc << "  输出: " << convert(amount) << endl;
    }
    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。

在这里插入图片描述

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
cesium通过引入 cesium-sensor-volumes ，展示czml文件中的传感器
Halcon之二维码
基于Springboot文件系统 -- 实现上传下载显示删除等接口详细解析 附代码（全）
【C++笔记】红黑树封装map和set深度剖析
在计算机中,两个数之间的取整(/)与取余(%)运算
超长干货，十倍提升你的搜索能力
云安全：2025年的挑战和最佳实践，从零基础到精通，收藏这篇就够了！
Python基于flask的智慧交通可视化，大数据智慧交通数据可视化系统
无迹卡尔曼滤波 (UKF, Unscented Kalman Filter) 算法详解及案例分析
使用YOLOv8训练自己的数据集（原理解析+数据标注说明+训练教程+图形化系统开发）
;