计算器类题目的解法汇总

最新推荐文章于 2021-08-28 17:23:14 发布
最新推荐文章于 2021-08-28 17:23:14 发布
阅读量467 收藏
点赞数
分类专栏： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhmy77/article/details/114757023
版权

文章目录

本文首发于公众号：code路漫漫，欢迎关注
在这里插入图片描述

概述

在这里插入图片描述

题目

  1. 逆波兰表达式求值
  2. 基本计算器
  3. 基本计算器 II
  4. 基本计算器 III

特别说明，由于精度的问题，这里的题目凡是涉及到除法都只保留整数部分

解法

通用解法 转换成逆波兰表达式

对于逆波兰表达式，我们可以用一个栈就能求解出结果，这也是150. 逆波兰表达式求值的答案

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        num = []
        
        for t in tokens:
            # 可能含有负数
            if t.isdigit() or t[1:].isdigit():
                num.append(int(t))
            else:
                if t == '+':
                    a,b = num.pop(),num.pop()
                    num.append(a+b)
                elif t == '-':
                    a,b = num.pop(),num.pop()
                    num.append(b-a)
                elif t == '*':
                    a,b = num.pop(),num.pop()
                    num.append(a*b)
                elif t == '/':
                    a,b = num.pop(),num.pop()
                    num.append(int(b/a))

        return num[-1]

那么如何将中缀表达式转换成逆波兰表达式呢？
这个转换有很多实现，最关键的一点是我们要记住符号的优先级和出入栈的规则，为了通过leetcode中-xxx和xx(-x+x)这种样例，我们还要对字符换进行预处理
假定一个字符串表达式合法，并且只含有以下字符：+, -, *, /, (, ), ，我们需要两个栈来存储变量，一个pos存储转换后的结果，一个opt存储转换过程中的操作符，我们按照如下规则转换：

  1. 如果是空格
    跳过
  2. 如果是数字
    直接添加到pos中
  3. 如果是左括号
    我们入栈opt
  4. 如果是右括号
    对于opt我们不断弹出栈顶元素添加到pos中直到遇到(，然后弹出(
  5. 如果是操作符
    对于操作符+, -, *, /，它们的优先级依次是1,1,2,2,即加减同级，乘除同级并且高于+，-
    我们按照如下策略执行：
    对于栈顶元素，不断弹出优先级大于等于自己的栈顶元素到pos中，直到栈空或者遇到左括号，然后将自己入栈

我们按照上面5个规则可以写出代码，下面的代码可以帮我们完成转换

    def transfer(s):
        pri = {'+': 1, '-': 1, '*': 2, '/': 2}
        pos = []
        opt = []

        # --- 处理特殊样例 ---
        # 如果不需要可以注释掉这一块代码
        def isopt(ch):
            if ch == '+' or ch == '-' or ch == '*' or ch == '/':
                return True
            return False

        ts = []
        for i in range(len(s)):
            ch = s[i]
            ts.append(ch)
            # 我们检查括号后是否是opt
            if ch == '(':
                if isopt(s[i + 1]):
                    ts.append('0')  # 补一个0，保证以数字开头
        s = ''.join(ts)
        if isopt(s[0]):
            s = '0' + s
        # --- 处理特殊样例 ---

        # 转换过程
        i = 0
        while i < len(s):
            ch = s[i]
            if ch == ' ':
                pass
            elif '0' <= ch <= '9':
                # 如果是数字，获取这一块数字
                t = 0
                while i < len(s) and '0' <= s[i] <= '9':
                    t = t * 10 + int(s[i])
                    i += 1
                i -= 1  # 由于判断外统一+1，我们这里先-1
                pos.append(t)
            elif ch == '(':
                # 如果左括号，我们直接入栈
                opt.append(ch)
            elif ch == ')':
                # 由于是合法的表达式，我们不需要检查栈空
                while opt[-1] != '(':
                    # 出栈直到遇到左括号
                    pos.append(opt.pop())
                # 弹出左括号
                opt.pop()
            else:
                # 遇到操作符
                while opt and opt[-1] != '(' and pri[opt[-1]] >= pri[ch]:
                    pos.append(opt.pop())
                opt.append(ch)
            i += 1

        # 弹出剩余的操作符
        while opt:
            pos.append(opt.pop())
        return pos

转换后我们传递结果给求解逆波兰表达式的算法即可

    def evalRPN(pos):
        num = []

        for t in pos:
            if type(t) == int:
                num.append(t)
            else:
                if t == '+':
                    a, b = num.pop(), num.pop()
                    num.append(a + b)
                elif t == '-':
                    a, b = num.pop(), num.pop()
                    num.append(b - a)
                elif t == '*':
                    a, b = num.pop(), num.pop()
                    num.append(a * b)
                elif t == '/':
                    a, b = num.pop(), num.pop()
                    num.append(int(b / a))

        return num[-1]

224. 基本计算器和227. 基本计算器 II的答案

class Solution:
    def transfer(self, s):
        pri = {'+': 1, '-': 1, '*': 2, '/': 2}
        pos = []
        opt = []

        # --- 处理特殊样例
        def isopt(ch):
            if ch == '+' or ch == '-' or ch == '*' or ch == '/':
                return True
            return False

        ts = []
        for i in range(len(s)):
            ch = s[i]
            ts.append(ch)
            # 我们检查括号后是否是opt
            if ch == '(':
                if isopt(s[i + 1]):
                    ts.append('0')  # 补一个0，保证以数字开头
        s = ''.join(ts)
        if isopt(s[0]):
            s = '0' + s
        # --- 处理特殊样例

        # 转换过程
        i = 0
        while i < len(s):
            ch = s[i]
            if ch == ' ':
                pass
            elif '0' <= ch <= '9':
                # 如果是数字，获取这一块数字
                t = 0
                while i < len(s) and '0' <= s[i] <= '9':
                    t = t * 10 + int(s[i])
                    i += 1
                i -= 1  # 由于判断外统一+1，我们这里先-1
                pos.append(t)
            elif ch == '(':
                # 如果左括号，我们直接入栈
                opt.append(ch)
            elif ch == ')':
                # 由于是合法的表达式，我们不需要检查栈空
                while opt[-1] != '(':
                    # 出栈直到遇到左括号
                    pos.append(opt.pop())
                # 弹出左括号
                opt.pop()
            else:
                # 遇到操作符
                while opt and opt[-1] != '(' and pri[opt[-1]] >= pri[ch]:
                    pos.append(opt.pop())
                opt.append(ch)
            i += 1

        # 弹出剩余的操作符
        while opt:
            pos.append(opt.pop())
        return pos

    def evalRPN(self, pos):
        num = []

        for t in pos:
            if type(t) == int:
                num.append(t)
            else:
                if t == '+':
                    a, b = num.pop(), num.pop()
                    num.append(a + b)
                elif t == '-':
                    a, b = num.pop(), num.pop()
                    num.append(b - a)
                elif t == '*':
                    a, b = num.pop(), num.pop()
                    num.append(a * b)
                elif t == '/':
                    a, b = num.pop(), num.pop()
                    num.append(int(b / a))

        return num[-1]

    def calculate(self, s: str) -> int:
        pos = self.transfer(s)
        ans = self.evalRPN(pos)
        return ans

转换的开销其实还挺大的，如果很长很长的表达式，那么不建议用这个解法

展开括号 针对224，227

如果追求高效，可以利用题目的特点去入手，下面以224. 基本计算器和227. 基本计算器 II为例，记录递归如何解决这类问题

先考虑224. 基本计算器，整个式子只有+ - ( )

如果我们把括号展开，那么可以遍历一次得到答案，即数字和符号的组合相加
例如 1+2+(3-(4+5)) = 1+2+3-4-5，是+1 +2 +3 -4 -5这些数字合起来
关键是我们怎么把括号展开同时给每个数字赋予正确的符号

数字的符号被两个因素影响

  1. 数字当前的符号
  2. 数字之前的符号

例如-(1+2)中2的符号，第一点，2的符号是+，第二点，2的符号受到了括号前-的影响，综合下来2的符号是-

数字当前的符号很好判断，要么是正要么是负，但是数字之前的符号需要记录下来，每个括号成对出现，所以我们可以用栈来表示，遇到左括号时，当前符号入栈，遇到右括号时，栈顶符号弹出

经过以上分析，我们需要两个变量

sign = 1
ops = [1]

sign初始化为1，ops初始化为[1]，这是因为我们为了方便处理-开头的表达式，相当于在表达式前加上0，变为以+开头

    ret = 0
    n = len(s)
    i = 0
    while i < n:
        if s[i] == ' ':
            i += 1
        elif s[i] == '+':
            # +
            pass
        elif s[i] == '-':
            # -
            pass
        elif s[i] == '(':
        	# 左括号
        	pass
        elif s[i] == ')':
			# 右括号
			pass
        else:
        	# 碰到数字
        	pass

然后我们逐个分析
如果是+：
由于+不会改变当前符号的性质，所以我们保持sign = ops[-1]即可
如果是-：
由于-会反转符号，所以我们用sign = -ops[-1]来记录当前符号
如果是(：
我们碰到了新的括号，当前的sign对括号内的元素来说是之前的元素，我们用ops.append(sign)来记录括号之外的符号
如果是)：
括号对结束了，我们把栈顶元素弹出
如果碰到数字：
按照之前的分析，我们获取数字，然后统计结果 ret += sign*num即可
上面的代码完善后变为

class Solution:
    def calculate(self, s: str) -> int:
        ops = [1]
        sign = 1

        ret = 0
        n = len(s)
        i = 0
        while i < n:
            if s[i] == ' ':
                i += 1
            elif s[i] == '+':
                # +号继承之前的符号
                sign = ops[-1]
                i += 1
            elif s[i] == '-':
                # -号反转
                sign = -ops[-1]
                i += 1
            elif s[i] == '(':
                ops.append(sign)
                i += 1
            elif s[i] == ')':
                ops.pop()
                i += 1
            else:
                num = 0
                while i<n and s[i].isdigit():
                    num = num*10 + ord(s[i]) - ord('0')
                    i+=1
                ret += num*sign

        return ret

然后我们看 227. 基本计算器 II
还是一样的思路，这里只多了乘除而少了括号，整个式子没有括号并不会改变运算的优先级，所以我们按照同样的思路来做

有意思的是整个表达式没有括号，不会改变运算的优先级，那么整个数字可以拆分为两部分：
如果是不涉及到乘除的数字，那么我们直接入栈，因为本质上是在做加法
如果涉及到乘除，那么涉及到的数字最终都会得到一个结果，我们可以不断对栈顶操作得到这个结果

具体来说，遍历字符串 s，并用变量 preSign 记录每个数字之前的运算符，对于第一个数字，其之前的运算符视为加号。每次遍历到数字末尾时，根据 preSign 来决定计算方式：

加号：将数字压入栈；
减号：将数字的相反数压入栈；
乘除号：计算数字与栈顶元素，并将栈顶元素替换为计算结果。

代码实现中，若读到一个运算符，或者遍历到字符串末尾，即认为是遍历到了数字末尾。处理完该数字后，更新 preSign 为当前遍历的字符。

class Solution:
    def calculate(self, s: str) -> int:
        n = len(s)
        stack = []
        preSign = '+'
        num = 0
        for i in range(n):
            if s[i] != ' ' and s[i].isdigit():
                num = num * 10 + ord(s[i]) - ord('0')
            if i == n - 1 or s[i] in '+-*/':
                if preSign == '+':
                    stack.append(num)
                elif preSign == '-':
                    stack.append(-num)
                elif preSign == '*':
                    stack.append(stack.pop() * num)
                else:
                    stack.append(int(stack.pop() / num))
                preSign = s[i]
                num = 0
        return sum(stack)

通用解法 基于递归

先设计处理加减、乘除法的方法，然后遇到括号的时候再递归

  1. 处理加减法
    思路是和上面 224的解法一样，我们用一个栈来存放结果，然后把式子变成累加的形式
def cal1(s):
    num = 0
    stack = []
    sign = '+'
    # 方便做最后判断
    s += '+'
    for i in range(len(s)):
        ch = s[i]
        if ch == ' ':
            continue
        elif ch.isdigit():
            num = num * 10 + ord(ch) - ord('0')
        else:
            if sign == '+':
                stack.append(num)
            elif sign == '-':
                stack.append(-num)
            sign = ch
            num = 0

    return sum(stack)
  1. 处理乘除法
    思路和227一样
def cal2(s):
    num = 0
    stack = []
    sign = '+'
    # 方便做最后判断
    s += '+'
    for i in range(len(s)):
        ch = s[i]
        if ch == ' ':
            continue
        elif ch.isdigit():
            num = num * 10 + ord(ch) - ord('0')
        else:
            if sign == '+':
                stack.append(num)
            elif sign == '-':
                stack.append(-num)
            elif sign == '*':
                stack[-1] *= num
            elif sign == '/':
                stack[-1] = int(stack[-1] / num)
            sign = ch
            num = 0

    return sum(stack)
  1. 处理括号
    如果一个式子带有括号并且是合法的，那么我们将上面的cal2封装为一个函数，给定一个不带括号的式子，它能正确计算并且返回结果，接下来我们只需要处理括号就行了
    思路
    每个括号包裹的式子，我们只需要把它看成一个数字处理就行了
    我们每次碰到左括号的时候，就调用封装的函数来计算，碰到右括号的时候，就结束递归
def calculate(s) -> int:
    def helper(s) -> int:
        num = 0
        stack = []
        sign = '+'
        # 方便做最后判断
        s += '+'
        while len(s) > 0:
            ch = s.pop(0)
            # 碰到左括号，递归计算括号内的式子
            if ch == '(':
                num = helper(s)

            if ch == ' ':
                continue
            elif ch.isdigit():
                num = num * 10 + ord(ch) - ord('0')
            else:
                if sign == '+':
                    stack.append(num)
                elif sign == '-':
                    stack.append(-num)
                elif sign == '*':
                    stack[-1] *= num
                elif sign == '/':
                    stack[-1] = int(stack[-1] / num)
                sign = ch
                num = 0

            # 碰到右括号，结束递归,返回计算的结果
            if ch == ')':
                break

        return sum(stack)

    return helper(list(s))

为了方便处理，我们把s变成list，然后不断弹出左边的字符来判断

不过由于递归开销过大，上面的代码通过不了leetcode的题目

扩展

上面的递归方法能够处理一般的计算器类问题，如果有特殊的符号，例如^，sqrt，需要我们做出一些改动
另外《算法》中有两道题目，感兴趣可以做一下
在这里插入图片描述
这里提示一下，用格式化构造字符串的方式可以很方便的补全
在这里插入图片描述

参考答案：
https://github.com/hhmy27/Alg4_Code/blob/master/src/ch01/part3/ex_1_3_9.java
https://github.com/hhmy27/Alg4_Code/blob/master/src/ch01/part3/InfixToPostfix.java
https://github.com/hhmy27/Alg4_Code/blob/master/src/ch01/part3/EvaluatePostfix.java

参考文章

https://mp.weixin.qq.com/s?__biz=MzAxODQxMDM0Mw==&mid=2247484903&idx=1&sn=184beaad36a71c9a8dd93c41a8ba74ac&chksm=9bd7fbefaca072f9beccff92a715d92ee90f46c297277eec10c322bc5ccd053460da6afb76c2&scene=21#wechat_redirect

https://leetcode-cn.com/problems/basic-calculator-ii/solution/zui-hou-du-bian-cheng-zuo-jia-fa-leetcod-oxx9/

https://leetcode-cn.com/problems/basic-calculator-ii/solution/ji-ben-ji-suan-qi-ii-by-leetcode-solutio-cm28/

https://leetcode-cn.com/problems/basic-calculator/solution/shuang-zhan-jie-jue-tong-yong-biao-da-sh-olym/

hhmy77
关注
专栏目录
2020年 第11届 蓝桥杯 C/C++ B组 省赛真题详解及小结【第1场省赛2020.7.5】【Java版】
upward
08-26 6397
一、试题 A: 跑步训练 方法一 方法二 二、试题 B: 纪念日 方法一：使用“计算器”求解 方法二：使用“日期类”求解（SimpleDateFormat+Date） 方法三：使用“日期类”求解（Date） 三、试题 C: 合并检测 四、试题 D: REPEAT 程序 五、试题 E: 矩阵 六、试题 F: 整除序列 解法一：ArrayList 解法二：快速位运算 七、试题 G: 解码 解法一：替换字符 解法二：boolean isDigit(char ch) 八、试题 H: 走方格 九、试题 I: 整数..
百度的科学计算器（解题报告）
YANG_Gang2017的博客
05-22 1231
题目来自计蒜客 今年，百度的科学计算器进行了重大更新，可以计算更为复杂的表达式了。 定义表达式中存在加减运算、括号、函数调用、强制类型转换这几种运算。其中数值的类型有整型与浮点型两种。并且， 整型与整型加减运算的结果为整型；整型与浮点型加减运算结果为浮点型；浮点型与浮点型加减运算结果为浮点型。 强制类型转换符 包括int(x)与float(x)，其中float(x)运算符可以将
1057：简单计算器 题解 信息学奥赛 NOIP
06-28 599
关于 内容来源于微信公众号：大神编程。已经过原文作者授权。 题目： 1057：简单计算器 超详细动画图文题解链接 题解目录（不断更新中） 喜欢信息学奥赛的同学们，可以一起交流学习哦 官方QQ群：893157498 我的QQ群：795233394 ...
计算机的解题过程
qq_35367566的博客
07-16 1630
现代计算机的解题过程 用户编写的高级语言程序（源程序）→翻译成机器语言程序（目标程序）→运行→结果 过程详述 用户编写好高级语言程序（源程序），然后将它和数据一起送入计算机内，再由计算机将其翻译成机器语言程序，机器自动运行该机器语言程序，并将计算机结果输出。 ...
LeetCode 224. 基本计算器 题解 C/C++
止心的博客
04-21 236
每个数字本身是不会变的，我们只需要控制好它前面的符号。一开始默认符号为正，向栈中压入数字1表示正数，接着遍历字符串，遇到+时，符号保持原样即可，不需要改变，遇到 - 号时符号取负，遇到左括号时我们需要将此时的符号入栈，因为它是控制括号内数字符号的，遇到右括号时将控制该对括号内数字的符号出栈，最后如果是数字则进行计算。 class Solution { public: int calculate(string s) { int len = s.length(); int i = 0,sign .
算法题_简单计算器
欢迎大家关注我
09-21 510
思路：其中加减乘都是通常计算，而幂计算需要用到快速幂。 接下来我们用Python进行编程： n = int(input()) def add(a,b): return (a + b) % 1000000007 def jian(a,b): return (a - b) def mi(a,b): if a == 0: return 0 res = 1 if b < 0: a,b = 1/a, -b while b: if b & 1: res = (re...
矩阵化为行最简形矩阵计算器_leetcode数组--矩阵题目汇总
weixin_39815329的博客
12-06 3301
1252. 奇数值单元格的数目给你一个 n 行 m 列的矩阵，最开始的时候，每个单元格中的值都是 0。另有一个索引数组 indices，indices[i] = [ri, ci] 中的 ri 和 ci 分别表示指定的行和列（从 0 开始编号）。你需要将每对 [ri, ci] 指定的行和列上的所有单元格的值加 1。请你在执行完所有 indices 指定的增量操作后，返回矩阵中 「奇数值单元格」 的数...
2017年第八届蓝桥杯C/C++程序设计本科B组省赛题目汇总
Spf小鱼干
03-23 909
1标题：购物单 小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。 这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。 小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。 现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。 取款机只能提供100元面额的纸币。小明想尽可能少取些现...
数据结构与算法题目及C++解答
热门推荐
Ankang的博客
06-03 1万+
前言 题目主要按照类型进行整理，包括leetcode，nowcoder等网站，对于可以使用多种方法的题目，不重复列举。推荐书籍《数据结构与算法分析--C++语言描述》第四版。 本文中所有源代码及博客中其他文章的VS源代码均在github：https://github.com/AnkangH，根据名称检索即可。 1.排序算法 SortAlgorithm 排序算法的源码见博客内排序算法的文章。...
LeetCode题解汇总
31楼下小黑的博客
08-28 879
97. 交错字符串
计算器（flash）
10-07
flash 编写的简易计算器 有基本的运算 但不能换算16进制等
一个有关计算器的算法题
greenliya的博客
03-29 300
题目：实现一个一位数字的四则运算计算函数，输入是一个char数组，输出是计算结果。 比如输入是char[] inputs = {'1','+','2','*','3'}，输出是7。输入的字符里面，如果是数字，则只有一位；如果是符号，则只有加减乘除四个运算符，没有括号 答案： /** * 确定操作符优先级 * @param first * @param second * @return */ public stati...
面试题 16.26. 计算器 （ 模拟运算 ）
lankerens
12-24 289
LeetCode：面试题 16.26. 计算器 模拟运算题。 传统做法使用两个栈， 一个操作符栈，一个数栈， 然后入栈 出栈就好。 双端队列模拟 代码有点长。 class Solution { public int calculate(String s) { // 栈模拟即可 Deque<Character> oper = new LinkedList<>(); Deque<Integer> num =
LeetCode解题笔记 37 —— 224. 基本计算器
JohnLiu的博客
05-07 631
题目 实现一个基本的计算器来计算一个简单的字符串表达式的值。 字符串表达式可以包含左括号(，右括号)，加号+，减号-，非负整数和空格。 示例 1: 输入: "1 + 1" 输出: 2 示例 2: 输入: " 2-1 + 2 " 输出: 3 示例 3: 输入: "(1+(4+5+2)-3)+(6+8)" 输出: 23 说明： 你可以假设所给定的表达式都是有...
每天一个小题目——计算器的新功能
SmallerNovice的博客
04-02 542
当你学一些可视化程序设计语言时，老师经常会让你设计并且编程做出一个计算器
经典字符串计数器设置题目
从0到1
03-30 768
导文 如何理解程序与计算机硬件的关系？ 程序 = 数据结构 + 算法 计算机= 内存 + cpu CPU负责执行算法，内存负责存储数据结构，因此程序要玩转内存和CPU 题目1 用户出入一个数字 - 判断是几位数 - 打印每一行数字及其重复的次数 - 依次打印每一位数字，顺序个、十、百、千、万.. 解法1:传统解法 1.对用户输入数字进行循环 2.对...
计算器趣题（一）
YangHao5的博客
04-22 546
lz上个月在颓化学竞赛。玩计算器的时候，偶然想到一个游戏，在此放上，以飨读者。 题目描述 今有一计算器，它有且仅有 222 个按键 GT 和 =，它们的描述如下： GT：将计数器数值输出到屏幕； =：将当前输入的表达式的值输出到屏幕，并将结果累加到计数器中。 一开始屏幕显示 111，且计数器初值为 000。 求一种方案，可以用最少的按键次数，使屏幕显示 666666666。 Solution\te...
计算机算法设计与分析——复习题
qq_44691784的博客
12-20 2186
1.快速排序 例题：对数组A={15，29，135，18，32，1，27，25，5}，用快速排序方法将其排成递增序列。简要回答快速排序的思想和上述数组的排序过程。 基本思想 　　在待排序的n个元素中任取一个元素（通常取第一个元素）作为基准，把该元素放入最终位置后，整个数据序列被基准分割成两个子序列，所有小于基准的元素放置在前子序列中，所有大于基准的元素放置在后子序列中，并把基准排在这两个子序列的中...
计算器趣题（二）
YangHao5的博客
04-23 445
上节我们说到，先凑出 373737，再搞出 181818，就能搞出 666666666。 那为什么是这两个数呢？ 尝试把 666666666 质因数分解，得到666=2×32×37666=2\times3^2\times37666=2×32×37发现没？最后的答案 ans=46=(2+3+3+37)+1ans=46=(2+3+3+37)+1ans=46=(2+3+3+37)+1！ 难道这仅是巧合吗...
C++ 编写带优先级的计算器类实现
"本资源是一个C++实现的简单计算器类，具备处理加减乘除运算、优先级、括号以及错误检测功能。用户可以输入任意长度的算式，包括包含函数（如sin、cos等）的表达式。程序通过读取用户输入的字符串，解析并计算出结果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值