华为OD机试-提取字符串中的最长数学表达式（Java 2024 D卷 100分）

最新推荐文章于 2025-08-17 21:40:23 发布

原创最新推荐文章于 2025-08-17 21:40:23 发布 · 71 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#华为OD #机试 #算法 #Java #Python #C++ #JavaScript

华为OD机试专栏收录该内容

105 篇文章

订阅专栏

题目描述

我们需要从给定的字符串中提取最长的合法简单数学表达式，并计算该表达式的值。如果字符串中没有合法的数学表达式，则返回0。合法的简单数学表达式只能包含数字（0-9）和符号（+、-、*）。表达式必须是最长的且合法的，操作符不能连续出现。

输入描述

输入为一个字符串。

输出描述

输出为表达式的值。

解题思路

遍历字符串：我们需要遍历字符串，寻找所有可能的合法表达式。
合法性检查：在遍历过程中，检查当前字符是否可以构成合法表达式的一部分。操作符不能连续出现。
记录最长表达式：记录下最长的合法表达式，并计算其值。
返回结果：返回最长表达式的值，如果没有合法表达式，则返回0。

代码实现

Java

import java.util.Stack;

public class Solution {
    public long longestExpression(String s) {
        long maxVal = 0;
        String maxExp = "";
        for (int i = 0; i < s.length(); i++) {
            for (int j = i + 1; j <= s.length(); j++) {
                String substr = s.substring(i, j);
                if (isValidExpression(substr)) {
                    if (substr.length() > maxExp.length()) {
                        maxExp = substr;
                        maxVal = evaluateExpression(substr);
                    }
                }
            }
        }
        return maxVal;
    }

    private boolean isValidExpression(String s) {
        if (s.isEmpty()) return false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (!Character.isDigit(c) && c != '+' && c != '-' && c != '*') {
                return false;
            }
            if (i > 0 && !Character.isDigit(s.charAt(i - 1)) {
                if (!Character.isDigit(c)) {
                    return false;
                }
            }
        }
        return true;
    }

    private long evaluateExpression(String s) {
        Stack<Long> numbers = new Stack<>();
        Stack<Character> operators = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isDigit(c)) {
                long num = 0;
                while (i < s.length() && Character.isDigit(s.charAt(i))) {
                    num = num * 10 + (s.charAt(i) - '0');
                    i++;
                }
                i--;
                numbers.push(num);
            } else if (c == '+' || c == '-' || c == '*') {
                while (!operators.isEmpty() && precedence(operators.peek()) >= precedence(c)) {
                    numbers.push(applyOp(operators.pop(), numbers.pop(), numbers.pop()));
                }
                operators.push(c);
            }
        }
        while (!operators.isEmpty()) {
            numbers.push(applyOp(operators.pop(), numbers.pop(), numbers.pop()));
        }
        return numbers.pop();
    }

    private int precedence(char op) {
        if (op == '+' || op == '-') return 1;
        if (op == '*') return 2;
        return 0;
    }

    private long applyOp(char op, long b, long a) {
        switch (op) {
            case '+': return a + b;
            case '-': return a - b;
            case '*': return a * b;
        }
        return 0;
    }
}

Python

def longest_expression(s):
    def is_valid_expression(expr):
        if not expr:
            return False
        for i, char in enumerate(expr):
            if not char.isdigit() and char not in {'+', '-', '*'}:
                return False
            if i > 0 and not expr[i-1].isdigit():
                if not char.isdigit():
                    return False
        return True

    def evaluate_expression(expr):
        stack = []
        num = 0
        sign = '+'
        for i in range(len(expr)):
            if expr[i].isdigit():
                num = num * 10 + int(expr[i])
            if not expr[i].isdigit() or i == len(expr) - 1:
                if sign == '+':
                    stack.append(num)
                elif sign == '-':
                    stack.append(-num)
                elif sign == '*':
                    stack.append(stack.pop() * num)
                sign = expr[i]
                num = 0
        return sum(stack)

    max_val = 0
    max_exp = ""
    for i in range(len(s)):
        for j in range(i + 1, len(s) + 1):
            substr = s[i:j]
            if is_valid_expression(substr):
                if len(substr) > len(max_exp):
                    max_exp = substr
                    max_val = evaluate_expression(substr)
    return max_val

C++

#include <string>
#include <stack>
#include <algorithm>

using namespace std;

class Solution {
public:
    long longestExpression(string s) {
        long maxVal = 0;
        string maxExp = "";
        for (size_t i = 0; i < s.length(); ++i) {
            for (size_t j = i + 1; j <= s.length(); ++j) {
                string substr = s.substr(i, j - i);
                if (isValidExpression(substr)) {
                    if (substr.length() > maxExp.length()) {
                        maxExp = substr;
                        maxVal = evaluateExpression(substr);
                    }
                }
            }
        }
        return maxVal;
    }

private:
    bool isValidExpression(const string& s) {
        if (s.empty()) return false;
        for (size_t i = 0; i < s.length(); ++i) {
            char c = s[i];
            if (!isdigit(c) && c != '+' && c != '-' && c != '*') {
                return false;
            }
            if (i > 0 && !isdigit(s[i - 1])) {
                if (!isdigit(c)) {
                    return false;
                }
            }
        }
        return true;
    }

    long evaluateExpression(const string& s) {
        stack<long> numbers;
        stack<char> operators;
        for (size_t i = 0; i < s.length(); ++i) {
            char c = s[i];
            if (isdigit(c)) {
                long num = 0;
                while (i < s.length() && isdigit(s[i])) {
                    num = num * 10 + (s[i] - '0');
                    ++i;
                }
                --i;
                numbers.push(num);
            } else if (c == '+' || c == '-' || c == '*') {
                while (!operators.empty() && precedence(operators.top()) >= precedence(c)) {
                    numbers.push(applyOp(operators.top(), numbers.top()));
                    operators.pop();
                    numbers.pop();
                }
                operators.push(c);
            }
        }
        while (!operators.empty()) {
            numbers.push(applyOp(operators.top(), numbers.top()));
            operators.pop();
            numbers.pop();
        }
        return numbers.top();
    }

    int precedence(char op) {
        if (op == '+' || op == '-') return 1;
        if (op == '*') return 2;
        return 0;
    }

    long applyOp(char op, long b, long a) {
        switch (op) {
            case '+': return a + b;
            case '-': return a - b;
            case '*': return a * b;
        }
        return 0;
    }
};

JavaScript

function longestExpression(s) {
    function isValidExpression(expr) {
        if (!expr) return false;
        for (let i = 0; i < expr.length; i++) {
            const char = expr[i];
            if (!/\d/.test(char) && !['+', '-', '*'].includes(char)) {
                return false;
            }
            if (i > 0 && !/\d/.test(expr[i - 1])) {
                if (!/\d/.test(char)) {
                    return false;
                }
            }
        }
        return true;
    }

    function evaluateExpression(expr) {
        const stack = [];
        let num = 0;
        let sign = '+';
        for (let i = 0; i < expr.length; i++) {
            if (/\d/.test(expr[i])) {
                num = num * 10 + parseInt(expr[i]);
            }
            if (!/\d/.test(expr[i]) || i === expr.length - 1) {
                if (sign === '+') {
                    stack.push(num);
                } else if (sign === '-') {
                    stack.push(-num);
                } else if (sign === '*') {
                    stack.push(stack.pop() * num);
                }
                sign = expr[i];
                num = 0;
            }
        }
        return stack.reduce((a, b) => a + b, 0);
    }

    let maxVal = 0;
    let maxExp = "";
    for (let i = 0; i < s.length; i++) {
        for (let j = i + 1; j <= s.length; j++) {
            const substr = s.substring(i, j);
            if (isValidExpression(substr)) {
                if (substr.length > maxExp.length) {
                    maxExp = substr;
                    maxVal = evaluateExpression(substr);
                }
            }
        }
    }
    return maxVal;
}