返回目录

题目描述

已知火星人使用的运算符为#、$，其与地球人的等价公式如下：

• x#y = 4x+3y+2
• x$y = 2*x+y+3

1. 其中 x、y 是无符号整数
2. 地球人公式按C语言规则计算
3. 火星人公式中，#的优先级高于$，相同的运算符，按从左到右的顺序计算

现有一段火星人的字符串报文，请你来翻译并计算结果。

输入描述

火星人字符串表达式（结尾不带回车换行）

输入的字符串说明： 字符串为仅由无符号整数和操作符（#、$）组成的计算表达式。例如：

123#4$5#67$78

1. 用例保证字符串中，操作数与操作符之间没有任何分隔符。
2. 用例保证操作数取值范围为32位无符号整数。
3. 保证输入以及计算结果不会出现整型溢出。
4. 保证输入的字符串为合法的求值报文，例如：123#4$5#67$78

5. 保证不会出现非法的求值报文，例如类似这样字符串：

   4$5 //缺少操作数

   4$5# //缺少操作数
   4#$5 //缺少操作数
   4 $5 //有空格
   3+4-5*6/7 //有其它操作符
   12345678987654321$54321 //32位整数计算溢出

输出描述

根据输入的火星人字符串输出计算结果（结尾不带回车换行）

示例：

Python算法源码

import re

# 处理字符串中的指定操作符
def process_operations(input_str, operator_regex):
    pattern = re.compile(r'(\d+)' + operator_regex + r'(\d+)')
  
    # 循环处理字符串中所有匹配的操作符
    while True:
        match = re.search(pattern, input_str)
        if not match:
            break
      
        # 从匹配结果中提取两个操作数
        a = int(match.group(1))
        b = int(match.group(2))
      
        # 根据操作符计算结果
        result = 4 * a + 3 * b + 2 if operator_regex == '#' else 2 * a + b + 3
      
        # 将匹配到的表达式替换为计算结果
        input_str = input_str[:match.start()] + str(result) + input_str[match.end():]
  
    # 返回处理后的字符串
    return input_str

# 计算火星文本表达式的值
def calculate(input_str):
    # 处理所有的 '#' 操作
    input_str = process_operations(input_str, '#')
    # 处理所有的 '$' 操作
    input_str = process_operations(input_str, '\\$')
    # 将最终的字符串转换为长整型数字并返回
    return int(input_str)

# 主函数
def main():
    # 提示用户输入数据
    input_str = input()
    # 计算并输出结果
    print(calculate(input_str))

if __name__ == "__main__":
    main()

C算法源码

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

// 定义火星运算符的函数
long long marsHash(long long x, long long y) {
    return 4 * x + 3 * y + 2; // 实现 x#y = 4*x + 3*y + 2
}

long long marsDollar(long long x, long long y) {
    return 2 * x + y + 3; // 实现 x$y = 2*x + y + 3
}

// 结构体
typedef struct {
    char expression[10000]; // 输入表达式的缓冲区
    long long nums[5000]; // 存储数字的数组
    int numIndex; // 数字数组的索引
    char ops[5000]; // 存储操作符的数组
    int opIndex; // 操作符数组的索引
    unsigned long long num; // 用于累积当前数字的变量，使用 unsigned long long
    bool readingNumber; // 标志，指示我们当前是否正在读取数字
} ExpressionParser;

// 用于初始化表达式解析器
void initializeParser(ExpressionParser *parser) {
    parser->numIndex = 0;
    parser->opIndex = 0;
    parser->num = 0;
    parser->readingNumber = false;
}

// 用于解析火星表达式
void parseExpression(ExpressionParser *parser) {
    int i = 0;
    while (parser->expression[i] != '\0') {
        if (parser->expression[i] >= '0' && parser->expression[i] <= '9') {
            parser->num = parser->num * 10 + (parser->expression[i] - '0');
            parser->readingNumber = true;
        } else {
            if (parser->readingNumber) {
                parser->nums[parser->numIndex++] = parser->num;
                parser->num = 0;
            }
            parser->readingNumber = false;
            parser->ops[parser->opIndex++] = parser->expression[i];
        }
        i++;
    }
    if (parser->readingNumber) {
        parser->nums[parser->numIndex++] = parser->num;
    }
}

int main() {
    ExpressionParser parser; // 创建表达式解析器
    initializeParser(&parser); // 初始化解析器

    scanf("%s", parser.expression); // 读取火星表达式
    parseExpression(&parser); // 解析表达式

    // 首先处理所有 '#' 操作
    int i = 0;
    while (i < parser.opIndex) {
        if (parser.ops[i] == '#') {
            parser.nums[i] = marsHash(parser.nums[i], parser.nums[i + 1]);
            for (int j = i + 1; j < parser.numIndex - 1; ++j) {
                parser.nums[j] = parser.nums[j + 1];
            }
            for (int j = i; j < parser.opIndex - 1; ++j) {
                parser.ops[j] = parser.ops[j + 1];
            }
            parser.numIndex--;
            parser.opIndex--;
        } else {
            i++;
        }
    }

    // 接下来处理所有 '$' 操作
    long long result = parser.nums[0];
    for (i = 0; i < parser.opIndex; ++i) {
        if (parser.ops[i] == '$') {
            result = marsDollar(result, parser.nums[i + 1]);
        }
    }

    printf("%lld\n", result); // 输出结果
    return 0;
}

Java算法源码

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取用户输入的每一行，并进行处理
        while (scanner.hasNextLine()) {
            String input = scanner.nextLine();
            System.out.println(calculate(input));
        }

        scanner.close();
    }

    // 计算火星文本表达式的值
    public static String calculate(String input) {
        // 处理 '#' 操作
        input = processOperations(input, "#");
        // 处理 '$' 操作
        input = processOperations(input, "\\$");
        return input;
    }

    // 处理特定操作符的方法
    public static String processOperations(String input, String operator) {
        // 构建正则表达式模式，用于匹配操作符及其周围的数字
        Pattern pattern = Pattern.compile("(\\d+)" + operator + "(\\d+)");
        Matcher matcher;
        String prevInput;

        do {
            prevInput = input;
            matcher = pattern.matcher(input);
            StringBuffer buffer = new StringBuffer();

            // 逐个匹配并处理操作符
            while (matcher.find()) {
                long a = Long.parseLong(matcher.group(1));
                long b = Long.parseLong(matcher.group(2));
                // 根据操作符计算结果
                long result = operator.equals("#") ? 4 * a + 3 * b + 2 : 2 * a + b + 3;
                matcher.appendReplacement(buffer, Long.toString(result));
            }

            // 将剩余部分添加到结果中
            matcher.appendTail(buffer);
            input = buffer.toString();

        } while (!prevInput.equals(input)); // 若处理后的字符串与原始字符串不同，则继续处理

        return input;
    }
}