[编程题] 四则运算

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了[编程题] 四则运算，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11617字，纯文字阅读大概需要17分钟。

内容图文

[编程题] 四则运算

题目描述

请实现如下接口

/* 功能：四则运算
* 输入：strExpression：字符串格式的算术表达式，如: "3+2*{1+2*[-4/(8-6)+7]}"
* 返回：算术表达式的计算结果
*/

public static int calculate(String strExpression)
{
    /* 请实现*/
    return 0;
}

约束：

pucExpression字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。
pucExpression算术表达式的有效性由调用者保证;

输入描述:

输入一个算术表达式

输出描述:

得到计算结果

输入例子1:

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

输出例子1:

个人方法(python)

# !/usr/bin/env python2
# -*- coding:utf-8 -*-

opts = '+-*/()[]{}'
Wopt = {'(':0,'[':1,'{':2,'+':3,'-':3, '*':4, '/':4}

# 字符串 转 中缀表达式(infix)  ： str->list
# 目的为了 分离 多位的整数、负数以及运算符
def str2infix(line):
    infix = []
    numtmp = ''
    for ch in line:
        if ch not in opts:
            numtmp += ch
        else:
            if ch == '-':  # 分离负数
                if len(infix) != 0:
                    if infix[-1] in "([{" and numtmp=='':
                        numtmp += ch
                        continue
            if numtmp != '':
                infix.append(numtmp)
                numtmp = ''
            infix.append(ch)

    if numtmp != '':
        infix.append(numtmp)

    return infix
# 中缀表达式(infix) 转 后缀表达式(posfix)
def infix2posfix(infix):
    posfix = []
    oprtmp = []
    for v in infix:
        if v not in opts:
            posfix.append(v)
        else:
            if len(oprtmp) == 0:
                oprtmp.append(v)
            elif v in '([{':
                oprtmp.append(v)
            elif v in ')]}':
                while True:
                    ele = oprtmp.pop()
                    if ele in '([{':
                        break
                    # posfix.append(ele)
                    # if Wopt[ele] < Wopt[oprtmp[-1]]:
                    posfix.append(ele)
                        # break

            elif Wopt[v] <= Wopt[oprtmp[-1]]:
                while Wopt[v] <= Wopt[oprtmp[-1]]:
                    posfix.append(oprtmp.pop())
                    if len(oprtmp) == 0:
                        break
                oprtmp.append(v)
            else:
                oprtmp.append(v)

    while len(oprtmp) != 0:
        posfix.append(oprtmp.pop())
    return posfix
# 后缀表达式求值
def calculate(posfix):
    expr = []
    for ele in posfix:
        if ele in '-+/*':
            n1, n2 = expr.pop(), expr.pop()
            if ele == '+':
                expr.append(n2 + n1)
            elif ele == '-':
                expr.append(n2 - n1)
            elif ele == '*':
                expr.append(n2 * n1)
            else:
                expr.append(n2 / n1)
        else:
            expr.append(int(ele))
    return expr

# 字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。
try:
    while True:
        line = raw_input()
        # line = '3+2*{1+2*[-4/(8-6)+7]}'
        # line = '3*5+8-0*3-6+0+0'
        # line = '5-3+9*6*(6-10-2)'
        # line = '3-10+(0+(10+5+3)-10)'
        if line=='':
            break

        infix = str2infix(line)
        posfix = infix2posfix(infix)
        # print infix
        # print posfix
        print calculate(posfix)[0]
        # break
except:
    pass

优秀解析

1. Python一行代码（py2,py3）

# python2
print(int(eval(raw_input().replace("{","(").replace("}",")").replace("[","(").replace("]",")"))))
# python3
print(int(eval(input().replace("{","(").replace("}",")").replace("[","(").replace("]",")"))))

说明：
eval字符串参数合法的字符包括”+, -, *, /, (, )”，”0-9”（没有“[]”,”{}“）

所以下面的仅仅是处理带小括号的表达式求值。同时上面也仅仅是把大、中括号替换为小括号。

# python2
print(eval(raw_input()))
# python3
print(eval(input()))

2. 传统方法，计算中缀表达式（java）

传统方法，直接通过两个栈，计算中缀表达式的值

import java.util.*;
public class Main{
    // 用于存放一个正括号的集合, 用于简化代码
    static Set<Character> brace = new HashSet<>();
    public static void main(String ... args){
        Scanner sc = new Scanner(System.in);
        // 初始化正括号集合
        brace.add('{');
        brace.add('(');
        brace.add('[');
        while(sc.hasNextLine()){
            // 对字符串做初始化处理，原则有二:
            // 1、处理负数，这里在-前面的位置加入一个0，如-4变为0-4，
            // 细节：注意-开头的地方前面一定不能是数字或者反括号，如9-0,(3-4)-5，这里地方是不能加0的
            // 它的后面可以是数字或者正括号，如-9=>0-9, -(3*3)=>0-(3*3)
            // 2、处理字符串，在最后的位置加#, 主要是为了防止最后一个整数无法处理的问题
            String exp = sc.nextLine().replaceAll("(?<![0-9)}\\]])(?=-[0-9({\\[])", "0") + "#";
            System.out.println(calculate(exp));
        }
    }
    private static int calculate(String exp){
        // 初始化栈
        Stack<Integer> opStack = new Stack<>();
        Stack<Character> otStack = new Stack<>();
         
        // 整数记录器
        String num = "";
        for(int i = 0; i < exp.length(); i++){
            // 抽取字符
            char c = exp.charAt(i);
            // 如果字符是数字，则加这个数字累加到num后面
            if(Character.isDigit(c)){
                num += c;
            }
            // 如果不是数字
            else{
                // 如果有字符串被记录，则操作数入栈，并清空
                if(!num.isEmpty()){
                    int n = Integer.parseInt(num);
                    num = "";
                    opStack.push(n);
                }
                // 如果遇上了终结符则退出
                if(c == '#')
                    break;
                // 如果遇上了+-
                else if(c == '+' || c == '-'){
                    // 空栈或者操作符栈顶遇到正括号，则入栈
                    if(otStack.isEmpty() || brace.contains(otStack.peek())){
                        otStack.push(c);
                    } else {
                        // 否则一直做弹栈计算，直到空或者遇到正括号为止，最后入栈
                        while(!otStack.isEmpty() && !brace.contains(otStack.peek()))
                            popAndCal(opStack, otStack);
                        otStack.push(c);
                    }
                }
                // 如果遇上*/
                else if(c == '*' || c == '/'){
                    // 空栈或者遇到操作符栈顶是括号，或者遇到优先级低的运算符，则入栈
                    if(otStack.isEmpty()
                            || brace.contains(otStack.peek())
                            || otStack.peek() == '+' || otStack.peek() == '-'){
                        otStack.push(c);
                    }else{
                        // 否则遇到*或/则一直做弹栈计算，直到栈顶是优先级比自己低的符号，最后入栈
                        while(!otStack.isEmpty()
                                && otStack.peek() != '+' && otStack.peek() != '-'
                                && !brace.contains(otStack.peek()))
                            popAndCal(opStack, otStack);
                        otStack.push(c);
                    }
                } else {
                    // 如果是正括号就压栈
                    if(brace.contains(c))
                        otStack.push(c);
                    else{
                        // 反括号就一直做弹栈计算，直到遇到正括号为止
                        char r = getBrace(c);
                        while(otStack.peek() != r){
                            popAndCal(opStack, otStack);
                        }
                        // 最后弹出正括号
                        otStack.pop();
                    }
                }
            }
        }
        // 将剩下的计算完，直到运算符栈为空
        while(!otStack.isEmpty())
            popAndCal(opStack, otStack);
        // 返回结果
        return opStack.pop();
    }
    private static void popAndCal(Stack<Integer> opStack, Stack<Character> otStack){
        int op2 = opStack.pop();
        int op1 = opStack.pop();
        char ot = otStack.pop();
        int res = 0;
        switch(ot){
            case '+':
                res = op1 + op2;
                break;
            case '-':
                res = op1 - op2;
                break;
            case '*':
                res = op1 * op2;
                break;
            case '/':
                res = op1 / op2;
                break;
        }
        opStack.push(res);
    }
    private static char getBrace(char brace){
        switch(brace){
            case ')':
                return '(';
            case ']':
                return '[';
            case '}':
                return '{';
        }
        return '#';
    }
}

3. 中缀字符串转变为后缀字符串数组并求解（c++）

//思路：
//1.字符串预处理，针对可能出现的“{，},[,],-”等特殊情况进行替换,判断‘-’是负号还是减号,负号前面+0，转变成减法运算
//2.将中缀字符串转变为后缀字符串数组
//3.对后缀字符串数组进行求解
#include<iostream>
#include<vector>
#include<string>
#include<stack>
#include<sstream>
using namespace std;
bool cmpPriority(char top,char cur)//比较当前字符与栈顶字符的优先级，若栈顶高，返回true
{
    if((top=='+' || top=='-') && (cur=='+' || cur=='-'))
        return true;
 if((top=='*' || top=='/') && (cur=='+' || cur=='-'|| top=='*' || top=='/'))
        return true;
    if(cur==')')
        return true;
    return false;
}
void preProcess(string &str)//对字符串进行预处理
{
    for(int i=0;i<str.size();++i)
    {
        if(str[i]=='{')//将‘{、}、[,]’替换成'()'
            str[i]='(';
        else if(str[i]=='}')
            str[i]=')';
        else if(str[i]=='[')
            str[i]='(';
        else if(str[i]==']')
            str[i]=')';
        else if(str[i]=='-')
        {
            if(i==0)//将'-'前面添加0转变成减法运算
                str.insert(0,1,'0');
            else if(str[i-1]=='(')
                str.insert(i,1,'0');
  }
 }
}
vector<string> mid2post(string &str)
{
    vector<string>vstr;
    stack<char>cstack;
    for(int i=0;i<str.size();++i)//扫描字符串
    {
        string temp="";
        if(str[i]>='0' && str[i]<='9')//若是数字
        {
            temp+=str[i];
            while(i+1<str.size() && str[i+1]>='0' && str[i+1]<='9')
            {
                temp+=str[i+1];//若是连续数字
                ++i;
   }
            vstr.push_back(temp);
  }
        else if(cstack.empty() || str[i]=='(')//若栈空或者字符为'('
            cstack.push(str[i]);
        else if(cmpPriority(cstack.top(),str[i]))//若栈顶元素优先级较高，栈顶元素出栈
        {
            if(str[i]==')')//若当前字符是右括号，栈中元素出栈，入字符串数组中，直到遇到'('
            {
                while(!cstack.empty() && cstack.top()!='(')
                {
                    temp+=cstack.top();
                    cstack.pop();
                    vstr.push_back(temp);
                    temp="";
                }
                cstack.pop();                   
            }
            else//栈中优先级高的元素出栈，入字符串数组，直到优先级低于当前字符
            {
                while(!cstack.empty() && cmpPriority(cstack.top(),str[i]))
                {
                    temp+=cstack.top();
                    cstack.pop();
                    vstr.push_back(temp);
                    temp="";
                }
                cstack.push(str[i]);
   }
        }
        else//当前字符优先级高于栈顶元素，直接入栈
         cstack.push(str[i]);
    }
    while(!cstack.empty())//栈中还存在运算符时，出栈，存入字符串数组
    {
        string temp="";
        temp+=cstack.top();
        cstack.pop();
        vstr.push_back(temp);
    }
    return vstr;
}
int calcPostExp(vector<string> & vstr)//对后缀表达式进行求值，主要是根据运算符取出两个操作数进行运算
{
    int num,op1,op2;
    stack<int>opstack;
    for(int i=0;i<vstr.size();++i)
    {
        string temp=vstr[i];
        if(temp[0]>='0' && temp[0]<='9')//如果当前字符串是数字，利用字符串流转化为int型
        {
            stringstream ss;
            ss<<temp;
            ss>>num;
            opstack.push(num);
        }
        else if(vstr[i]=="+")//若是操作符，取出两个操作数，进行运算，并将结果存入
        {
            op2=opstack.top();
            opstack.pop();
            op1=opstack.top();
            opstack.pop();
            opstack.push(op1+op2);
        }
        else if(vstr[i]=="-")
        {
            op2=opstack.top();
            opstack.pop();
            op1=opstack.top();
            opstack.pop();
            opstack.push(op1-op2);
        }
        else if(vstr[i]=="*")
        {
            op2=opstack.top();
            opstack.pop();
            op1=opstack.top();
            opstack.pop();
            opstack.push(op1*op2);
        }
        else if(vstr[i]=="/")
        {
            op2=opstack.top();
            opstack.pop();
            op1=opstack.top();
            opstack.pop();
            opstack.push(op1/op2);
        }
    }
    return opstack.top();//最终的栈顶元素就是求解的结果
}
void calcExp(string str)
{
    vector<string>vstr;
    preProcess(str);//对字符串进行预处理
    vstr=mid2post(str);//将中缀表达式转为后缀，保存在字符串数组中，方便下一步求解
    int res=calcPostExp(vstr);
    cout<<res<<endl;
}
int main()
{
    string str;
    while(getline(cin,str))
    {
        calcExp(str);
 }
    return 0;
}

3. 统一小括号，中缀表达式转后缀并求解（c++）

思路是很正常的思路

先把中括号和大括号换成小括号，方便后续处理
四则运算：中缀表达式转后缀表达式，中途计算算出后缀表达式结果

#include<iostream>
#include<string>
#include<stack>//栈头文件
using namespace std;
string change_bracket(string exp);//将大括号和中括号转成小括号，同时，将负数x转成0-x的形式
int mid_to_post(string exp);
int calculate(int a, int b, char sym);
int main()
{
    string exp;
    while (cin >> exp)
    {
        exp = change_bracket(exp);
        int exp_post = mid_to_post(exp);
        cout << exp_post << endl;
    }
    return 0;
}
//把大括号和中括号换成小括号，以便减少后期过多的判断
string change_bracket(string exp)
{
    for (int i = 0; i < exp.size(); i++)
    {
        if (exp[i] == '{' || exp[i] == '[')
            exp[i] = '(';
        if (exp[i] == '}' || exp[i] == ']')
            exp[i] = ')';
    }
     
    //cout << exp;
    return exp;
}
int mid_to_post(string exp)
{
    int flag = 0;//正负号标志，0为无正负号，1为正号，2为负号
    stack<int> exp_post;//数字栈
    stack<char> symbol;//符号栈
    for (int i = 0; i < exp.size(); i++)
    {
        char temp;
        if (isdigit(exp[i]))//为数字时
        {
            int j = i,num=0;
            while (i + 1 < exp.length() && isdigit(exp[i + 1])) i++;
            string str_num = exp.substr(j, i - j+1);
            for (int k = 0; k < str_num.size(); k++)
                num = num * 10 + str_num[k] - '0';
            if (flag == 2)
                num = 0 - num;
            flag = 0;
            exp_post.push(num);
        }  
        else if (exp[i] == '*' || exp[i] == '/' || exp[i] == '(')//为乘除时
            symbol.push(exp[i]);
        else if (exp[i] == '+'||exp[i] == '-')//为加减时
        {
            /*处理负号先*/
            if (!i || exp[i - 1]=='(')
                if (exp[i] == '+')
                    flag = 1;
                else
                    flag = 2;
 
            /*处理负号先_end*/
            while (!flag&&!symbol.empty() && symbol.top() != '(')//堆栈非空时，符号栈弹出符号，并结合数字栈计算
            {
                int b = 0, a = 0;
                char sym_temp;
                b = exp_post.top();
                exp_post.pop();
                a = exp_post.top();
                exp_post.pop();
                sym_temp = symbol.top();
                symbol.pop();
                exp_post.push(calculate(a, b, sym_temp));//计算结果入栈
            }
            if(!flag) symbol.push(exp[i]);
        }
        else if (exp[i] == ')')//为右括号时
        {
            while (symbol.top() != '(')
            {
                int b = 0, a = 0;
                char sym_temp;
                b = exp_post.top();
                exp_post.pop();
                a = exp_post.top();
                exp_post.pop();
                sym_temp = symbol.top();
                symbol.pop();
                exp_post.push(calculate(a, b, sym_temp));//计算结果入栈
            }
            symbol.pop();
        }
        else
            cout << "Input error!!!" << endl;
    }
    //循环结束后把剩下的符号弹出，并结合数字栈计算
    while (!symbol.empty())
    {
        int b = 0, a = 0;
        char sym_temp;
        b = exp_post.top();
        exp_post.pop();
        a = exp_post.top();
        exp_post.pop();
        sym_temp = symbol.top();
        symbol.pop();
        exp_post.push(calculate(a, b, sym_temp));//计算结果入栈
    }
    return exp_post.top();
}
 
int calculate(int a,int b,char sym)
{
    switch (sym)
    {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/': return a / b;
    default:
        return 0;
        break;
    }
}

参考

简单算术表达式求值 https://blog.csdn.net/dnxbjyj/article/details/71248637
首页 > 试题广场 > 四则运算 https://www.nowcoder.com/questionTerminal/9999764a61484d819056f807d2a91f1e

内容总结

以上是互联网集市为您收集整理的[编程题] 四则运算全部内容，希望文章能够帮你解决[编程题] 四则运算所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/636683.html

来源：【匿名】

【上一篇】任务2打开一个案例程序Kittenblock 【下一篇】关于IE的RegExp.exec的问题

更多 ►

【[编程题] 四则运算】教程文章相关的互联网学习教程文章

[编程题] 四则运算题目描述请实现如下接口 /* 功能：四则运算 * 输入：strExpression：字符串格式的算术表达式，如: "3+2*{1+2*[-4/(8-6)+7]}" * 返回：算术表达式的计算结果 */public static int calculate(String strExpression) {/* 请实现*/return 0; } 约束：pucExpression字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。 pucExpression算术表达式的有效性由调用...

少儿编程-教育：少儿编程教育【图】

ylbtech-少儿编程-教育：少儿编程教育 1.返回顶部 1、少儿编程教育是通过编程游戏启蒙、可视化图形编程等课程，培养学生的计算思维和创新解难能力的课程?。? 中文名：少儿编程教育外文名：kid coding受众人群：6-18岁青少年儿童类属：青少儿教育内容简介少儿编程教育并非高等教育那样学习如何写代码、编制应用程序，而是通过编程游戏启蒙、可视化图形编程等课程，培养学生的计算思维和创新解难能力。例如学生在制作一个小动画...

实验 2 用机器指令和汇编指令编程【图】

实验任务一、使用e命令修改 0021:0～0021:f数据，将连续8个字节改为30H, 31H, 32H, 33H,34H,35H,36H,37H，使用d命令查看修改后的结果使用debug，写入程序段（将 P74 实验任务(1)中第 1行的 mov ax, ffff → 改为 mov ax, 0021）将程序段写入后，可以使用r指令查看当前CS:IP使用t指令单步执行查看结果mov ax,0021mov ds,axmov ax,2200mov ss,ax【注意：此处指令 mov sp,0100被略过，原因：在执行修改ss的指令后，即此处执行mov ss,a...

雷子聊并发编程（002）：进程介绍【图】

什么是进程进程的定义是：指在系统中能独立运行并作为资源分配的基本单位，它是由一组机器指令、数据和堆栈等组成的，是一个能独立运行的活动实体。通俗直白的讲：进程是系统中正在运行的一个程序，程序一旦运行就是进程。查看进程在Windows系统中，打开QQ程序这个软件，系统就会创建一个进程，通过任务栏管理器可以方便直观的查看。如下图所示：在Linux操作系统中，执行ps -aux指令，下图所示。进程特征动态性：进程的实质是...

CS314作业代写、代做Matlab编程语言作业、代做Matlab课程设计作业、代写Matlab实验报告作业

CS314 Numerical MethodsFall 2018Homework 03Due 11:59PM, Thursday, Oct 11, 2018*** Homework must be submitted via Blackboard in PDF file format. The PDF file (i.e. the mainfile) should include Matlab code (if necessary) and also the Matlab code should be uploaded inseparate files (i.e., .m files).*** Your PDF file should be named as follows: FistnameLastnameHWxx.pdf, where xx representsthe homework...

网络编程一定要看过的socket大山

python已经可以做很多的东西了。但是要想要和别人互联互通就会涉及到一个关键的模块socket！值得一提的是，其实socket不是python独创的一种模块，而是任何语言都会有的一个部分！自己的程序和别的电脑进行连接的时候都会用到这个方式！但是，首先还是来看看网络通信的相关的知识，然后再慢慢的了解socket！其实根据不同的场景大概可以分为两种情况：C/S架构和B/S架构 C/S架构的意思就是客户端和服务端的连接方式。就像是手机上的...

PAT(乙级)1036 跟奥巴马一起编程（15 分)

美国总统奥巴马不仅呼吁所有人都学习编程，甚至以身作则编写代码，成为美国历史上首位编写计算机代码的总统。2014 年底，为庆祝“计算机科学教育周”正式启动，奥巴马编写了很简单的计算机代码：在屏幕上画一个正方形。现在你也跟他一起画吧！输入格式：输入在一行中给出正方形边长 N（3≤N≤20）和组成正方形边的某种字符 C，间隔一个空格。输出格式：输出由给定字符 C 画出的正方形。但是注意到行间距比列间距大，所以为了让...

网络编程1【图】

目录网络架构及其演变过程单机架构 CS架构 BS架构 BS架构和CS架构的区别 C/S架构的优缺点： B/S架构的优缺点：互联网与互联网的组成互联网的组成（教科书版）互联网的组成（科普版）OSI七层协议物理层数据链路层以太网协议 Mac地址广播地址网络层传输层应用层Socket抽象层 Socket抽象层网络架构及其演变过程单机架构单机：顾名思义，就是不需要进行联网操作应用领域俄罗斯方块连连看CS架构CS架构：C--client--客户端，...

面向对象编程之封装【代码】

面向对象编程之封装一、封装的原则举例说明：类似于电视机，把所有的东西都封装起来，只展示显示屏，封装一般对结构的属性进行封装，使用方法和包的方式进行封装（摘抄：https://blog.csdn.net/flyfeifei66/article/details/81532261） 1、单一职责原则最重要的原则，见名知意。单一职责，强调的是职责的分离，一个方法只干一件事情，只因为一个原因做修改。很多代码之所以需要重构，因为有职责扩散。所谓职责扩散，就是因为某...

泛型编程与STL学习笔记之容器

泛型编程与STL学习笔记之容器 C++ STL定义两种大小可变的 containers : Sequence Container和Associative Container。 1，Sequence 是Forward Container的一个强化（Refinement），是一种最明显的大小可变的container。就像所有的containers一样，Sequence 以严格线性序列的range来呈现其元素。此外，你不但可以取用任何元素，也可以在range的任意一个地点新增或删除元素。也就是说，Sequence不会以某种规定来排列元素，它让你依照...

PTA基础编程题目7-8超速判断【代码】

PTA基础编程题目7-8 题目 7-8 超速判断 (10分) 模拟交通警察的雷达测速仪。输入汽车速度，如果速度超出60 mph，则显示“Speeding”，否则显示“OK”。输入格式：输入在一行中给出1个不超过500的非负整数，即雷达测到的车速。输出格式：在一行中输出测速仪显示结果，格式为：Speed: V - S，其中V是车速，S或者是Speeding、或者是OK。输入样例1： 40 输出样例1： Speed: 40 - OK 输入样例2： 75 输出样例2： Speed: 75 - Speedi...

clojure GUI编程-1

<?xml version="1.0" encoding="utf-8"?>clojure GUI编程-1 <style type="text/css">*/ </style> <body>clojure GUI编程-1目录 1. 简介 2. 实现过程2.1. 添加依赖包 2.2. API请求的实现 2.3. gui界面的实现1 简介最近了解了下GUI编程，测试了实时刷新GUI的编程方法，作为总结，记录下来。具体示例以okex交易行情为例子,写一个GUI程序，界面要实时刷新当前行情。参考官方地址。 okex的API地址。主要用到获取币对信息，和深度数据...

首页 / 更多教程 / [编程题] 四则运算

[编程题] 四则运算

内容导读

内容图文

[编程题] 四则运算

题目描述

请实现如下接口

约束：

个人方法(python)

优秀解析

1. Python一行代码（py2,py3）

2. 传统方法，计算中缀表达式（java）

3. 中缀字符串转变为后缀字符串数组并求解（c++）

3. 统一小括号，中缀表达式转后缀并求解（c++）

参考

内容总结

内容备注

内容手机端

【[编程题] 四则运算】教程文章相关的互联网学习教程文章

[编程题] 四则运算【代码】

少儿编程-教育：少儿编程教育【图】

实验 2 用机器指令和汇编指令编程【图】

雷子聊并发编程（002）：进程介绍【图】

CS314作业代写、代做Matlab编程语言作业、代做Matlab课程设计作业、代写Matlab实验报告作业

网络编程一定要看过的socket大山

PAT(乙级)1036 跟奥巴马一起编程（15 分)

网络编程1【图】

面向对象编程之封装【代码】

泛型编程与STL学习笔记之容器

PTA基础编程题目7-8超速判断【代码】

clojure GUI编程-1

promise和普通异步编程的区别

“《编程珠玑》（第2版）第2章”：A题【代码】【图】

并发编程-线程池（五）线程池为什么不允许使用Executors创建

更多教程 - 最新教程

更多教程 - 最热教程