《算法系列》之字符串

已于 2022-07-23 17:50:58 修改
阅读量240 收藏 3
点赞数
分类专栏： 算法
于 2022-07-18 17:22:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22136439/article/details/125856026
版权

算法 leetcode 字符串

简介

  字符串是若干字符组成的有限序列，也可以理解为是一个字符数组。在做字符串类的算法题时，API方法对我们的诱惑特别的大，因为主流语言都会有很多处理字符串的方法，我们的题目有时两三行API就能直接被解决了，这显然不是我们刷题的目标，就算只为了过面试也不能直接调API，这样只能回去等通知了。API也不是不能用，当我们觉得，我们的API不影响题目考察的重点时，就可以放心使用！

理论基础

  字符串在存储上类似字符数组，所以它每一位的单个元素都是可以提取的，如s=“abcdefghij”，则s[1]=“b”，s[9]=“j”，这可以给我们提供很多方便，如高精度运算时每一位都可以转化为数字存入数组。觉见的高级语言都有很多处理字符串的方法如：连接、求子串、删除子串、插入子串、求长度、搜索子串位置、大写转换等。我们平时编程处理最多也是字符串，这里就不过多介绍了。最后做字符串类的题目，有时候会用到KMP算法，不了解的同学，可以参考这篇文章：一文读懂 KMP 字符串查找算法。

解题心得

  • 有时可把字符串类的题看做char类型的数组题，很多问题就迎刃而解了。
  • 解题时常会用到递归、双指针、滑动窗口、反转等技巧。
  • 有时字符串算法题可能会用到KMP算法，我们需要重点了解该算法。
  • 做字符串算法题时，不可太过依赖API方法。
  • 字符串类的题目，往往想法很简单，实现起来很考验对代码的掌控能力。

算法题目

6. Z 字形变换

在这里插入图片描述
题目解析：根据Z字形生成规律，直接构造结果字符串。
代码如下：

/**
  * 字符串
  */
class Solution {
    public String convert(String s, int numRows) {

        if (numRows == 1) {
            return s;
        }

        StringBuilder ret = new StringBuilder();
        int n = s.length();
        int cycleLen = 2 * numRows - 2;

        for (int i = 0; i < numRows; i++) {
            // 每次加一个周期
            for (int j = 0; j + i < n; j += cycleLen) {
                ret.append(s.charAt(j + i));
                // 除去第 0 行和最后一行
                if (i != 0 && i != numRows - 1 && j + cycleLen - i < n) {
                    ret.append(s.charAt(j + cycleLen - i));
                }
            }
        }
        return ret.toString();
    }
}
8. 字符串转换整数 (atoi)

在这里插入图片描述
题目解析：从左往右依次处理字符串，去掉无用字符，判断正负，确定数字，最后大小值控制在Integer.MAX_VALUE内即可。
代码如下：

/**
  * 字符串
  */
class Solution {
    public int myAtoi(String s) {
        int sign = 1;
        int ans = 0, pop = 0;
        //代表是否开始转换数字
        boolean hasSign = false;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '-' && !hasSign) {
                sign = -1;
                hasSign = true;
                continue;
            }
            if (s.charAt(i) == '+' && !hasSign) {
                sign = 1;
                hasSign = true;
                continue;
            }
            if (s.charAt(i) == ' ' && !hasSign) {
                continue;
            }

            if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
                hasSign = true;
                pop = s.charAt(i) - '0';
                if (ans * sign > Integer.MAX_VALUE / 10 || (ans * sign == Integer.MAX_VALUE / 10 && pop * sign > 7)) {
                    return 2147483647;
                }
                if (ans * sign < Integer.MIN_VALUE / 10 || (ans * sign == Integer.MIN_VALUE / 10 && pop * sign < -8)) {
                    return -2147483648;
                }
                ans = ans * 10 + pop;
            } else {
                return ans * sign;
            }
        }
        return ans * sign;
    }
}
14. 最长公共前缀

在这里插入图片描述
题目解析：所有字符串从左往右开始比较即可。
代码如下：

/**
  * 字符串
  */
class Solution {
    public String longestCommonPrefix(String[] strs) {

        if (strs == null || strs.length == 0)
            return "";

        StringBuilder res = new StringBuilder();
        for (int i = 0; i < strs[0].length(); i++) {
            Character tmp = strs[0].charAt(i);
            for (int j = 0; j < strs.length; j++) {
                // 如果字符串长度不足或字符不相等，立即中止比较
                if (strs[j].length() - 1 >= i && tmp == strs[j].charAt(i)) {
                    // 比较完一轮后，再添加字符
                    if (j == strs.length - 1) {
                        res.append(tmp);
                    }
                } else {
                    break;
                }

            }
            if (res.length() - 1 != i) {
                break;
            }
        }
        return res.toString();
    }
}
28. 实现 strStr()

在这里插入图片描述
题目解析：这题看上去是道简单题，其实要用KMP算法，再这里骗，偷袭我们这些老师傅。用KMP算法可以提高效率到O(n + m)。不了解KMP算法，可以参考这篇文章：一文读懂 KMP 字符串查找算法。
代码如下：

/**
  * 字符串
  */
class Solution {
	/**
 	*  获取当前模式串的 next[] (回退表)
 	*  这里没有右移一位，如果需要右移，所有值减1即可
 	*/
    public void getNext(int[] next, String s){
		int j = 0;
        next[0] = 0;
        for(int i = 1; i < s.length(); i++) {
        	// j要保证大于0，因为下面有取j-1作为数组下标的操作
            while (j > 0 && s.charAt(i) != s.charAt(j)) { 
                // 注意这里，是要找前一位的对应的回退位置了
                j = next[j - 1]; 
            }
            if (s.charAt(i) == s.charAt(j)) {
                j++;
            }
            next[i] = j;
        }
    }
    
    public int strStr(String haystack, String needle) {
        if(needle.length()==0){
            return 0;
        }

        int[] next = new int[needle.length()];
        getNext(next, needle);
        int j = 0;
        for(int i = 0; i < haystack.length(); i++){
            while(j>0 && haystack.charAt(i) != needle.charAt(j)){
                j = next[j - 1];
            }
            if(haystack.charAt(i) == needle.charAt(j)){
                j++;
            }
            if(j == needle.length() ){
                return (i - needle.length() + 1);
            }
        }

        return -1;
    }
}
38. 外观数列

在这里插入图片描述
在这里插入图片描述
题目解析：采用递归，描述的时候注意多个相同数字要合并描述即可。
代码如下：

/**
 * 递归
 */
class Solution {
    public String countAndSay(int n) {
        // 递归出口
        if (n == 1) return "1";
        // 递归调用
        String result = countAndSay(n - 1);
        StringBuilder temp = new StringBuilder();
        for (int j = 0; j < result.length(); j++) {
            int count = 1;
            char c = result.charAt(j);
            while (j < result.length() - 1 && c == result.charAt(j + 1)) {
                // 计算该字符有多少个
                count++;
                // 指针向后移
                j++;
                c = result.charAt(j);
            }
            // 拼接
            temp.append(count);
            temp.append(c);
        }
        return temp.toString();
    }
}
58. 最后一个单词的长度

在这里插入图片描述
题目解析：从后往前循环查找空格即可，这里需要注意字符串最末尾的空格需要排除。
代码如下：

/**
 * 字符串
 */
class Solution {
    public int lengthOfLastWord(String s) {
        int res = 0;
        // 标志是否已开始统计单词长度
        boolean flag = false;
        for (int i = s.length() - 1; i >= 0; i--) {
            // 开始统计单词后，遇到的第一个空格即为单词分隔
            if (flag && s.charAt(i) == ' ') {
                break;
            }
            // 计数共有多少字母
            if (s.charAt(i) != ' ') {
                flag = true;
                res++;
            }
        }
        return res;
    }
}
65. 有效数字

在这里插入图片描述
题目解析：确定有限状态自动机，太难了，直接看官方答案吧。
代码如下：

/**
 * 确定有限状态自动机
 */
class Solution {
    public boolean isNumber(String s) {
        Map<State, Map<CharType, State>> transfer = new HashMap<State, Map<CharType, State>>();
        Map<CharType, State> initialMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_INTEGER);
            put(CharType.CHAR_POINT, State.STATE_POINT_WITHOUT_INT);
            put(CharType.CHAR_SIGN, State.STATE_INT_SIGN);
        }};
        transfer.put(State.STATE_INITIAL, initialMap);
        Map<CharType, State> intSignMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_INTEGER);
            put(CharType.CHAR_POINT, State.STATE_POINT_WITHOUT_INT);
        }};
        transfer.put(State.STATE_INT_SIGN, intSignMap);
        Map<CharType, State> integerMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_INTEGER);
            put(CharType.CHAR_EXP, State.STATE_EXP);
            put(CharType.CHAR_POINT, State.STATE_POINT);
        }};
        transfer.put(State.STATE_INTEGER, integerMap);
        Map<CharType, State> pointMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_FRACTION);
            put(CharType.CHAR_EXP, State.STATE_EXP);
        }};
        transfer.put(State.STATE_POINT, pointMap);
        Map<CharType, State> pointWithoutIntMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_FRACTION);
        }};
        transfer.put(State.STATE_POINT_WITHOUT_INT, pointWithoutIntMap);
        Map<CharType, State> fractionMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_FRACTION);
            put(CharType.CHAR_EXP, State.STATE_EXP);
        }};
        transfer.put(State.STATE_FRACTION, fractionMap);
        Map<CharType, State> expMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER);
            put(CharType.CHAR_SIGN, State.STATE_EXP_SIGN);
        }};
        transfer.put(State.STATE_EXP, expMap);
        Map<CharType, State> expSignMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER);
        }};
        transfer.put(State.STATE_EXP_SIGN, expSignMap);
        Map<CharType, State> expNumberMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER);
        }};
        transfer.put(State.STATE_EXP_NUMBER, expNumberMap);

        int length = s.length();
        State state = State.STATE_INITIAL;

        for (int i = 0; i < length; i++) {
            CharType type = toCharType(s.charAt(i));
            if (!transfer.get(state).containsKey(type)) {
                return false;
            } else {
                state = transfer.get(state).get(type);
            }
        }
        return state == State.STATE_INTEGER || state == State.STATE_POINT || state == State.STATE_FRACTION || state == State.STATE_EXP_NUMBER || state == State.STATE_END;
    }

    public CharType toCharType(char ch) {
        if (ch >= '0' && ch <= '9') {
            return CharType.CHAR_NUMBER;
        } else if (ch == 'e' || ch == 'E') {
            return CharType.CHAR_EXP;
        } else if (ch == '.') {
            return CharType.CHAR_POINT;
        } else if (ch == '+' || ch == '-') {
            return CharType.CHAR_SIGN;
        } else {
            return CharType.CHAR_ILLEGAL;
        }
    }

    enum State {
        STATE_INITIAL,
        STATE_INT_SIGN,
        STATE_INTEGER,
        STATE_POINT,
        STATE_POINT_WITHOUT_INT,
        STATE_FRACTION,
        STATE_EXP,
        STATE_EXP_SIGN,
        STATE_EXP_NUMBER,
        STATE_END
    }

    enum CharType {
        CHAR_NUMBER,
        CHAR_EXP,
        CHAR_POINT,
        CHAR_SIGN,
        CHAR_ILLEGAL
    }
}
127. 单词接龙

在这里插入图片描述
题目解析：从 beginWord 和 endWord 两边同时开始广度优先搜索，同时一层一层扩展，当发现某一时刻两边都访问过同一顶点时就停止搜索。
代码如下：

/**
 * 双向广度优先搜索
 */
class Solution {
    Map<String, Integer> wordId = new HashMap<String, Integer>();
    List<List<Integer>> edge = new ArrayList<List<Integer>>();
    int nodeNum = 0;

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        for (String word : wordList) {
            addEdge(word);
        }
        addEdge(beginWord);
        if (!wordId.containsKey(endWord)) {
            return 0;
        }

        int[] disBegin = new int[nodeNum];
        Arrays.fill(disBegin, Integer.MAX_VALUE);
        int beginId = wordId.get(beginWord);
        disBegin[beginId] = 0;
        Queue<Integer> queBegin = new LinkedList<Integer>();
        queBegin.offer(beginId);
        
        int[] disEnd = new int[nodeNum];
        Arrays.fill(disEnd, Integer.MAX_VALUE);
        int endId = wordId.get(endWord);
        disEnd[endId] = 0;
        Queue<Integer> queEnd = new LinkedList<Integer>();
        queEnd.offer(endId);

        while (!queBegin.isEmpty() && !queEnd.isEmpty()) {
            int queBeginSize = queBegin.size();
            for (int i = 0; i < queBeginSize; ++i) {
                int nodeBegin = queBegin.poll();
                if (disEnd[nodeBegin] != Integer.MAX_VALUE) {
                    return (disBegin[nodeBegin] + disEnd[nodeBegin]) / 2 + 1;
                }
                for (int it : edge.get(nodeBegin)) {
                    if (disBegin[it] == Integer.MAX_VALUE) {
                        disBegin[it] = disBegin[nodeBegin] + 1;
                        queBegin.offer(it);
                    }
                }
            }

            int queEndSize = queEnd.size();
            for (int i = 0; i < queEndSize; ++i) {
                int nodeEnd = queEnd.poll();
                if (disBegin[nodeEnd] != Integer.MAX_VALUE) {
                    return (disBegin[nodeEnd] + disEnd[nodeEnd]) / 2 + 1;
                }
                for (int it : edge.get(nodeEnd)) {
                    if (disEnd[it] == Integer.MAX_VALUE) {
                        disEnd[it] = disEnd[nodeEnd] + 1;
                        queEnd.offer(it);
                    }
                }
            }
        }
        return 0;
    }

    public void addEdge(String word) {
        addWord(word);
        int id1 = wordId.get(word);
        char[] array = word.toCharArray();
        int length = array.length;
        for (int i = 0; i < length; ++i) {
            char tmp = array[i];
            array[i] = '*';
            String newWord = new String(array);
            addWord(newWord);
            int id2 = wordId.get(newWord);
            edge.get(id1).add(id2);
            edge.get(id2).add(id1);
            array[i] = tmp;
        }
    }

    public void addWord(String word) {
        if (!wordId.containsKey(word)) {
            wordId.put(word, nodeNum++);
            edge.add(new ArrayList<Integer>());
        }
    }
}
165. 比较版本号

在这里插入图片描述
题目解析：字符串分割，然后分区比较，即可得到对比结果。
代码如下：

/**
 * 字符串分割
 */
class Solution {
    public int compareVersion(String version1, String version2) {
        String[] v1 = version1.split("\\.");
        String[] v2 = version2.split("\\.");
        for (int i = 0; i < v1.length || i < v2.length; ++i) {
            int x = 0, y = 0;
            if (i < v1.length) {
                x = Integer.parseInt(v1[i]);
            }
            if (i < v2.length) {
                y = Integer.parseInt(v2[i]);
            }
            if (x > y) {
                return 1;
            }
            if (x < y) {
                return -1;
            }
        }
        return 0;
    }
}
214. 最短回文串

在这里插入图片描述
题目解析：此题也是用KMP算法，可以参考这篇文章：一文读懂 KMP 字符串查找算法。
代码如下：

/**
 * KMP 算法
 */
class Solution {
    public String shortestPalindrome(String s) {
        int n = s.length();
        int[] fail = new int[n];
        Arrays.fill(fail, -1);
        for (int i = 1; i < n; ++i) {
            int j = fail[i - 1];
            while (j != -1 && s.charAt(j + 1) != s.charAt(i)) {
                j = fail[j];
            }
            if (s.charAt(j + 1) == s.charAt(i)) {
                fail[i] = j + 1;
            }
        }
        int best = -1;
        for (int i = n - 1; i >= 0; --i) {
            while (best != -1 && s.charAt(best + 1) != s.charAt(i)) {
                best = fail[best];
            }
            if (s.charAt(best + 1) == s.charAt(i)) {
                ++best;
            }
        }
        String add = (best == n - 1 ? "" : s.substring(best + 1));
        StringBuffer ans = new StringBuffer(add).reverse();
        ans.append(s);
        return ans.toString();
    }
}
回到首页

刷 leetcode 500+ 题的一些感受

下一篇

《算法系列》之双指针

小夏陌
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
字符串hash算法比较
09-20
字符串哈希算法是一种将任意长度的字符串映射到固定长度哈希值的算法，通常用于快速查找、数据索引和内存管理等。在计算机科学中，哈希函数的设计至关重要，因为它直接影响到哈希表的性能。本文将探讨几种经典的字符...
LeetCode字符串刷题分析与总结
ZHOUJIAN_TANK的博客
08-16 762
2020/8/16 15:00 开始 争取刷30-40道 预计2020/8/26 完成
算法刷题总结 (五) 字符串操作
UK - UofL HW - SDE
03-23 1571
字符串是 Python 中最常用的数据类型使用频率非常高，并且它非常灵活有非常多的操作，且拥有非常强大的内置库函数。 字符串经常作为考题出现，或者为其他主题考题的某一部分，所以熟练的掌握字符串的相关操作对自己编程解决问题的能力的提升至关重要。
C++数据结构字符串及KMP匹配算法
01-03
这种自定义的字符串类通常会包含一系列操作方法，如拼接（concatenation）、删除（deletion）、截取（sub-string extraction）、转换（conversion）以及匹配和替换（matching and replacement）。这些功能的实现涉及...
java字符串替换排序实例
09-04
这个实例的核心在于将输入的一行数字字符串处理成一系列非负整数，并按照从大到小的顺序进行排序。以下是这个实例涉及的主要知识点： 1. **字符串操作**：首先，`split("5")`方法用于根据字符'5'将输入字符串分割成...
C#实现字符串SHA-256加密算法
11-16
SHA-256是SHA-2家族的一员，它通过一系列复杂的数学运算（如位操作、异或、旋转等）将输入信息（字符串）转化为一个256位的摘要值。这个摘要具有不可逆性，即无法从摘要还原出原始信息，这使得它成为验证数据完整性...
iOS安全防护系列之字符串及系统函数隐藏详解
08-27
2. **使用对称加密**：除了异或操作，还可以采用更安全的对称加密算法（如AES）来保护字符串。但需要注意的是，对称加密的密钥管理同样重要，不能让密钥直接出现在代码或可执行文件中。 二、隐藏系统函数 1. **...
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 241
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
插入和选择排序
c23856的博客
07-20 225
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 220
完全二叉树的节点个数-递归
python实现图像缩放算法
qq_42568323的博客
07-20 262
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
拆分整数 java
laocooon的博客
07-16 680
输入: n = 10输出: 36解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。输入: n = 2输出: 1解释: 2 = 1 + 1, 1 × 1 = 1。），并使这些整数的乘积最大化。你可以获得的最大乘积。
算法力扣刷题记录 五十【106.从中序与后序遍历序列构造二叉树】和【105.从前序与中序遍历序列构造二叉树】
danaaaa的博客
07-17 1069
构造二叉树
前缀和算法——部分OJ题详解
aaqq800520的博客
07-17 979
（文章的题目解释可能存在一些问题，欢迎各位小伙伴私信或评论指点（双手合十））
面试题 27. 二叉树的镜像
weixin_51332735的博客
07-16 475
请完成一个函数，输入一个二叉树，该函数输出它的镜像。
《算法笔记》总结No.8——双指针
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-17 1047
去年发表过较简单的双指针案例，建议先行阅读~C++实现双指针算法_c++ 双指针排序-CSDN博客文章浏览阅读154次。本贴介绍双指针的入门典例~_c++ 双指针排序https://jslhyh32.blog.csdn.net/article/details/129829790相比说双指针是一种算法，他更倾向是一种编程技巧，话不多说直接看一个引例：如下，给定递增序列【1,3,5,7,9】，寻找到两个相加为16的元素。如果使用暴力的思想，相当于是一个双层循环：外层下标i对应的A[i]和内层下标为j的A[j]之
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 102
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
算法——滑动窗口（day5）
fax_player的博客
07-20 385
（上一题是通过缩小窗口来求长度最小，所以每一次缩小都有可能得到最小长度）（而本题是求最大连续长度，只需要在去除所有重复项后计算就行了）
算法之选择排序
最新发布
SmileAssassn的博客
07-20 201
什么是选择排序呢，就是给你一组无序数组，进行排序，那么从第一个数开始，依次与后面的数进行比较，如果找到最小的，就放在第一位，然后从第二个再进行比较，放在第二个，重复以上操作，直到找到最后一个数，这样就完成了由小到大的一个排序，由大到小也是一样的。本来的想法是找到一个最小的，直接从原来的数组中删除，然后放到新的数组中就好了，但是由于java中的数组删除一个数很麻烦，因此这边直接需要新建个swap方法，专门用来进行数组中的数进行交换使用。输入一组无序数组，然后进行从小到大的排序，并输出最后的结果。
C语言实现字符串匹配算法
本文主要介绍了C语言中与字符串处理相关的数据结构和匹配算法，包括字符串的基本概念、ADTString（字符串抽象数据类型）的定义、基本操作以及串的表示和实现。 在C语言中，字符串是由n（n>=0）个字符组成的有限序列...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小夏陌

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值