力扣算法：344.反转字符串 541.反转字符串|| 05.替换空格 58.左旋转字符串 151.反转字符串中的单词

已于 2022-10-27 11:31:07 修改
阅读量117 收藏
点赞数
文章标签： 算法 leetcode java
于 2022-10-08 21:25:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51982291/article/details/127115760
版权

学习内容

力扣算法：

344.反转字符串

541.反转字符串||

05.替换空格

58.左旋转字符串

151.反转字符串中的单词

具体内容

344.反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：

输入：s = [“h”,“e”,“l”,“l”,“o”] 输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：

输入：s = [“H”,“a”,“n”,“n”,“a”,“h”] 输出：[“h”,“a”,“n”,“n”,“a”,“H”]

提示：

1 <= s.length <= 105
s[i] 都是 ASCII 码表中的可打印字符

题目地址

做题思路

类似前面学过的反转链表一样，用双指针

解题

class Solution {
    public void reverseString(char[] s) {
    	int i=0;
    	int j=s.length-1;
    	while(i < j){
    		char temp = s[i];
    		s[i] = s[j];
    		s[j] = temp;
    		i++;
    		j--;
    	}
    }
}

541.反转字符串||

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

示例 1：

输入：s = “abcdefg”, k = 2 输出：“bacdfeg”

示例 2：

输入：s = “abcd”, k = 2 输出：“bacd”

提示：

1 <= s.length <= 104
s 仅由小写英文组成
1 <= k <= 104

题目地址

做题思路

由于要翻转的是每2 * k 区间的起点到k的距离，因此在for循环里面，直接让i移动2*k，再依次遍历，要是剩余的字段小于k，则进行翻转

解题

class Solution {
    public String reverseStr(String s, int k) {
    	char[] a = s.toCharArray();
    	//题目是以 2k 个字符计数，因此i每次相加间隔为2k
    	for(int i = 0;i < a.length-1;i+=2*k){
    		//若是剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
    		if(i + k <= a.length){
    			reverseString(a,i,i+k-1);
    			//z
    		}else{
    			reverseString(a,i,s.length()-1);
    		}
    	}
    	return new String(a);
    }
    public void reverseString(char[] a,int left,int right){
     	//第一种
    	// while(left < right){
    	// 	char temp = a[left];
    	// 	a[left] = a[right];
    	// 	a[right] = temp;
    	// }
    	//第二种：所用的时间更少
    	for(;left<right;left++,right--){
    		char temp = a[left];
    		a[left] = a[right];
    		a[right] = temp;
    	}
    }
}

解答代码存在的疑问

1、当i + k <= ch.length，为什么翻转是i到i+k-1？
因为k是不断往后移动，且移动的距离是k，减掉1则是我们要反转的位置是前一位数
2、为什么要使用第二种反转？
所用时间更少，效率更好

05.替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = “We are happy.” 输出：“We%20are%20happy.”

限制：
0 <= s 的长度 <= 10000

题目地址

做题思路

可扩充字符串的长度，将空格填充为所需要的内容。要注意题目是将一个空格变成3个新的字符，也就是每个空格对应扩充2个字符

解题

class Solution {
    public String replaceSpace(String s) {
    	//判断代码是否为空，一定要养成好的习惯
    	if(s == null || s.length() == 0){
    		return s;
    	}
    	//先判断字符串出现空格的地方进行扩充,且必须先创建一个StringBuilder对象进行扩充，不能直接在原字符串进行扩充
    	StringBuilder str = new StringBuilder();
    	for(int i = 0;i < s.length();i++){
    		if(s.charAt(i) == ' '){
    		  //注意是填充2个字符
    			str.append("  ");
    		}
    	}
    	//判断str是否为空 若为空则证明原字符串本身没有空格 直接返回原字符串即可
    	if(str == null || str.length() == 0){
    		return s;
    	}
    	//在原来的字符串用left变量赋值最后一个元素，方便后续使用
    	int left = s.length()-1;
    	//对原字符串进行扩充
    	s += str.toString();
    	//在最新的字符串用right变量赋值最后一个元素，方便后续使用
    	int right = s.length()-1;
    	char[] news = s.toCharArray();
    	//依次赋值
    	while(left <= 0){
    		if(news[left] == ' '){
    			news[right--] = '0';
    			news[right--] = '2';
    			news[right] = '%';
    		}else{
    			news[right] = news[left];
    		}
    		//注意要改变left和right的值
    		left--;
         	right--;
    	}
    	return new String(news);
    }
 }

58.左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：

输入: s = “abcdefg”, k = 2 输出: “cdefgab”

示例 2：

输入: s = “lrloseumgh”, k = 6 输出: “umghlrlose”

限制：

1 <= k < s.length <= 10000

题目地址

做题思路

将前n位数的元素进行反转，再反转后n位数，之前再总体反转

解题

class Solution {
    public String reverseLeftWords(String s, int n) {
        char[] k = s.toCharArray();
        reverse(k,0,n-1);
        reverse(k,n,k.length-1);
        reverse(k,0,k.length-1);
        return new String(k);
    }
    public void reverse(char[] a,int left,int right){
        for(;left < right;left++,right--){
            char k = a[left];
            a[left] = a[right];
            a[right] = k;
        }
    }
}

151.反转字符串中的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：

输入：s = “the sky is blue” 输出：“blue is sky the”

示例 2：

输入：s = " hello world " 输出：“world hello” 解释：反转后的字符串中不能存在前导空格和尾随空格

示例 3：

输入：s = “a good example” 输出：“example good a”
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。

提示：

1 <= s.length <= 104
s 包含英文大小写字母、数字和空格 ' '
s 中 至少存在一个 单词

题目地址

做题思路

先把首尾多余空格去掉，翻转整体，通过判断中间的空格位置再把每个单词一一翻过来，且要注意中间也会有多余的空格

解题

	class Solution {
   /**
     * 不使用Java内置方法实现
     * <p>
     * 1.去除首尾以及中间多余空格
     * 2.反转整个字符串
     * 3.反转各个单词
     */
    public String reverseWords(String s) {
        // System.out.println("ReverseWords.reverseWords2() called with: s = [" + s + "]");
        // 1.去除首尾以及中间多余空格
        StringBuilder sb = removeSpace(s);
        // 2.反转整个字符串
        reverseString(sb, 0, sb.length() - 1);
        // 3.反转各个单词
        reverseEachWord(sb);
        return sb.toString();
    }

    private StringBuilder removeSpace(String s) {
        // System.out.println("ReverseWords.removeSpace() called with: s = [" + s + "]");
        int start = 0;
        int end = s.length() - 1;
        while (s.charAt(start) == ' ') start++;
        while (s.charAt(end) == ' ') end--;
        StringBuilder sb = new StringBuilder();
        while (start <= end) {
            char c = s.charAt(start);
            if (c != ' ' || sb.charAt(sb.length() - 1) != ' ') {
                sb.append(c);
            }
            start++;
        }
        // System.out.println("ReverseWords.removeSpace returned: sb = [" + sb + "]");
        return sb;
    }

    /**
     * 反转字符串指定区间[start, end]的字符
     */
    public void reverseString(StringBuilder sb, int start, int end) {
        // System.out.println("ReverseWords.reverseString() called with: sb = [" + sb + "], start = [" + start + "], end = [" + end + "]");
        while (start < end) {
            char temp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, temp);
            start++;
            end--;
        }
        // System.out.println("ReverseWords.reverseString returned: sb = [" + sb + "]");
    }

    private void reverseEachWord(StringBuilder sb) {
        int start = 0;
        int end = 1;
        int n = sb.length();
        while (start < n) {
            while (end < n && sb.charAt(end) != ' ') {
                end++;
            }
            reverseString(sb, start, end - 1);
            start = end + 1;
            end = start + 1;
        }
    }
}

复习

344.反转字符串

class Solution {
    public void reverseString(char[] s) {
    	int i = 0;
    	int j = s.length - 1;
    	while(i < j){
    		char temp = s[i];
    		s[i] = s[j];
    		s[j] = temp;
    		i++;
    		j--;
    	}
    }
}

541.反转字符串||

第一次写，逻辑有问题

class Solution {
    public String reverseStr(String s, int k) {
        char[] a = s.toCharArray();
        for(int i = 0; i < s.length(); i+=2*k){
            //这里的逻辑有误
            if(i + k <= s.length()){
                reverse(a,i,k+i);
            }else{
                reverse(a,k,s.length()-1);
            }
        }
        return new String(a);
    }
    //写出翻转的函数
    public void reverse(char[] a,int left,int right){
        while(left < right){
            char temp = a[left];
            a[left] = a[right];
            a[right] = temp;
            left++;
            right--;
        }
    } 
}

矫正

class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        // 1. 每隔 2k 个字符的前 k 个字符进行反转
        for (int i = 0; i< ch.length; i += 2 * k) {
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= ch.length) {
                reverse(ch, i, i + k -1);
                continue;
            }
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转
            reverse(ch, i, ch.length - 1);
        }
        return  new String(ch);

    }
    // 定义翻转函数
    public void reverse(char[] ch, int i, int j) {
    	for (; i < j; i++, j--) {
        	char temp  = ch[i];
        	ch[i] = ch[j];
        	ch[j] = temp;
    	}
    }
}

05.替换空格

中层逻辑不清楚，且没有判空

class Solution {
    public String replaceSpace(String s) {
        //没有空处理！
    	StringBuilder str = new StringBuilder();
        for(int i = 0; i < s.length();i++){
            if(s.charAt(i) == ' '){
                str.append("  ");
            }
        }
        int left = s.length()-1;
        //处理不对
        s.append(str);
        int right = s.length()-1;
        //这里开始混乱
        while(left < right){
            String k = s.charAt(left);
            if(k == ' '){

            }
        }
    }
}

矫正

class Solution {
    public String replaceSpace(String s) {
    	//没有空处理 -------空处理
    	if(s == null || s.length() == 0){
    		return s;
    	}
    	StringBuilder str = new StringBuilder();
    	for(int i = 0;i < s.length();i++){
    		if(s.charAt(i) == ' '){
    		  //注意是填充2个字符
    			str.append("  ");
    		}
    	}
    	//没有空处理 -------空处理
    	if(str == null || str.length() == 0){
    		return s;
    	}
    	int left = s.length()-1;
    	//处理不对s.append(str); ------- 正确处理
    	s += str.toString();
    	int right = s.length()-1;
    	char[] news = s.toCharArray();
    	//依次赋值
    	while(left <= 0){
    		if(news[left] == ' '){
    			news[right--] = '0';
    			news[right--] = '2';
    			news[right] = '%';
    		}else{
    			news[right] = news[left];
    		}
    		//注意要改变left和right的值
    		left--;
         right--;
    	}
    	return new String(news);
    }
 }

58.左旋转字符串

完全没印象

class Solution {
    public String reverseLeftWords(String s, int n) {
        int len=s.length();
        char[] a = s.toCharArray();
        reverseString(a,0,n-1);
        reverseString(a,n,len-1);
         reverseString(a,0,len-1);
        return new String(a);
    }
     public void reverseString(char[] sb, int start, int end) {
        while (start < end) {
            char temp = sb[start];
            sb[start] = sb[end];
            sb[end] = temp;
            start++;
            end--;
            }
        }
}

151.反转字符串中的单词

报错，看似正确，但没有移除掉空格，也没有判空

class Solution {
    public String reverseWords(String s) {
        char k[] = s.toCharArray();
        int l = 0;
        int r = k.length - 1;
        while(l < r){
            reverse(k,l,r);
        }
        int i = 0;
        int j = 0;
        while(j <= k.length - 1){
            if(k[j] == ' '){
                reverse(k,i,i+j-1);
                i = j+1;
            }
            j++;
        }
        return new String(k);

    }
    public void reverse(char[] a,int left,int right){
        while(left < right){
            char temp = a[left];
            a[left] = a[right];
            a[right] = temp;
            left++;
            right--;
        }
    }
}

矫正

public String reverseWords(String s) {
        // System.out.println("ReverseWords.reverseWords2() called with: s = [" + s + "]");
        // 1.去除首尾以及中间多余空格
        StringBuilder sb = removeSpace(s);
        // 2.反转整个字符串
        reverseString(sb, 0, sb.length() - 1);
        // 3.反转各个单词
        reverseEachWord(sb);
        return sb.toString();
    }

    private StringBuilder removeSpace(String s) {
        // System.out.println("ReverseWords.removeSpace() called with: s = [" + s + "]");
        int start = 0;
        int end = s.length() - 1;
        //去掉首位空格
        while (s.charAt(start) == ' ') start++;
        while (s.charAt(end) == ' ') end--;
        StringBuilder sb = new StringBuilder();
        while (start <= end) {
            char c = s.charAt(start);
            if (c != ' ' || sb.charAt(sb.length() - 1) != ' ') {
                sb.append(c);
            }
            start++;
        }
        // System.out.println("ReverseWords.removeSpace returned: sb = [" + sb + "]");
        return sb;
    }

    /**
     * 反转字符串指定区间[start, end]的字符
     */
    public void reverseString(StringBuilder sb, int start, int end) {
        // System.out.println("ReverseWords.reverseString() called with: sb = [" + sb + "], start = [" + start + "], end = [" + end + "]");
        while (start < end) {
            char temp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, temp);
            start++;
            end--;
        }
        // System.out.println("ReverseWords.reverseString returned: sb = [" + sb + "]");
    }

    private void reverseEachWord(StringBuilder sb) {
        int start = 0;
        int end = 1;
        int n = sb.length();
        while (start < n) {
        		//sb.charAt(end) != ' '判断前面是否有空格
            while (end < n && sb.charAt(end) != ' ') {
                end++;
            }
            reverseString(sb, start, end - 1);
            start = end + 1;
            end = start + 1;
        }
    }
}
菜菜要要努力
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Leetcode 字符串部分： 344.反转字符串 541. 反转字符串II 151.翻转字符串里的单词
2302_80833385的博客
07-31 218
本题比上一个题目难度上升了一些，最关键的步骤在于如何判定达到2k次，我一开始是设置一个变量来计数，这样导致时间复杂度额外多乘了一个n。考察如何构建一个我们自己想要的reverse函数，因为库中自带的reverse函数在区间选择上为。添加空格后，慢指针就亦步亦趋的跟在快指针后向对应位置写入字符，直至下一个循环。快指针就是读指针，要全部读一遍；慢指针就是写指针，只在需要的时候再写。的条件下，只用从i的新位置到末尾反转即可。，来隔开两段字符，获得单词。整体思路与上方两题区别不大，的条件下，则是从i~i+k。
字符串——4.力扣题目：151. 反转字符串中的单词
big_face_kitty的博客
03-21 86
字符串中单词间的顺序反转
力扣：557. 反转字符串中的单词 III
qq_46111138的博客
05-17 242
题目链接：557. 反转字符串中的单词 III 题目： 给定一个字符串 s ，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。 示例 1： 输入：s = “Let’s take LeetCode contest” 输出：“s’teL ekat edoCteeL tsetnoc” 示例 2: 输入： s = “God Ding” 输出：“doG gniD” 提示： 1 <= s.length <= 5 * 104 s 包含可打印的 ASCII 字符。 s 不包含
算法记录 Day8：344.反转字符串 541. 反转字符串II 剑指Offer05.替换空格 151.翻转字符串里的单词 剑指Offer58-II.左旋转字符串
weixin_45004203的博客
11-29 190
刷 Leetcode 算法题目
力扣：151. 反转字符串中的单词344. 反转字符串541. 反转字符串 II
qq_39562292的博客
01-17 388
思路：只考虑需要反转的部分，反转的部分的区间是哪些？假设每次循环都走2k个长度，第i次可反转的区间是[2*i*k,2*i*k+k-1],如果2*i*k+k-1大于s的长度（越界），反转区间就是[2*i*k,s.length-1];思路：该题的关键是如何处理多个空格拆分单词，剩下的就是反转单词，采用双指针的思路；今天分享的都是使用双指针的方法解决的字符串反转问题，希望对大家有说帮助；输入字符串以字符数组。不要给另外的数组分配额外的空间，你必须。中使用至少一个空格将字符串中的。151. 反转字符串中的单词。
力扣算法题557. 反转字符串中的单词 III
Program bear的博客
02-25 363
给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。 示例 1: 输入: “Let’s take LeetCode contest” 输出: “s’teL ekat edoCteeL tsetnoc” 注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。 /** * @param {string} s * @return {stri...
力扣：151.反转字符串里的单词【2023年7月3日学习记录】
2303_81066780的博客
07-03 424
151.反转字符串里的单词（双指针）
字符串反转巧妙处理、拼接、空格的跳跃处理-151. 反转字符串中的单词
FLJS_T的博客
06-13 521
遍历到第一个单词word时，此时fast指针指向word单词后的第一个空格，随后将slow = fast + 1，slow指向了fast指针的后一个位置，如果单词间仅有一个空格，此时fast指针对应的单词为非空格，继续遍历，不会进入字符串提取操作。今天又遇到了曾经做过的题目，对于这道题目，曾经做过几遍了，即使之前做过，今天又遇到这道题目时，对于边界的处理仍然不够完善，浪费了不少的时间。如果是第一个单词，则提取后的单词不需要加空格，如果非第一个单词，则提取后的单词需要加空格，，
刷力扣Day08 | 344.反转字符串 541. 反转字符串II 剑指Offer 05.替换空格 151.翻转字符串里的单词 剑指Offer58-II.左旋转字符串
qq_41864086的博客
12-15 145
day8
(leetcode学习)50. Pow(x, n)
m0_54888411的博客
08-05 150
快速幂，第一次写的时候用 n%2==1，这样不能处理负数的问题。
嵌入式初学-C语言-十五
MaBaB的博客
08-05 483
函数：实现一定功能的，独立的代码模块，我们的函数一定是先定义后使用使用函数的优势可以通过函数提供功能给别人使用，当然我们也可以使用别人提供的函数，减少代码量借助函数可以减少重复性代码。实现结构化（模块化）程序设计思想结构化程序设计思想：将大型的任务功能，划分为相互独立的小型的任务模块来设计3.函数是c语言程序的基本组成单元：C语言程序是由一个（必然是main函数）或多个函数组成。语法：返回类型 函数名(形参列表) -- 函数头 | 函数首部。
PageRank算法与TextRank算法
最新发布
weixin_74254879的博客
08-06 256
PageRank 是一种用于计算网页重要性的算法，其核心思想源自随机浏览模型。这个模型假设一个网络中的用户通过随机点击链接在网页之间跳转，并根据网页的链接结构计算每个网页的重要性。假设三个网页按以下方式连接，计算每个网页的PR值。2最终的 PageRank 值---> tensor([[0.8575, 0.0925, 0.0500]])从结果得出，网页重要性。
HDU - 2057 (纯C语言模拟16进制加减法)
qq_62224565的博客
08-05 200
首先将16进制转成10进制，再将10进制转成16进制。有个问题就是题目说输入不超过15位，但是。第二，使用abs函数时注意，当数爆int时，用long long 储存使用abs会有误。第一，多组输入注意清空字符数组，令每个字符等于’\0’即可。纯模拟，过了后发现可以用%x，直接输入输出。第三，模拟时记得用long long。以前做题没有怎么用C写过HDU的题。就是求16进制的加法。
差分专题的练习
wniuniu_的博客
08-05 117
神经，树状数组做多了一开始还想着用树状数组来查询差分数组，但是我们要进行所有元素的查询，直接过一遍就好啦。就好像这个题目，我们可以小试牛刀直接进行树状数组。
代码随想录算法训练营day34：动态规划02：62.不同路径；63. 不同路径 II；343. 整数拆分；96.不同的二叉搜索树
weixin_65180740的博客
08-05 657
这里要看一下递推公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，dp[i][j]都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。那么很自然，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，因为dp[i][j]只有这两个方向过来。这样就可以保证推导dp[i][j]的时候，dp[i - 1][j] 和 dp[i][j - 1]一定是有数值的。表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。
手搓交换排序、归并排序、计数排序
sparrowfart的博客
08-02 1689
不同于hoare版本的找基准值，通过挖坑法，在循环里，当left == right就直接跳出，hoare版本的left和right相等时需要判断，当前它们所指的值比基准值大还是小，而挖坑法就不需要考虑，left和right相等时，同时指向的位置是一个坑，坑内不存在有效数据，最后直接将基准值填坑即可。先根据最大值最小值的差值开辟空间，若是根据最大值开辟，当最大值为109万，最小值为100，一共有10个数据，此时根据最大值直接开辟空间会很浪费，109个整形大小的空间，只用来存放10个数据。
【算法系列】双指针
GOATLong的博客
08-05 432
常⻅的双指针有两种形式，⼀种是对撞指针，⼀种是左右指针。对撞指针：⼀般⽤于顺序结构中，也称左右指针。• 对撞指针从两端向中间移动。⼀个指针从最左端开始，另⼀个从最右端开始，然后逐渐往中间逼近。• 对撞指针的终⽌条件⼀般是两个指针相遇或者错开（也可能在循环内部找到结果直接跳出循环），也就是：◦ left == right （两个指针指向同⼀个位置）◦ left > right （两个指针错开）
网络流算法：最大流问题
qq_40254606的博客
08-05 313
在一个流网络中，每条边有一个容量，表示该边能够承载的最大流量。容量限制：流量不能超过边的容量。流量守恒：除源点和汇点外，每个顶点的流入量等于流出量。Ford-Fulkerson算法是一种贪心算法，用于解决最大流问题。其核心思想是不断寻找增广路径，直到找不到新的增广路径为止。Edmonds-Karp算法是Ford-Fulkerson算法的一个具体实现，使用广度优先搜索（BFS）来寻找增广路径。该算法的时间复杂度为 (O(VE^2))，其中 (V) 是顶点数，(E) 是边数。
力扣 子字符串在总字符串的出现次数
09-03
你可以使用字符串匹配算法来计算子字符串在总字符串中的出现次数。一个常用的方法是使用滑动窗口技巧。 下面是一个示例代码，它使用滑动窗口来计算子字符串在总字符串中的出现次数： ```python def count_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值