精华内容
下载资源
问答
  • 模拟计算器

    2013-10-22 14:36:21
    模拟计算器 c# 代码
  • c++模拟计算器

    2015-03-19 09:35:06
    c++模拟计算器程序设计
  • 模拟计算器设计

    2012-12-24 19:58:57
    模拟计算器设计
  • 模拟计算器 C语言

    2015-05-20 15:11:30
    用C语言模拟计算器的运行。支持四则运算,开根号
  • 单片机 模拟计算器程序
  • 模拟计算器

    2021-01-27 21:36:17
    模拟计算器   计算器是我们生活中最常见的数学用具,计算器可以用栈来模拟。 模拟计算器要点: 使用两个栈分别来存储数字和运算符以及括号。 遍历表达式字符串,分别处理’(’,’)’,运算符和数字。 如果是 ...

    栈模拟计算器

      计算器是我们生活中最常见的数学用具,计算器可以用栈来模拟。
    模拟计算器要点:

    1. 使用两个栈分别来存储数字和运算符以及括号。
    2. 遍历表达式字符串,分别处理’(’,’)’,运算符和数字。 如果是 ‘(’ 则直接入栈, 如果是 ‘)’ 则计算括号中的结果,如果是运算符则根据前一个操作符判断要计算还是直接入栈,如果是数字则根据表达式后一位判断要入栈还是继续读取数字拼接。
    3. 遍历完字符串后,清空运算符栈,计算最终结果。

    下面代码演示一下:

    import java.util.Stack;
    import java.util.Scanner;
    
    public class Calculator {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            while (sc.hasNext()) {
                String expression = sc.next();     // 表达式
                if (expression.equals("end")) // 输入 end 结束
                    break;
                System.out.printf("%s = %d\n", expression, count(expression));
            }
        }
    
        // 计算表达式
        public static int count(String expression) {
            Stack<Integer> numStack = new Stack();       // 存放数字的栈
            Stack<Character> operStack = new Stack();    // 存放运算符的栈
            int num1 = 0, num2 = 0, res = 0;
            char ch = ' ', oper = ' '; // ch是表达式中的每一字符,oper是运算符
            String number = "";  // 用于拼接多位数
            // 遍历字符串
            for (int i = 0; i < expression.length(); i++) {
                ch = expression.charAt(i);
                if (ch == '(') { // 如果是左括号直接入栈即可
                    operStack.push(ch);
                } else if (ch == ')') { // 如果是有括号,处理括号里面的所有内容
                    while (true) {
                        // 如果符号栈为'('
                        if (operStack.peek() == '(') {
                            operStack.pop();
                            break;
                        }
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = calculate(num1, oper, num2);
                        numStack.push(res);  // 把运算结果入栈
                    }
                } else if (isOper(ch)) { // 如果是运算符
                    // 如果运算符栈为空时,该操作符直接入栈
                    if (operStack.isEmpty() || operStack.peek() == '(') { // 利用惰性
                        operStack.push(ch);
                    } else { // 如果运算符栈不为空或'('时,则需要判断要不要计算
                        // 如果当前运算符ch优先级小于或等于前一个运算符,需先计算前一个运算符
                        if (priority(ch) <= priority(operStack.peek())) {
                            num1 = numStack.pop();
                            num2 = numStack.pop();
                            oper = operStack.pop();
                            res = calculate(num1, oper, num2);
                            numStack.push(res);  // 把运算结果入栈
                            operStack.push(ch);  // 把当前运算符压入栈
                        } else { // 如果当前运算符ch优先级大于前一个运算符,直接入栈
                            operStack.push(ch);
                        }
                    }
                } else { // 如果是数字直接入栈
                    number += ch;
                    // 如果已经是最后一位了
                    if (i == expression.length() -1) {
                        numStack.push(Integer.parseInt(number));
                    } else if(isOper(expression.charAt(i+1)) || expression.charAt(i+1) == '(' || expression.charAt(i+1) == ')') {
                        numStack.push(Integer.parseInt(number));
                        number = "";
                    }
                }
            }
            // 表达式遍历结束,清理栈
            while (true) {
                // 如果符号栈为空,退出
                if (operStack.isEmpty()) {
                    break;
                }
                num1 = numStack.pop();
                num2 = numStack.pop();
                oper = operStack.pop();
                res = calculate(num1, oper, num2);
                numStack.push(res);  // 把运算结果入栈
            }
            // 此时数字栈中只剩下一个数字,也就是最终的计算结果,返回即可
            return numStack.pop();
        }
    
        // 判断优先级
        public static int priority(char oper) {
            if (oper == '*' || oper == '/')
                return 1;
            else if (oper == '+' || oper == '-')
                return 0;
            else
                return -1;
        }
    
        // 判断是否是运算符
        public static boolean isOper(char val) {
            return val == '+' || val == '-' || val == '*' || val == '/';
        }
    
        // 返回计算结果
        public static int calculate(int num1, char oper, int num2) {
            int res = 0;
            switch (oper) {
                case '+':
                    res += num2 + num1;break;
                case '-':
                    res += num2 - num1;break;
                case '*':
                    res += num2 * num1;break;
                case '/':
                    res += num2 / num1;break;
                default:
                    break;
            }
            return res;
        }
    
    }
    

    测试一下,这里用两组数据,12*(2-5+1)/2+24,2+(22*6-10)/2 测试,以end结束,运行结果为:

    12*(2-5+1)/2+24
    12*(2-5+1)/2+24 = 12
    2+(22*6-10)/2
    2+(22*6-10)/2 = 63
    end
    

    上述是对中缀表达式的计算,想了解波兰表达式和逆波兰表达式可看
    波兰计算器和逆波兰计算器

    展开全文
  • /usr/bin/env python#-*- coding:utf-8 -*-#Author: Colin Yao"""模拟计算器开发作业"""importredefoperator_update(formula):formula= formula.replace(" ", "")formula= formula.replace("+-", "-")formula= ...

    #!/usr/bin/env python#-*- coding:utf-8 -*-#Author: Colin Yao

    """模拟计算器开发作业"""

    importredefoperator_update(formula):

    formula= formula.replace(" ", "")

    formula= formula.replace("+-", "-")

    formula= formula.replace("--", "+")returnformuladefcalc_muldiv(formula_list):for index, element inenumerate(formula_list):if "*" in element or "/" inelement:

    operators= re.findall("[*/]", element)

    calc_list= re.split("[*/]", element)

    num=Nonefor i, e inenumerate(calc_list):ifnum:if operators[i - 1] == "*":

    num*=float(e)elif operators[i - 1] == "/":

    num/=float(e)else:

    num=float(e)

    formula_list[index]=numreturnformula_listdefcalc_plumin(operators, num_list):

    num=Nonefor i, e inenumerate(num_list):ifnum:if operators[i - 1] == "+":

    num+=float(e)elif operators[i - 1] == "-":

    num-=float(e)else:

    num=float(e)returnnumdefmerge(plus_minus_operator, multiply_divide_list):for index, element inenumerate(multiply_divide_list):if element.endswith("*") or element.endswith("/"):

    multiply_divide_list[index]= element + plus_minus_operator[index] + multiply_divide_list[index + 1]del multiply_divide_list[index + 1]delplus_minus_operator[index]returnmerge(plus_minus_operator, multiply_divide_list)returnplus_minus_operator, multiply_divide_listdefbracket_calc(formula):

    formula= re.sub("[()]", "", formula) #去除两边的()

    formula =operator_update(formula)

    plus_minus_operator= re.findall("[+-]", formula)

    multiply_divide_list= re.split("[+-]", formula)if multiply_divide_list[0] == "":

    multiply_divide_list[1] = "-" + multiply_divide_list[1]delplus_minus_operator[0]delmultiply_divide_list[0]

    res=merge(plus_minus_operator, multiply_divide_list)

    plus_minus_operator=res[0]

    multiply_divide_list= res[1]

    plus_minus_list=calc_muldiv(multiply_divide_list)

    res=calc_plumin(plus_minus_operator, plus_minus_list)returnresdefcalculate(formula):whileTrue:

    formula_depth= re.search("\([^()]+\)", formula)ifformula_depth:

    formula_depth=formula_depth.group()

    res=bracket_calc(formula_depth)

    formula=formula.replace(formula_depth, str(res))print(formula)else:

    res=bracket_calc(formula)print(res)

    exit()if __name__ == '__main__':

    msg= '''进行解析()的运算

    例如:1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'''

    print(msg)

    formula= input("请输入要进行的运算>>>:")#formula = "1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )"

    calculate(formula)

    展开全文
  • 模拟_计算器,易语言模拟计算器源码,源码是简单的组件应用教程。
  • 合肥工业大学 模拟计算器程序 c++,合肥工业大学程序设计基础大作业,模拟计算器程序 c++版本,有代码和实验结果
  • javaScript简单模拟计算器简单易懂
  • 用脚本模拟计算器

    2020-04-01 11:44:36
    用脚本模拟计算器

    用脚本模拟计算器

    用shell写一个简易计算器,可以实现加、减、乘、除运算,假如脚本名字为1.sh,执行示例:./1.sh 1 + 2

    #!/bin/bash
    
    if [ $# -ne 3 ] 
    then
        echo "参数个数不为3"
        echo "当使用乘法时,需要加上脱义符号,例如 $0 1 \* 2"
        exit 1;
    fi
    
    num1=`echo $1|sed 's/[0-9.]//g'` ;
    if [ -n "$num1" ] 
    then
        echo "$1 不是数字" ;
        exit 1
    fi
    
    num3=`echo $3|sed 's/[0-9.]//g'` ;
    if [ -n "$num3" ]
    then
        echo "$3 不是数字" ;
        exit 1
    fi
    
    case $2 in
      +)
        echo "scale=2;$1+$3" | bc
        ;;
    
      -)
        echo "scale=2;$1-$3" | bc 
        ;;
    
      \*)
        echo "scale=2;$1*$3" | bc 
        ;;
    
      /)
        echo "scale=2;$1/$3" | bc 
        ;;
    
      *)
       echo  "$2 不是运算符"
       ;;
    esac
    

    测试结果

    在这里插入图片描述

    展开全文
  • 精品文档 数据结构课程设计 实验报告 模拟计算器 班 级 学 号 姓 名 模拟计算器 1 欢迎下载 精品文档 1 问题描述 对于模拟计算器的设计实际便是利用栈对一个表达式求值的问题 要求 对包含加减乘除括号的任意整型...
  • 数据结构课程设计 实验报告 模拟计算器 班 级 学 号 姓 名 模拟计算器 问题描述 对于模拟计算器的设计实际便是利用栈对一个表达式求值的问题 要求 对包含加减乘除括号的任意整型表达式进行求解 设计思路 表达式任何...
  • } // 下面进行计算器的整体布局,将calckeys和command画板放在计算器的中部, // 将文本框放在北部,将calms画板放在计算器的西部。 // 新建一个大的画板,将上面建立的command和calckeys画板放在该画板内 JPanel ...

    package myPractise.Creasy2;

    import java.awt.BorderLayout;

    import java.awt.Color;

    import java.awt.Font;

    import java.awt.GridLayout;

    import java.awt.event.ActionEvent;

    import java.awt.event.ActionListener;

    import javax.swing.JButton;

    import javax.swing.JFrame;

    import javax.swing.JPanel;

    import javax.swing.JTextField;

    import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils.Text;

    public class Calculator2 extends JFrame implements ActionListener

    {

    /** 计算器上的键的显示名字 */

    private final String[] KEYS = { "7", "8", "9", "/", "sqrt", "4", "5", "6", "*", "%", "1", "2", "3", "-", "1/x", "0",

    "+/-", ".", "+", "=" };

    /** 计算器上的功能键的显示名字 */

    private final String[] COMMAND = { "Backspace", "CE", "C" };

    /** 计算器左边的M的显示名字 */

    private final String[] M = { " ", "MC", "MR", "MS", "M+" };

    /** 计算器上键的按钮 */

    private JButton keys[] = new JButton[KEYS.length];

    /** 计算器上的功能键的按钮 */

    private JButton commands[] = new JButton[COMMAND.length];

    /** 计算器左边的M的按钮 */

    private JButton m[] = new JButton[M.length];

    /** 计算结果文本框 */

    private JTextField resultText = new JTextField("0");

    // 标志用户按的是否是整个表达式的第一个数字,或者是运算符后的第一个数字

    private boolean firstDigit = true;

    // 计算的中间结果。

    private double resultNum = 0.0;

    // 当前运算的运算符

    private String operator = "=";

    // 操作是否合法

    private boolean operateValidFlag = true;

    /**

    * 构造函数

    */

    public Calculator2() {

    super();

    // 初始化计算器

    init();

    // 设置计算器的背景颜色

    this.setBackground(Color.LIGHT_GRAY);

    this.setTitle("计算器");

    // 在屏幕(500, 300)坐标处显示计算器

    this.setLocation(500, 300);

    // 不许修改计算器的大小

    this.setResizable(false);

    // 使计算器中各组件大小合适

    this.pack();

    }

    /**

    * 初始化计算器

    */

    public void init()

    {

    // 文本的字体和大小

    resultText.setFont(new Font("宋体", Font.PLAIN, 15));

    // 文本框中的内容采用右对齐方式

    resultText.setHorizontalAlignment(JTextField.RIGHT);

    // 不允许修改结果文本框

    resultText.setEditable(false);

    // 设置文本框背景颜色为白色

    resultText.setBackground(Color.WHITE);

    // 初始化计算器上键的按钮,将键放在一个画板内

    JPanel calckeysPanel = new JPanel();

    // 用网格布局器,4行,5列的网格,网格之间的水平方向间隔为3个象素,垂直方向间隔为3个象素

    calckeysPanel.setLayout(new GridLayout(4, 5, 3, 3));

    for (int i = 0; i < KEYS.length; i++)

    {

    keys[i] = new JButton(KEYS[i]);

    calckeysPanel.add(keys[i]);

    keys[i].setForeground(Color.blue);

    }

    // 运算符键用红色标示,其他键用蓝色表示

    keys[3].setForeground(Color.red);

    keys[8].setForeground(Color.red);

    keys[13].setForeground(Color.red);

    keys[18].setForeground(Color.red);

    keys[19].setForeground(Color.red);

    // 初始化功能键,都用红色标示。将功能键放在一个画板内

    JPanel commandsPanel = new JPanel();

    // 用网格布局器,1行,3列的网格,网格之间的水平方向间隔为3个象素,垂直方向间隔为3个象素

    commandsPanel.setLayout(new GridLayout(1, 3, 3, 3));

    for (int i = 0; i < COMMAND.length; i++)

    {

    commands[i] = new JButton(COMMAND[i]);

    commandsPanel.add(commands[i]);

    commands[i].setForeground(Color.red);

    }

    // 初始化M键,用红色标示,将M键放在一个画板内

    JPanel calmsPanel = new JPanel();

    // 用网格布局管理器,5行,1列的网格,网格之间的水平方向间隔为3个象素,垂直方向间隔为3个象素

    calmsPanel.setLayout(new GridLayout(5, 1, 3, 3));

    for (int i = 0; i < M.length; i++)

    {

    m[i] = new JButton(M[i]);

    calmsPanel.add(m[i]);

    m[i].setForeground(Color.red);

    }

    // 下面进行计算器的整体布局,将calckeys和command画板放在计算器的中部,

    // 将文本框放在北部,将calms画板放在计算器的西部。

    // 新建一个大的画板,将上面建立的command和calckeys画板放在该画板内

    JPanel panel1 = new JPanel();

    // 画板采用边界布局管理器,画板里组件之间的水平和垂直方向上间隔都为3象素

    panel1.setLayout(new BorderLayout(3, 3));

    panel1.add("North", commandsPanel);

    panel1.add("Center", calckeysPanel);

    // 建立一个画板放文本框

    JPanel top = new JPanel();

    top.setLayout(new BorderLayout());

    top.add("Center", resultText);

    // 整体布局,getcontentpane方法是JRame的静态方法

    getContentPane().setLayout(new BorderLayout(3, 5));

    getContentPane().add("North", top);

    getContentPane().add("Center", panel1);

    getContentPane().add("West", calmsPanel);

    // 为各按钮添加事件侦听器

    // 都使用同一个事件侦听器,即本对象。本类的声明中有implements ActionListener

    for (int i = 0; i < KEYS.length; i++)

    {

    keys[i].addActionListener(this);

    }

    for (int i = 0; i < COMMAND.length; i++)

    {

    commands[i].addActionListener(this);

    }

    for (int i = 0; i < M.length; i++)

    {

    m[i].addActionListener(this);

    }

    }

    /*

    * 处理键盘事件 覆盖ActionListenser的方法,接受被监听对象的活动

    */

    @Override

    public void actionPerformed(ActionEvent e)

    {

    String label = e.getActionCommand();

    if (label.equals(COMMAND[0]))

    {

    // 用户按了"Backspace"键方法

    BackspaceWay(label);

    }

    else if (label.equals(COMMAND[1]))

    {

    // 用户按了"CE"键

    resultText.setText("0");

    }

    else if (label.equals(COMMAND[2]))

    {

    // 用户按了"C"键

    resultText.setText("0");

    operator = "=";

    operateValidFlag = true;

    }

    else if ("0123456789.".indexOf(label) >= 0)

    {

    // 用户按了数字键或者小数点键

    NumWay(label);

    }

    else

    {

    // 用户按了运算符键

    CalculatorWay(label);

    }

    }

    public void BackspaceWay(String label)

    {

    String text = resultText.getText();

    if (text.length() > 0)

    {

    text = text.substring(0, text.length() - 1);

    if (text.length() == 0)

    {

    resultText.setText("0");

    operator = "=";

    operateValidFlag = true;

    }

    else

    {

    resultText.setText(text);

    }

    }

    }

    public void NumWay(String label)

    {

    if (firstDigit)

    {

    resultText.setText(label);

    }else if (!label.equals("."))

    {

    resultText.setText(resultText.getText() + label);

    }else if(label.equals(".")&&resultText.getText().indexOf(".")<0) {

    resultText.setText(resultText.getText() + ".");

    }

    firstDigit = false;

    }

    public void CalculatorWay(String label)

    {

    if (operator.equals("/")) {

    // 除法运算

    // 如果当前结果文本框中的值等于0

    if (getNumberFromText() == 0.0) {

    // 操作不合法

    operateValidFlag = false;

    resultText.setText("除数不能为零");

    } else {

    resultNum /= getNumberFromText();

    }

    } else if (operator.equals("1/x")) {

    // 倒数运算

    if (resultNum == 0.0) {

    // 操作不合法

    operateValidFlag = false;

    resultText.setText("零没有倒数");

    } else {

    resultNum = 1 / resultNum;

    }

    } else if (operator.equals("+")) {

    // 加法运算

    resultNum += getNumberFromText();

    } else if (operator.equals("-")) {

    // 减法运算

    resultNum -= getNumberFromText();

    } else if (operator.equals("*")) {

    // 乘法运算

    resultNum *= getNumberFromText();

    } else if (operator.equals("sqrt")) {

    // 平方根运算

    resultNum = Math.sqrt(resultNum);

    } else if (operator.equals("%")) {

    // 百分号运算,除以100

    resultNum = resultNum / 100;

    } else if (operator.equals("+/-")) {

    // 正数负数运算

    resultNum = resultNum * (-1);

    } else if (operator.equals("=")) {

    // 赋值运算

    resultNum = getNumberFromText();

    }

    if (operateValidFlag) {

    // 双精度浮点数的运算

    long t1;

    double t2;

    t1 = (long) resultNum;

    t2 = resultNum - t1;

    if (t2 == 0) {

    resultText.setText(String.valueOf(t1));

    } else {

    resultText.setText(String.valueOf(resultNum));

    }

    }

    // 运算符等于用户按的按钮

    operator = label;

    firstDigit = true;

    operateValidFlag = true;

    }

    public double getNumberFromText(){

    double result = 0;

    try {

    result = Double.valueOf(resultText.getText()).doubleValue();

    } catch (NumberFormatException e) {

    }

    return result;

    }

    public static void main(String[] args)

    {

    Calculator2 calculator2=new Calculator2();

    calculator2.setVisible(true);

    }

    }

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,121
精华内容 848
关键字:

模拟计算器