我要招人

去企业版

首页 > 试题广场 >

四则运算

[编程题]四则运算

热度指数：122401 时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32M，其他语言64M
算法知识视频讲解

输入一个表达式（用字符串表示），求这个表达式的值。

保证字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。且表达式一定合法。

数据范围：表达式计算结果和过程中满足 $|val| \le 1000 \$ ，字符串长度满足 $1 \le n \le 1000 \$

输入描述:

输入一个算术表达式

输出描述:

得到计算结果

示例1

输入

3+2*{1+2*[-4/(8-6)+7]}

输出

算法知识视频讲解

Javascript_V8

独孤剑走偏锋

const str = readline().replace(/(\[|{)/g, '(').replace(/(]|})/g, ')')
print(eval(str))

发表于 2022-07-10 23:14:16 回复(0)

Javascript_V8

快乐小达

let str = readline().trim()
while (str.includes("{")) {
str = str.replace("{", "(").replace("}", ")")
}
while (str.includes("]")) {
str = str.replace("]", ")").replace("[", "(")
}
console.log(eval(str));

发表于 2022-06-27 19:50:13 回复(0)

Javascript_V8

不系之舟1027

一行代码

console.log(eval(readline().replace(/[\[\{]/g,'(').replace(/[\]\}]/g,')')))

发表于 2022-03-11 15:03:25 回复(0)

Javascript_V8

sirokuma2024

const line = readline();
let string = line.replace(/[\{\}\[\]]/g, (match) => {
    switch (match) {
        case "{" : return "(";
        case "}" : return ")";
        case "[" : return "(";
        case "]" : return ")";
    }
});
let rightIndex = string.indexOf(")");
while (rightIndex !== -1) {
    const leftIndex = string.lastIndexOf("(", rightIndex);
    const expression = string.slice(leftIndex + 1, rightIndex);
    const result = calculate(expression);
    string = string.slice(0, leftIndex) + result + string.slice(rightIndex + 1);
    rightIndex = string.indexOf(")");
}
console.log(calculate(string));

function calculate(expression) {
    const arr = expression.match(/([\+-]?[0-9]+)|[\*\/]/g);
    let multiple = true;
    let result = 0;
    while (multiple) {
        const index = arr.findIndex(element => element === "*" || element === "/");
        if (index !== -1) {
            const num1 = parseInt(arr[index - 1], 10);
            const num2 = parseInt(arr[index + 1], 10);
            const mark = arr[index];
            if (mark === "*") {
                result = num1 * num2;
            } else {
                result = num1 / num2;
            }
            arr.splice(index - 1, 3, result);
        } else {
            multiple = false;
        }
    }
    result = 0;
    for (const num of arr) {
        result = result + parseInt(num, 10);
    }
    return result;
}

发表于 2022-02-11 16:48:45 回复(0)

Javascript_V8

超早起的鸟

while (line = readline()) {
let lines=line.replace(/{/g,'(').replace(/}/g,')');
print(eval(lines));
}

发表于 2021-09-23 00:14:31 回复(1)

Javascript_V8

olinlee

let line = readline();

let numberS = [];

let signS = [];

let idx = 0;

let temp = '';

const BLOCK = /[\{\[\(]/;

while(true){

const char = line[idx];

if(char === undefined){

if(temp){

numberS.push(+temp);

temp = '';

}

const top = signS.slice(-1)[0];

handleFirst(top)

break;

}

if(/\d/.test(char)){

temp += char;

}else{

if(temp){

numberS.push(+temp);

temp = '';

}

if(char === '+' || char === '-'){

if(numberS.length !== (signS.filter(v=>!BLOCK.test(v)).length+1)){

numberS.push(0)

}

const top = signS.slice(-1)[0];

handleFirst(top);

signS.push(char);

}else if(char === '\}' || char === '\]' || char === '\)'){

const top = signS.slice(-1)[0];

handleFirst(top);

signS.pop();

}else{

signS.push(char);

}

idx++;

}

print(numberS[0]);

function handleFirst(top){

if(top === '*' || top === '/' || top === '+'|| top === '-'){

const res = com(numberS.pop(),numberS.pop(),signS.pop());

// print(res)

numberS.push(res);

handleFirst(signS.slice(-1)[0]);

}else{

return;

}

function com(num1,num2,sign){

switch(sign){

case '*': return (+num2) * (+num1);

case '/': return (+num2) / (+num1);

case '+': return (+num2) + (+num1);

case '-': return (+num2) - (+num1);

}

发表于 2021-08-28 20:38:16 回复(0)

Javascript_V8

邓洲201731104108

个人最垃圾的解法（非递归）

对不同的括号分开判断，然后还要判断是否多位数，还要判断负数（如果是负数要变成负数并删除前一个减号，非负数则变成负数并删除减号换成加号）。

一轮字符串解析后，再循环符号栈找出 */ 进行优先运算。

之后再循环一遍符号栈从左至右完成加减运算（实际上只有加运算，减号都被替换成加号和负数了）。

解是解出来来了，还好我这暴脾气差点没删掉所有代码。

let str = readline();
let sstack = [];
let nstack = [];

for(let i=0;i<str.length;i++){
    //当是0-9数字时
    if(str[i].match(/[0-9]/)){
        //如果是负数
        if(ifNG()){
            sstack.pop();
//             console.log("有一个负数:"+parseInt(str[i]))
            nstack.push(0-parseInt(str[i]))
        }else if(str[i-1]=='-'){
            //如果前面是-，但不是负数，那么转化为+负数
            sstack.pop();
            sstack.push("+");
            nstack.push(0-parseInt(str[i]))
        }else{
            nstack.push(str[i])
        }
        //再判断是否为多位数(十百千万),通过判断前一位是否是数字
        if(str[i-1] && str[i-1].match(/[0-9]/)){
            let digit = parseInt(nstack.pop());
            let decade = parseInt(nstack.pop());
            nstack.push(decade*10 + digit)
        }
    }
    //当是+-/*时
    if(str[i].match(/[\+\-\*\/]/)){
//         console.log(str[i])
        if((sstack[sstack.length-1]=="*" || sstack[sstack.length-1] == "/")){
            //当遇到栈顶是最高运算符*/，那么就先将栈顶元素出栈并计算，然后再将该元素入栈。
            let sym = sstack.pop();
            let num2 = parseInt(nstack.pop());    //操作数
            let num1 = parseInt(nstack.pop());    //被操作数
            nstack.push(compute(num1,num2,sym))
        }
        sstack.push(str[i])
//         console.log(sstack+'==========')
    }
    //当是左括号时
    if(str[i].match(/[\{\[\(]/)){
        sstack.push(str[i])
    }
    //当是右括号(分开判断)
    if(str[i]==")"){
        clean("(")
    }
    if(str[i]=="]"){
        clean("[")
    }
    if(str[i]=="}"){
        clean("{")
    }
}

//当循环结束，先从左至右遍历sstack找出乘除进行运算
if(sstack.indexOf("*")!=-1 || sstack.indexOf("/")!=-1){
    let sLen = sstack.length;
for(let i=0; i<sLen; i++){
    let sym = sstack.shift();
    if(sym=='*' || sym=='/'){
        let num1 = parseInt(nstack.shift());    //被操作数
        let num2 = parseInt(nstack.shift());    //操作数
        nstack.push(compute(num1,num2,sym));
    }else{
        //否则推到栈顶继续判断下一个
        nstack.push(nstack.shift());
        sstack.push(sym);
    }
}
}

//当循环结束，此时乘除都没了
while(sstack.length!=0){
    let sym = sstack.shift();
    let num1 = parseInt(nstack.shift());    //被操作数
    let num2 = parseInt(nstack.shift());    //操作数
    nstack.unshift(compute(num1,num2,sym))
}
//输出结果，为数据栈仅剩的一个数字
console.log(nstack[0])

function clean(leftSym){
//     console.log("括号"+sstack)
    let sym;
        while((sym = sstack.pop()) && (sym != leftSym)){
//             console.log(sym)
            let num2 = parseInt(nstack.pop());    //操作数
            let num1 = parseInt(nstack.pop());    //被操作数
            nstack.push(compute(num1,num2,sym))
        }
}

function compute(num1,num2,sym){
    if(sym=="*"){
//         console.log(num1+"*"+num2+"="+(num1*num2))
        return num1*num2;
    }else if(sym=="/"){
//         console.log(num1+"/"+num2+"="+(num1/num2))
        return num1/num2;
    }else if(sym=="+"){
//         console.log(num1+"+"+num2+"="+(num1+num2))
        return num1+num2;
    }else if(sym=="-"){
//         console.log(num1+"-"+num2+"="+(num1-num2))
        return num1-num2;
    }
}

//负数判断，如果去掉左括号，符号栈的length和数字栈的length一样大，那么该数为负数
function ifNG(){
    //只有当栈顶为-才判断
    if(sstack[sstack.length-1]!="-") return false;
            let leftS = 0;
            for(let i=0;i<sstack.length;i++){
                if(sstack[i]=="{" || sstack[i]=="[" || sstack[i]=="("){
                    leftS++;
                }
            }
            let sLen = sstack.length - leftS;
            if(sLen==nstack.length+1){
                //如果运算符比数字还多一位，那么铁定是负数了
                return true;
            }
}

发表于 2021-07-19 02:31:19 回复(0)