精华内容
下载资源
问答
  • 仿lisp运算
    2022-06-07 23:36:54

    LISP 语言唯一的语法就是括号要配对。 形如(OP P1 P2 …),括号内元素由单个空格分割。 其中第一个
    元素 OP 为操作符,后续元素均为其参数,参数个数取决于操作符类型 注意:参数 P1, P2 也有可能是另外
    一个嵌套的(OP P1 P2 …) 当前 OP 类型为 add / sub / mul / div(全小写),分别代表整数的加减乘除法
    简单起见,所有 OP 参数个数均为 2
    举例:
    输入:(mul 3 -7) 输出: -21
    输入:(add 1 2) 输出:3
    输入:(sub(mul 2 4) (div 9 3)) 输出:5
    输入:(div 1 0) 输出:error 题目涉及数字均为整数,可能为负;
    不考虑 32 位溢出翻转,计算过程中也不会发生 32 位溢出翻转 除零错误时,
    输出 “error”,除法遇除不尽,向下取整,即 3 / 2 = 1
    输入描述:
    输入为长度不超过 512 的字符串,用例保证了无语法错误
    输出描述:
    输出计算结果或者“error”
    示例 1
    输入:(div 12 (sub 45 45))
    输出:
    error

    public class Main {
    更多相关内容
  • 仿LISP运算

    2022-05-22 09:21:35
    // 仿LISP运算 function add(a, b) { if (a == "error" || b == "error") { return "error"; } else { return Number(a) + Number(b); } } function sub(a, b) { if (a == "error" || b == "error") { return...

    // 仿LISP运算
    function add(a, b) {
      if (a == "error" || b == "error") {
        return "error";
      } else {
        return Number(a) + Number(b);
      }
    }
    function sub(a, b) {
      if (a == "error" || b == "error") {
        return "error";
      } else {
        return Number(a) - Number(b);
      }
    }
    function mul(a, b) {
      if (a == "error" || b == "error") {
        return "error";
      } else {
        return Number(a) * Number(b);
      }
    }
    function div(a, b) {
      if (a == "error" || b == "error" || b == "0") {
        return "error";
      } else {
        return Math.floor(Number(a) / Number(b));
      }
    }
    function lisp(str) { // 封装上面四则运算,通过eval执行计算结果
      let tmp=str.replace(/\((sub|div|mul|add) /g,'$1(').replace(/ /g,',');
      console.log(eval(tmp))
    }
    lisp('(sub (mul 2 4) (div 9 3))')
    

    展开全文
  • 仿 LISP 运算

    2021-10-31 18:41:12
    仿 LISP 运算 题目描述: LISP 语言唯一的语法就是括号要配对。 形如(OP P1 P2 …),括号内元素由单个空格分割。 其中第一个 元素 OP 为操作符,后续元素均为其参数,参数个数取决于操作符类型 注意:参数 P1, P2 也...

    仿 LISP 运算

    题目描述:
    LISP 语言唯一的语法就是括号要配对。 形如(OP P1 P2 …),括号内元素由单个空格分割。 其中第一个
    元素 OP 为操作符,后续元素均为其参数,参数个数取决于操作符类型 注意:参数 P1, P2 也有可能是另外
    一个嵌套的(OP P1 P2 …) 当前 OP 类型为 add / sub / mul / div(全小写),分别代表整数的加减乘除法
    简单起见,所有 OP 参数个数均为 2
    举例:
    输入:(mul 3 -7) 输出: -21
    输入:(add 1 2) 输出:3
    输入:(sub(mul 2 4) (div 9 3)) 输出:5
    输入:(div 1 0) 输出:error 题目涉及数字均为整数,可能为负;
    不考虑 32 位溢出翻转,计算过程中也不会发生 32 位溢出翻转 除零错误时,
    输出 “error”,除法遇除不尽,向下取整,即 3 / 2 = 1
    输入描述:
    输入为长度不超过 512 的字符串,用例保证了无语法错误
    输出描述:
    输出计算结果或者“error”
    示例 1
    输入:(div 12 (sub 45 45))
    输出:
    error

    #include<iostream>
    #include<vector>
    #include<string>
    #include<stack>
    using namespace std;
    
    int main(){
    	string str="";
    	while(getline(cin,str)){
    		bool flag=true;
    		vector<string> st;
    		stack<int> res;
    		int n=str.size();
    		for(int i=n-1;i>=0;){
    			if(str[i]=='(' || str[i]==')' || str[i]==' '){
    				--i;
    			}
    			else if(str[i]>='a' && str[i]<='z'){
    				st.push_back(str.substr(i-2,3));
    				i=i-3;
    			}
    			else{
    				string::size_type index=str.rfind(' ',i);
    				st.push_back(str.substr(index+1,i-index));
    				i=index;
    			}
    		}
    		for(size_t i=0;i<st.size();++i){
    			string tmp=st[i];
    			if(tmp=="add" || tmp=="sub" || tmp=="mul" || tmp=="div"){
    				if(res.size()<2){
    					return 0;
    				}
    				int num2=res.top(); res.pop();
    				int num1=res.top(); res.pop();
    				int result=0;
    				if(tmp=="add"){
    					result=num1+num2;
    				}
    				else if(tmp=="sub"){
    					result=num2-num1;
    				}
    				else if(tmp=="mul"){
    					result=num1*num2;
    				}
    				else if(tmp=="div"){
    					if(num1==0){
    						flag=false;
    					}
    					else{
    						result=num2/num1;
    					}
    				}
    				res.push(result);
    			}
    			else{
    				res.push(atoi(tmp.c_str()));
    			}
    		}
    		if(!flag){
    			cout<<"error"<<endl;
    		}
    		else{
    			cout<<res.top()<<endl;
    		}
    	}
    	return 0;
    }
    
    展开全文
  • 华为机试:仿lisp运算,栈

    【编程题目 | 200分】 仿 LISP 运算【2021 H2, 2022 Q1,Q2 考试题】

    题目描述

    LISP 语言唯一的语法就是括号要配对。 形如(OP P1 P2 …),括号内元素由单个空格分割。 其中第一个元素 OP 为操作符,后续元素均为其参数,参数个数取决于操作符类型 注意:参数 P1, P2 也有可能是另外一个嵌套的(OP P1 P2 …) 当前 OP 类型为 add / sub / mul / div(全小写),分别代表整数的加减乘除法简单起见,所有 OP 参数个数均为 2

    • 题目涉及数字均为整数,可能为负;
    • 不考虑 32 位溢出翻转,计算过程中也不会发生 32 位溢出翻转 除零错误时,输出 “error”;
    • 除法遇除不尽,向下取整,即 3 / 2 = 1

    输入描述:

    输入为长度不超过 512 的字符串,用例保证了无语法错误

    输出描述:

    输出计算结果或者“error”

    举例:

    输入:

    (mul 3 -7) 
    

    输出:

    -21
    

    输入:

    (add 1 2) 
    

    输出:

    3
    

    输入:

    (sub (mul 2 4) (div 9 3)) 
    

    输出:

    5
    

    输入:

    (div 1 0) 
    

    输出:

    error
    

    输入:

    (div 12 (sub 45 45))
    

    输出:

    error
    

    思路分析

    首先:对于括号的处理是栈,然后字符串的操作,根据出栈的顺序,进行switch case操作。

    参考代码

    import java.util.Scanner;
    import java.util.Stack;
    
    public class LISP {
        public static boolean isError;
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            String str = in.nextLine().replaceAll("\\(", "( ").replaceAll("\\)", " )");
            String[] s = str.split(" ");
    
            Stack<String> patten = new Stack<>();
            Stack<String> opera = new Stack<>();
    
            int op1, op2;
            String operation;
            isError = false;
            int res = 0;
            for (int i = 0; i < s.length; i++) {
                String temp = s[i];
                switch (temp) {
                    case "(":
                        patten.push("(");
                        break;
                    case ")":
                        if (patten.isEmpty()) {
                            isError = true;
                        }
                        patten.pop();
                        op2 = Integer.parseInt(opera.pop());
                        op1 = Integer.parseInt(opera.pop());
                        operation = opera.pop();
                        res = calculate(operation, op1, op2);
                        opera.push(String.valueOf(res));
                        break;
                    default:
                        opera.push(temp);
                }
                if(isError) {
                    break;
                }
            }
            if (isError) {
                System.out.println("error");
            } else {
                System.out.println(res);
            }
        }
        public static int calculate(String operation, int op1, int op2) {
            int result = 0;
            switch (operation) {
                case "add":
                    result = op1 + op2;
                    break;
                case "sub":
                    result = op1 - op2;
                    break;
                case "mul":
                    result = op1 * op2;
                    break;
                default:
                    if (op2 == 0) {
                        isError = true;
                    } else {
                        result = op1 / op2;
                    }
            }
            return result;
        }
    }
    

    欢迎在评论区指正以及留下自己的更简洁的方法。

    展开全文
  • 标题:仿LISP运算| LISP语言唯一的语法就是括号要配对。形如(OPP1P2...),括号内元素由单个空格分割。其中第一个元素OP为操作符,后续元素均为其参数,参数个数取决于操作符类型 注意:参数P1,P2也有可能是另外一个...
  • 【华为OD机试真题 JAVA】仿LISP运算

    千次阅读 2022-04-27 11:04:39
    标题:仿LISP运算| LISP语言唯一的语法就是括号要配对。形如(OPP1P2...),括号内元素由单个空格分割。其中第一个元素OP为操作符,后续元素均为其参数,参数个数取决于操作符类型。注意:参数P1,P2也有可能是另外一个...
  • LISP 语言唯一的语法就是括号要配对。 形如 (OP P1 P2 …),括号内元素由单个空格分割。其中第一个元素 OP 为操作符,后续元素均为其参数,参数个数取决于操作符类型注意:参数 P1, P2 也有可能是另外一个嵌套的 (OP...
  • 仿LISP运算 | c++

    2019-07-14 15:14:00
    1 #include<bits/stdc++.h> 2 using namespace std; ... 4 * 仿LISP运算 5 * 模拟(sub (mul 2 4) (div 9 3)) 6 * @return 7 */ 8 9 int main() { 10 int mark = 0; 11 in...
  • [编程|300分] 仿LISP字符串运算 题目描述 LISP语言唯一的语法就是括号要配对。 形如 (OP P1 P2 …),括号内元素由单个空格分割。 其中第一个元素OP为操作符,后续元素均为其参数,参数个数取决于操作符类型 注意:...
  • 简单 LISP 算术表达式(以下简称表达式)定义如下: (1) 一个 0..9 的整数;或者 (2)(运算符 表达式 表达式) 例如,6,(+45),(+(+25)8) 都是表达式,其值分别为6,9和15。 【任务要求】 实现LISP加法表达式的求值。 ...
  • 仿LISP运算 1.题目描述  LISP语言唯一的语法就是括号要配对。  形如 (OP P1 P2 …),括号内元素由单个空格分割。  其中第一个元素OP为操作符,后续元素均为其参数,参数个数取决于操作符类型  注意:...
  • 仿 LISP 字符串运算[200 分] 题目描述 LISP 语言唯一的语法就是括号要配对。 形如 (OP P1 P2 …),括号内元素由单个空格分割。 其中第一个元素 OP 为操作符,后续元素均为其参数,参数个数取决于操作符类型。 注意:...
  • 华为机试题:仿LISP

    2021-03-08 16:07:28
    packagecom.nowcoder.huawei;import java.util.*;public classLISP {//只通过80%//(+ (* 2 3) (^ 4))//(+ (* 2 3) (^ 4))(2 3)//((+ 2 3)//((+ 2 3))//(^ (+ (* 2 3) (^ ((^ 4)))))public static voidmain(String[] ...
  • /*** 仿LISP字符串运算* LISP语言唯一的语法就是括号要配对。* 形如 (OP P1 P2 …),括号内元素由单个空格分割。* 其中第一个元素OP为操作符,后续元素均为其参数,参数个数取决于操作符类型* 注意:参数 P1, P2 也...
  • 栈的应用 - 仿LISP字符串运算

    千次阅读 2018-08-05 10:40:40
    LISP语言唯一的语法就是括号要配对。 形如 (OP P1 P2 …),括号内元素由单个空格分割。 其中第一个元素OP为操作符,后续元素均为其参数,参数个数取决于操作符类型 注意:参数 P1, P2 也有可能是另外一个嵌套的 ...
  • 华为机试(仿LISP字符串运算

    千次阅读 2017-06-28 22:55:50
    [编程|300分] 仿LISP字符串运算 时间限制:3秒 空间限制:32768K 题目描述 LISP语言唯一的语法就是括号要配对。 形如 (OP P1 P2 …),括号内元素由单个空格分割。 其中第一个元素OP为操作符,后续元素均为其...
  • 题目描述 LISP语言唯一的语法就是括号要配对。 形如 (OP P1 P2 …),括号内元素由单个空格分割。 其中第一个元素OP为操作符,后续元素均为其参数,参数个数取决于操作符类型 注意:参数 P1, P2 也有可能是另外一个...
  • 华为机试C语言
  • importjava.util.Scanner;importjava.util.Stack;public classMain {//(sub (mul 2 4) (div 9 3))public static voidmain(String[] args) {Scanner scanner= newScanner(System.in);String line=scanner.nextLine();...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 602
精华内容 240
关键字:

仿lisp运算