靠谱的车【华为OD机试-JAVAPythonC++JS】

题目描述

程序员小明打了一辆出租车去上班。出于职业敏感，他注意到这辆出租车的计费表有点问题，总是偏大。
出租车司机解释说他不喜欢数字4，所以改装了计费表，任何数字位置遇到数字4就直接跳过，其余功能都正常。
比如：
23再多一块钱就变为25；
39再多一块钱变为50；
399再多一块钱变为500；
小明识破了司机的伎俩，准备利用自己的学识打败司机的阴谋。
给出计费表的表面读数，返回实际产生的费用。
输入描述：
只有一行，数字N，表示里程表的读数。
(1<=N<=888888888)。
输出描述：
一个数字，表示实际产生的费用。以回车结束。
补充说明：
示例1
输入：
5
输出：
4
说明：
5表示计费表的表面读数。
4表示实际产生的费用其实只有4块钱。
示例2
输入：
17
输出：
15
说明：
17表示计费表的表面读数。
15表示实际产生的费用其实只有15块钱。
示例3
输入：
100
输出：
81
说明：
100表示计费表的表面读数。
81表示实际产生的费用其实只有81块钱。

解题思路

将表面读数转换为字符串，以便按位处理数字。
遍历每一位数字，从高位到低位。
对于每一位数字，如果是4，则直接跳过；如果大于4，则减一。
计算当前位数对应的实际费用，乘以权重（9的幂次方，从高位到低位递减），并累加到总费用中。
返回实际产生的费用。

这样，通过遍历每一位数字，对数字进行适当的处理，就可以得到实际产生的费用。

题解代码

Python题解代码

def calculate_actual_cost(surface_reading):
    actual_cost = 0
    surface_reading_str = str(surface_reading)

    for i in range(len(surface_reading_str)):
        digit = int(surface_reading_str[i])

        if digit == 4:
            # 跳过数字 4
            continue
        elif digit > 4:
            # 对大于 4 的数字减一
            digit -= 1

        # 计算当前位数对应的实际费用，并累加到总费用中
        actual_cost += digit * (9 ** (len(surface_reading_str) - i - 1))

    return actual_cost


# 输入获取
surface_reading = int(input())

# 计算实际产生的费用并输出结果
print(calculate_actual_cost(surface_reading))

JAVA题解代码

import java.util.Scanner;
public class ReliableCar {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			String line = sc.nextLine();
			processReliableCar( line );
		}
	}
 
	private static void processReliableCar( String line ) {
		StringBuffer sb = new StringBuffer();
		for( int i = 0; i < line.length(); i ++ )
		{
			char curChar = line.charAt( i );
			if( curChar > '4' )
			{
				sb.append( (char) ( curChar - 1 ) );
			}else
			{
				sb.append( curChar );
			}
		}
		String realValueStr = sb.toString();
		int realValue = 0;
		for( int i = 0; i < realValueStr.length(); i ++ )
		{
			realValue *= 9;
			realValue += ( realValueStr.charAt(i) - '0') ;
		}
		System.out.println( realValue );		
	}
		
}

C/C++题解代码

#include<iostream>
using namespace std;
 
int result(int val) {
	int m = val;
	int tmp = 0, j = 0, i = 1;
	while (val > 0) {
		if (val % 10 > 4) {
			tmp += ((val % 10) - 1) * j + i;
		}
		else {
			tmp += (val % 10) * j;
		}
		val /= 10;
		j = j * 9 + i;
		i *= 10;
	}
	return m - tmp;
}
 
int main() {
	int val;
	cin >> val;
	cout << result(val) << endl;
	return 0;
}

JS题解代码


const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;
void async function() {
    while (line = await readline()) {
        processRobotMoveArea(line);
    }
 
}();
 
function processRobotMoveArea(line) {
    var realValueStr = "";
        for( var i = 0; i < line.length; i ++ )
        {
            var curChar = line[i];
            if( curChar > '4' )
            {
                realValueStr += curChar - 1;
            }else
            {
                realValueStr += curChar;
            }
        }
        var realValue = 0;
        for( var i = 0; i < realValueStr.length; i ++ )
        {
            realValue *= 9;
            realValue += ( realValueStr[i] - '0') ;
        }
    console.log(realValue);
}

代码OJ评判结果

通过测试点

代码讲解

Python题解代码解析：

函数定义：
- calculate_actual_cost(surface_reading): 定义了一个计算实际费用的函数，接收表面读数 surface_reading 作为参数。
变量初始化：
- actual_cost = 0: 初始化实际费用为0。
- surface_reading_str = str(surface_reading): 将表面读数转换为字符串，以便按位处理数字。
循环遍历每一位数字：
- for i in range(len(surface_reading_str)): 遍历表面读数的每一位数字，从高位到低位。
- digit = int(surface_reading_str[i]): 获取当前位的数字。
处理数字4的情况：
- if digit == 4: continue: 如果当前位数字是4，则直接跳过。
处理大于4的数字：
- elif digit > 4: digit -= 1: 如果当前位数字大于4，则减一。
计算实际费用：
- actual_cost += digit * (9 ** (len(surface_reading_str) - i - 1)): 计算当前位数对应的实际费用，并累加到总费用中。
返回结果：
- return actual_cost: 返回实际产生的费用。
输入获取和结果输出：
- surface_reading = int(input()): 获取输入的表面读数。
- print(calculate_actual_cost(surface_reading)): 计算实际产生的费用并输出结果。

JAVA题解代码解析：

导入包和主函数：
- import java.util.Scanner;: 导入Scanner类。
- public class ReliableCar {: 定义类名为ReliableCar。
主函数处理输入：
- Scanner sc = new Scanner(System.in);: 创建Scanner对象用于接收输入。
- while (sc.hasNext()) {: 循环读取输入。
- String line = sc.nextLine();: 读取一行输入。
处理每个字符：
- for( int i = 0; i < line.length(); i ++ ): 遍历输入的每个字符。
- char curChar = line.charAt( i );: 获取当前字符。
- if( curChar > '4' ) { sb.append( (char) ( curChar - 1 ) ); }: 如果当前字符大于4，则将字符减一后追加到结果字符串中。
- else { sb.append( curChar ); }: 否则直接追加当前字符。
计算实际费用：
- String realValueStr = sb.toString();: 将结果字符串转换为字符串。
- int realValue = 0;: 初始化实际费用为0。
- for( int i = 0; i < realValueStr.length(); i ++ ): 遍历每个字符。
- realValue *= 9; realValue += ( realValueStr.charAt(i) - '0') ;: 计算实际费用。
输出结果：
- System.out.println( realValue );: 输出实际费用。

C/C++题解代码解析：

包含头文件和主函数：
- #include<iostream>: 包含输入输出流头文件。
- int result(int val) {: 定义计算实际费用的函数。
函数实现：
- int tmp = 0, j = 0, i = 1;: 初始化临时变量和权重变量。
- while (val > 0) {: 循环处理每个数字。
- if (val % 10 > 4) { tmp += ((val % 10) - 1) * j + i; }: 如果当前数字大于4，则将数字减一后加到临时变量中。
- else { tmp += (val % 10) * j; }: 否则直接加到临时变量中。
- val /= 10; j = j * 9 + i; i *= 10;: 更新数字和权重。
- return m - tmp;: 返回实际费用。
主函数：
- int main() { int val; cin >> val; cout << result(val) << endl; return 0; }: 读取输入，调用函数计算实际费用，输出结果。

JS题解代码解析：

导入readline模块：
- const rl = require("readline").createInterface({ input: process.stdin });: 使用readline模块创建接口。
异步循环处理输入：
- void async function() { while (line = await readline()) { processRobotMoveArea(line); } }();: 异步循环读取输入，并调用处理函数。
处理每个字符：
- for( var i = 0; i < line.length; i ++ ): 遍历输入的每个字符。
- var curChar = line[i];: 获取当前字符。
- if( curChar > '4' ) { realValueStr += curChar - 1; }: 如果当前字符大于4，则将字符减一后追加到结果字符串中。
- else { realValueStr += curChar; }: 否则直接追加当前字符。
计算实际费用：
- var realValue = 0;: 初始化实际费用为0。
- for( var i = 0; i < realValueStr.length; i ++ ): 遍历每个字符。
- realValue *= 9; realValue += ( realValueStr[i] - '0') ;: 计算实际费用。
输出结果：
- console.log(realValue);: 输出实际费用。