返回目录

题目描述

程序员小明打了一辆出租车去上班。出于职业敏感，他注意到这辆出租车的计费表有点问题，总是偏大。

出租车司机解释说他不喜欢数字4，所以改装了计费表，任何数字位置遇到数字4就直接跳过，其余功能都正常。

比如：

1. 23再多一块钱就变为25；
2. 39再多一块钱变为50；
3. 399再多一块钱变为500；

小明识破了司机的伎俩，准备利用自己的学识打败司机的阴谋。

给出计费表的表面读数，返回实际产生的费用。

输入描述

只有一行，数字N，表示里程表的读数。

(1<=N<=888888888)。

输出描述

一个数字，表示实际产生的费用。以回车结束。

解题思路

我们需要理解出租车司机改装计费表的方式。司机不喜欢数字4，所以他的计费表从1开始计数，直到3，然后跳过4，继续从5计数。这意味着计费表上的每一位数字实际上只有9种可能的值：0, 1, 2, 3, 5, 6, 7, 8, 9（跳过了4）。因此，这个计费表实际上是在使用一个基数为9的数制系统。

现在，让我们用三个用例来解释这个过程：

1. 输入：5
   输出：4
   解释：由于计费表跳过了数字4，所以表面读数5实际上是9进制中的5。在10进制中，这是4。
2. 输入：17
   输出：15
   解释：表面读数17在9进制中表示为1 ∗ 9 1 1 * 9^11∗91 + 7 ∗ 9 0 7*9^07∗90。但是，因为我们跳过了4，所以实际的计算应该是1 ∗ 9 1 + 6 ∗ 9 0 1*9^1 + 6*9^01∗91+6∗90（因为7实际上是8，但我们要减去1以补偿跳过的4），这等于9 + 6 = 15。
3. 输入：100
   输出：81
   解释：表面读数100在9进制中表示为1 ∗ 9 2 + 0 ∗ 9 1 + 0 ∗ 9 0 1*9^2 + 0*9^1 + 0*9^01∗92+0∗91+0∗90。在10进制中，这等于81。

因此，通过将表面读数视为9进制数，并将其转换为10进制数，同时考虑到跳过的4，我们可以得到实际产生的费用。这就是为什么我们使用9进制进行求解的原因。

在这个特殊的9进制系统中，我们跳过了数字4，所以当我们看到特殊9进制数15时，实际上是指真实9进制数13，它对应于10进制中的13（19^1 + 49^0）。注意，在这个系统中，我们将特殊9进制数转换为真实9进制数时，需要将每个大于4的数字减去1来得到真实的9进制数，然后再将其转换为10进制数。

Python算法源码

# 读取输入的表面读数
line = input()

# 初始化实际产生的费用
correct = 0

# 遍历读数的每一位数字
for c in line:
    digit = int(c) - int('0')  # 将字符转换为数字
    if digit > 4:  # 如果数字大于4，则需要减1
        digit -= 1
    correct = correct * 9 + digit  # 将每一位数字加入到实际产生的费用中

# 输出实际产生的费用
print(correct)

C算法源码

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

int getResult(int arr[], int length) {
    int correct = 0;

    for (int i = 0; i < length; i++) {
        int fault = arr[i];
        // 如果本位数比4大，则相当于跳过1次，则需要将本位数-1
        if (fault > 4) {
            fault--;
        }

        // 将本位转成十进制
        for (int j = length - i - 1; j > 0; j--) {
            fault *= 9;
        }

        // 累加各位对应十进制数
        correct += fault;
    }

    return correct;
}

int main() {
    char line[100]; // 假设输入行长度小于100个字符
    printf("请输入数字: ");
    fgets(line, sizeof(line), stdin);

    int length = strlen(line) - 1; // 排除换行符
    int arr[length];
  
    // 将字符转换为整数
    for (int i = 0; i < length; i++) {
        arr[i] = line[i] - '0';
    }

    int result = getResult(arr, length);
    printf("%d\n", result);

    return 0;
}

Java算法源码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] nums = new int[10];
        int numsSize = 0;

        // 将输入的数字转换为数组
        while (n > 0) {
            nums[numsSize++] = n % 10;
            n /= 10;
        }

        // 对数组进行翻转
        int l = 0;
        int r = numsSize - 1;

        while (l < r) {
            int tmp = nums[l];
            nums[l] = nums[r];
            nums[r] = tmp;

            l++;
            r--;
        }

        // 调用 getResult 方法计算结果并输出
        System.out.println(getResult(nums, numsSize));
    }

    // 计算结果的方法
    public static int getResult(int[] nums, int numsSize) {
        int correct = 0;

        // 对每个数字根据规则进行修正
        for (int i = 0; i < numsSize; i++) {
            int fault = nums[i];
            if (fault > 4) fault--;

            // 将数字转换成十进制
            for (int j = numsSize - i - 1; j > 0; j--) {
                fault *= 9;
            }

            // 累加修正后的数字
            correct += fault;
        }

        return correct;
    }
}