DAY7 字符串1

最新推荐文章于 2024-07-11 21:13:07 发布
最新推荐文章于 2024-07-11 21:13:07 发布
阅读量65 收藏
点赞数
文章标签： 算法 leetcode 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yk2909438315/article/details/131579675
版权

一、344.反转字符串

题目链接：344. 反转字符串 - 力扣（LeetCode）

这道题相等于手写C++里的一个库函数 reverse

我的思路：

 class Solution {
 public:
     void reverseString(vector<char>& s) {
         int total=s.size();
         int front=0;
         int back=total-1;
         for(int i=total/2;i>=0;i--)
         {
             char temp;
             temp=s[front];
             s[front]=s[back];
             s[back]=temp;
             front++;
             back--;
         }
     }
 };

发现是在接近中间部分的时候翻转结果不符合答案，所以我想应该是边界条件没有把握好——》然后发现for循环里面的结束条件应该是i>=1而不是i>=0（其实这个边界在我写的时候我也不确定，只是觉得应该先把思路写完再去判断边界，结果就忘记了——》以后写的时候不确定的地方要加注释！！）

修改后就正确了：

 class Solution {
 public:
     void reverseString(vector<char>& s) {
         int total=s.size();
         int front=0;
         int back=total-1;
         for(int i=total/2;i>=1;i--)
         {
             char temp;
             temp=s[front];
             s[front]=s[back];
             s[back]=temp;
             front++;
             back--;
         }
     }
 };

卡子哥答案：和我的思路一样，直接代码写的更简洁了一点

 class Solution {
 public:
     void reverseString(vector<char>& s) {
         for (int i = 0, j = s.size() - 1; i < s.size()/2; i++, j--) {
             swap(s[i],s[j]);
         }
     }
 };

二、541. 反转字符串II

题目链接：541. 反转字符串 II - 力扣（LeetCode） 

这道题目其实也是模拟，实现题目中规定的反转规则就可以了。

我的思路：思路不是就和上一题一样，只不过每次都需要判断剩余字符的数量

 class Solution {//我这里写的是伪代码，毕竟目前重点是对比思路上的不同
 public:
     string reverseStr(string s, int k) {
         int total=s.size();
         int cur=0;//用来记录每次取出2k个数后，剩余数组成的数组的第一个元素的位置
         for(;total>0;)
         {
             if(total<=k){
             //全部翻转
             total=0;
             }
             else if(total<=2*k && total>k){
             //将前k个值翻转
             total=0;
             }
             else{
             //先计数，取出字符串中前2k个数，然后将前k个数进行翻转
             total-=2*k;
             cur+=2*k;
             }
         }
     }
 };

卡子哥的思路：在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。因为要找的也就是每2 * k 区间的起点，这样写，程序会高效很多。

1.和我一样，只不过他把剩余数组的元素个数大于2k的情况 与 剩余数组元素个数大于k小于2k的情况结合了起来，让代码更简洁了

2.此外，他还用了内置的reverse()函数——注意，reverse函数不是string的成员函数，而是一个通用的库函数。

 class Solution {
 public:
     string reverseStr(string s, int k) {
         for (int i = 0; i < s.size(); i += (2 * k)) {
             // 1. 每隔 2k 个字符的前 k 个字符进行反转
             // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
             if (i + k <= s.size()) {
                 reverse(s.begin() + i, s.begin() + i + k );
             } else {
                 // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
                 reverse(s.begin() + i, s.end());
             }
         }
         return s;
     }
 };

三、剑指Offer 05.替换空格

题目链接：力扣

1.我的思路：

新开一个数组；一个指针i指向原数组，一个指针j指向新开的数组；当遇到空格时，在新数组中加入"%20"这三个字符；其他情况下将原数组中的字符原封不动的复制到新数组中。

代码实现时的疑问：一开始如何确定存储字符串的数组的大小要设为几？——》因为题目给了条件是：字符串s的长度<=10000，所以我设一个长度为30000的数组肯定没有问题。但是有点浪费，因为我设的是最坏情况下数组需要的大小。——》看完卡子哥的代码，我发现s的内容传入以后就固定了，所以我们可以计算出这个字符串s里面有多少个空格，然后就对应扩容多少空间。

2.卡子哥思路：

如果想把这道题目做到极致，就不要使用额外的辅助空间了！

首先扩充数组到每个空格替换成"%20"之后的大小。然后从后向前替换空格，也就是双指针法，过程如下：i指向新长度的末尾，j指向旧长度的末尾。

问题（重点）：为什么要从后向前填充，从前向后填充不行么？

从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素向后移动。

其实很多数组填充类的问题，都可以先预先给数组扩容待填充后的大小，然后在从后向前进行操作。

这么做有两个好处：

  1. 不用申请新数组。

  2. 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。（关键）

我的缺点：给数组扩容的方式有些遗忘——》其实看了卡子哥的思路的时候我觉得我有所遗忘，原因是以前用c语言写数据结构的时候，数组扩容就是申请一个更大的内存空间，如何把数组现有的数值复制进去，然后把原数组释放掉。所以我觉得这好像还是使用了额外的辅助空间。——》但看了卡子哥的代码后发现，那样不算是使用了额外空间；虽然卡子哥使用了string的类内函数resize()，但是这个resize()的源码肯定也是用重新申请一个空间更大的数组的方式来扩容。

 class Solution {
 public:
     string replaceSpace(string s) {
         int count = 0; // 统计空格的个数
         int sOldSize = s.size();
         for (int i = 0; i < s.size(); i++) {
             if (s[i] == ' ') {
                 count++;
             }
         }
         // 扩充字符串s的大小，也就是每个空格替换成"%20"之后的大小
         s.resize(s.size() + count * 2);
         int sNewSize = s.size();
         // 从后先前将空格替换为"%20"
         for (int i = sNewSize - 1, j = sOldSize - 1; j < i; i--, j--) {//j=i的时候就会退出循环--这时j和i都达到了字符串的最左边
             if (s[j] != ' ') {
                 s[i] = s[j];
             } 
             else {
                 s[i] = '0';
                 s[i - 1] = '2';
                 s[i - 2] = '%';
                 i -= 2;
             }
         }
         return s;
     }
 };

  • 时间复杂度：O(n)

  • 空间复杂度：O(1)

此时算上本题，我们已经做了七道双指针相关的题目了分别是：

字符串和数组的区别

字符串是若干字符组成的有限序列，也可以理解为是一个字符数组，但是很多语言对字符串做了特殊的规定，接下来我来说一说C/C++中的字符串。

在C语言中，把一个字符串存入一个数组时，也把结束符 '\0'存入数组，并以此作为该字符串是否结束的标志。

例如这段代码：

 char a[5] = "asd";
 for (int i = 0; a[i] != '\0'; i++) {
 }

在C++中，提供一个string类，string类会提供 size接口，可以用来判断string类字符串是否结束，就不用'\0'来判断是否结束。

例如这段代码:

 string a = "asd";
 for (int i = 0; i < a.size(); i++) {
 }

那么vector< char > 和 string 又有什么区别呢？

其实在基本操作上没有区别，但是 string提供更多的字符串处理的相关接口，例如string 重载了+，而vector却没有。所以想处理字符串，我们还是会定义一个string类型

四、151.翻转字符串里的单词（难）

原题链接;151. 反转字符串中的单词 - 力扣（LeetCode）

给定一个字符串，逐个翻转字符串中的每个单词。

注意：我感觉卡子哥是把string前后只能有一个空格来处理了！那我就这样认为就行了，可能是因为他已经研究过这道题力扣里面的数据集了。

 示例 1：
 输入: "the sky is blue"
 输出: "blue is sky the"
 ​
 示例 2：
 输入: "  hello world!  "
 输出: "world! hello"
 解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
 ​
 示例 3：
 输入: "a good  example"
 输出: "example good a"
 解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个

1.我的想法：我想不出来要怎么翻转单词，因为这道题中单词内部的顺序是不需要翻转的，但上面的翻转的题目都是将一整个string全部翻转，所以我就是没有这个的思路。

2.卡子哥提到的思路：

（1）使用split库函数，分隔单词，然后定义一个新的string字符串，最后再把单词倒序相加——》但是这样的话这道题目就是一道水题了，失去了它的意义。

提高一下本题的难度：不要使用辅助空间，空间复杂度要求为O(1)。

（2）（重要）我们将整个字符串都反转过来，那么单词的顺序指定是倒序了，只不过单词本身也倒序了，那么再把单词反转一下，单词不就正过来了。

所以解题思路如下：

  • 移除多余空格

  • 将整个字符串反转

  • 将每个单词反转

这样我们就完成了翻转字符串里的单词。

3.代码细节：

注意：我感觉卡子哥是把string前后只能有一个空格来处理了！那我就这样认为就行了，可能是因为他已经研究过这道题力扣里面的数据集了。

（1）移除空格

方法一（bad)：

就拿移除多余空格来说，一些同学会上来写如下代码：

 void removeExtraSpaces(string& s) {
     for (int i = s.size() - 1; i > 0; i--) {
         if (s[i] == s[i - 1] && s[i] == ' ') {
             s.erase(s.begin() + i);
         }
     }
     // 删除字符串最后面的空格
     if (s.size() > 0 && s[s.size() - 1] == ' ') {//其实我觉得这里用while更合适，除非规定 每个string前面和后面只会有有一个空格
         s.erase(s.begin() + s.size() - 1);
     }
     // 删除字符串最前面的空格
     if (s.size() > 0 && s[0] == ' ') {
         s.erase(s.begin());
     }
 }

逻辑很简单，从前向后遍历，遇到空格了就erase。

如果不仔细琢磨一下erase的时间复杂度，还以为以上的代码是O(n)的时间复杂度呢。

想一下真正的时间复杂度是多少，一个erase本来就是O(n)的操作。

erase操作上面还套了一个for循环，那么以上代码移除冗余空格的代码时间复杂度为O(n^2)。

方法二：双指针（good）

那么使用双指针法来去移除空格，最后resize（重新设置）一下字符串的大小，就可以做到O(n)的时间复杂度。

 //版本一 
 void removeExtraSpaces(string& s) {
     int slowIndex = 0, fastIndex = 0; // 定义快指针，慢指针
     // 去掉字符串前面的空格
     while (s.size() > 0 && fastIndex < s.size() && s[fastIndex] == ' ') {
         fastIndex++;
     }
     for (; fastIndex < s.size(); fastIndex++) {
         // 去掉字符串中间部分的冗余空格
         if (fastIndex - 1 > 0 && s[fastIndex - 1] == s[fastIndex] && s[fastIndex] == ' ') 
         {
             continue;
         } 
         else 
         {
             s[slowIndex++] = s[fastIndex];//（关键）---双指针的精髓！！
         }
     }
     // 最后去掉字符串末尾的空格
     if (slowIndex - 1 > 0 && s[slowIndex - 1] == ' ') 
     { 
         s.resize(slowIndex - 1);
     } 
     else 
     {
         s.resize(slowIndex); // 重新设置字符串大小
     }
 }

“快慢指针”去除空格的思路：快指针就是快速经过空格位置不停留，直到找到了字符，才停留并召唤slow指针来获取字符。

有的同学可能发现用erase来移除空格，在leetcode上性能也还行。主要是以下几点；：

  1. leetcode上的测试集里，字符串的长度不够长，如果足够长，性能差距会非常明显。

  2. leetcode的测程序耗时不是很准确的。

版本一的代码是一般的思考过程，就是 先移除字符串前的空格，再移除中间的，再移除后面部分。

不过其实还可以优化，这部分和27.移除元素 (opens new window)的逻辑是一样一样的，本题是移除空格，而 27.移除元素 就是移除元素，两道题目都可以使用“双指针法”。

所以代码可以写的很精简，大家可以看 如下 代码 removeExtraSpaces 函数的实现：

 // 版本二 
 void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针。
     int slow = 0;   //整体思想参考https://programmercarl.com/0027.移除元素.html
     for (int i = 0; i < s.size(); ++i) 
     { 
         if (s[i] != ' ') //遇到非空格就处理，即删除所有空格。
         { 
             if (slow != 0) s[slow++] = ' '; //手动给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
             while (i < s.size() && s[i] != ' ') //补上该单词，遇到空格说明单词结束。
             { 
                 s[slow++] = s[i++];//这里i++后若退出了while循环，说明i++后对应的元素为空格；然后最外层for循环又会进行++i，这样就能跳到空格的下一个字符了。（小细节--妙）
             }
         }
     }
     s.resize(slow); //slow的大小即为去除多余空格后的大小。
 }

此时我们已经实现了removeExtraSpaces函数来移除冗余空格。

还要实现反转字符串的功能，支持反转字符串子区间，这个实现我们分别在344.反转字符串 (opens new window)和541.反转字符串II (opens new window)里已经讲过了。

代码如下：

 // 反转字符串s中左闭右闭的区间[start, end]
 void reverse(string& s, int start, int end) {
     for (int i = start, j = end; i < j; i++, j--) {
         swap(s[i], s[j]);
     }
 }

整体代码如下：

 class Solution {
 public:
     void reverse(string& s, int start, int end){ //翻转，区间写法：左闭右闭 []
         for (int i = start, j = end; i < j; i++, j--) {
             swap(s[i], s[j]);
         }
     }
 ​
     void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针。
         int slow = 0;   //整体思想参考https://programmercarl.com/0027.移除元素.html
         for (int i = 0; i < s.size(); ++i) { //
             if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。
                 if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
                 while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。
                     s[slow++] = s[i++];
                 }
             }
         }
         s.resize(slow); //slow的大小即为去除多余空格后的大小。
     }
 ​
     string reverseWords(string s) {
         removeExtraSpaces(s); //去除多余空格，保证单词之间之只有一个空格，且字符串首尾没空格。
         reverse(s, 0, s.size() - 1);
         int start = 0; //removeExtraSpaces后保证第一个单词的开始下标一定是0。
         for (int i = 0; i <= s.size(); ++i) {
             if (i == s.size() || s[i] == ' ') { //到达空格或者串尾，说明一个单词结束。进行翻转。
                 reverse(s, start, i - 1); //翻转，注意是左闭右闭 []的翻转。
                 start = i + 1; //更新下一个单词的开始下标start
             }
         }
         return s;
     }
 };

  • 时间复杂度: O(n)

  • 空间复杂度: O(1) 或 O(n)，取决于语言中字符串是否可变

本题思路中最独特的地方就是“整体反转+局部反转”

五、剑指Offer58-II.左旋转字符串

题目链接：力扣

我的思路：把数组头部的元素运到数组尾部

 class Solution {
 public:
     string reverseLeftWords(string s, int n) {
         int end=s.size()-1;
         for(int i=0;i<n;i++)
         {
            //把数组中前n个数字另开一个数组nums把里面的值给记录下来
         }
         for(){
             //把数组中n个以外的数组往前移动
         }
         for(){
             //再把nums数组中的元素放到原数组的后面
         }
     }
 };

卡子哥思路：

为了让本题更有意义，提升一下本题难度：不能申请额外空间，只能在本串上操作。

不能使用额外空间的话，模拟在本串操作要实现左旋转字符串的功能还是有点困难的。

那么我们可以想一下上一题目字符串：花式反转还不够！ (opens new window)中讲过，使用整体反转+局部反转就可以实现反转单词顺序的目的。

这道题目也非常类似，依然可以通过局部反转+整体反转 达到左旋转的目的（精髓）。

具体步骤为：

  1. 反转区间为前n的子串

  2. 反转区间为n到末尾的子串

  3. 反转整个字符串

最后就可以达到左旋n的目的，而不用定义新的字符串，完全在本串上操作。

例如 ：示例1中 输入：字符串abcdefg，n=2

最终得到左旋2个单元的字符串：cdefgab

思路明确之后，那么代码实现就很简单了

C++代码如下：

 class Solution {
 public:
     string reverseLeftWords(string s, int n) {
         reverse(s.begin(), s.begin() + n);
         reverse(s.begin() + n, s.end());
         reverse(s.begin(), s.end());
         return s;
     }
 };

  • 时间复杂度: O(n)

  • 空间复杂度：O(1)

2909438315
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
非常全面的python字符串相关处理方法
景天科技苑
01-03 9177
python字符串相关操作汇总
Day1 字符数组char[]和string字符串赋值
m0_48028149的博客
08-04 4158
Day1 字符数组char[]和string字符串赋值 一、字符数组char[]类型赋值 1.当定义了数组大小后，两个数组间可以按位赋值，例如： #include<iostream> #include<string> using namespace std; int main() { char a[5]={'1','2','3','4'}; char b[5]; //声明数组b的大小 for(int i=0;i<5;i++) { b[i]=a[i]; //按位赋值
C++字符串处理专题
wow_awsl_qwq的博客
03-13 6775
7-1 字符串排序 本题要求编写程序，读入5个字符串，按由小到大的顺序输出。 输入格式： 输入为由空格分隔的5个非空字符串，每个字符串不包括空格、制表符、换行符等空白字符，长度小于80。 输出格式： 按照以下格式输出排序后的结果： After sorted: 每行一个字符串 输入样例： red yellow blue black white 输出样例： After sorted: black blue red white yellow #include <bits/stdc++.h> usin
C语言中字符串详解
weixin_46093842的博客
03-02 4365
C语言中字符串详解 字符串时是C语言中非常重要的部分，我们从字符串的性质和字符串的创建、程序中字符串的输入输出和字符串的操作来对字符串进行详细的解析。 什么是字符串？ C语言本身没有内置的字符串类型，字符串本质上是一种特殊类型的数组，它的组成元素类型为char，除此之外不受制与数组长度的限制，以'\0'作为结束标志，作为字符串结束的标志。（\0作为一个特殊字符，它的ASCII值为0，但是它不是'0'字符，'0'字符的ASCII值为48。） 定义字符串 1. 字符串字面量（字符串常量） 字符串字面量
7-1 字符串的冒泡排序
韩旭051的博客
07-17 3326
暑假字符串专题HBU程序设计训练营总结
python字符串练习题
weixin_53049621的博客
07-28 5487
1.去掉字符串所有空格 str = "today is a good day" a = "" for i in str: if i != " ": a += i print(a) #字符串方法 a = str.split(" ") c = "".join(a) print(c) 2.根据完整路径从路径中分离文件路径，文件名及文件扩展名 注意python中一个反斜杠有特殊含义，所以要用二个反斜杠 str2 = "D:\\软件\python\\python39\\Tools\scri
python 字符串赋值操作_python字符串操作
热门推荐
weixin_39767887的博客
12-06 1万+
字符串简介字符串序列用于表示和存储文本，python中字符串是不可变的，一旦声明，不能改变这里的的改变，指的是声明变量后的真实对象。但如果第二次用到变量，赋值，系统会默认为你新生成一个变量。比如：>>> a='11'>>> print id(a)41264744>>> a='22'>>> print id(a)41264648...
java 字符串输出字符_输出java字符串
weixin_36334284的博客
02-20 3210
1-1 字符串排序用Java编写一个能对一组字符串按字典序升序排序的程序 输入为N和N行字符串，需要按行输出字符串升序排序的结果 如输入3AbcAbeAbd输出：AbcAbdAbeimport java.util.Arrays;import java.util.Scanne...文章uiiuiiu2018-07-13951浏览量怎样解决Java/J2EE中文问题大部分程序员在编程中都遇到过Java...
分割字符串c语言strsep,C语言 字符串切割
weixin_42361623的博客
05-17 2745
#include #include #include /* 字符串切割函数 *//*知识补充:1. 函数原型:char *strtok(char *str, const char *delim);char *strsep(char **stringp, const char *delim);2. 功能:strtok和strsep两个函数的功能都是用来分解字符串为一组字符串。str为要分解的字符串，...
字符型指针，数组，字符串赋值
wywbzan的博客
07-23 2495
一、 C语言中，为什么字符串可以赋值给字符指针变量 char *p,a='5'; p=&a;                     //显然是正确的， p="abcd";  &nbsp...
深入浅出字符串-day3
12-20
1. **索引和切片**：可以通过索引访问字符串中的单个字符，如`str[0]`，也可以通过切片获取子字符串，如`str[1:5]`。 2. **连接**：使用`+`操作符可以连接两个字符串，如`str1 + str2`。 3. **复制**：使用`*`操作符...
java获取昨天日期字符串的方法
09-01
在Java编程中，获取昨天日期字符串涉及到对日期和时间的操作，这通常需要用到`java.util`和`java.text`包中的类。以下是一个详细的解释和示例代码，展示如何实现这个功能。 首先，我们需要导入必要的库： ```java ...
day1变量及字符串.zip
10-14
今天我们将深入探讨“day1变量及字符串”的主题，通过学习这些基础知识，你可以为后续更复杂的编程任务打下坚实的基础。 首先，我们来看“变量”。在Python中，变量是用来存储数据的容器。当你创建一个变量时，你是...
Python合并字符串的3种方法
09-22
在上述例子中，`%s`表示字符串，`%.1f`表示保留一位小数的浮点数。 3. **使用`str.join()`方法** `str.join()`方法是最高效的字符串合并方式，特别是当处理大量字符串时。它通过指定的分隔符连接列表中的所有...
php中利用explode函数分割字符串到数组
10-26
这段代码将日期字符串`$date`按照斜线、点或横线分割，结果分别赋值给`$month`、`$day`和`$year`。 在实际应用中，有时我们需要处理更复杂的字符串处理场景，例如多条件查询。给出的示例展示了如何构建SQL查询条件...
36. Adam 算法详解
qq_41238579的博客
07-10 938
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
代码随想录算法训练营第33天
m0_62262158的博客
07-10 158
【代码】代码随想录算法训练营第33天。
代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树
最新发布
wonderlandlja的博客
07-11 184
【代码】代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树。
【代码随想录算法训练营第六十二天|卡码网53.寻宝（prim算法和kruskal算法）】
weixin_46281930的博客
07-09 474
kruskal算法以边为导向，先把边按照长度从小到大排序，然后一个个检查边的两个端点是否在同一个集合中（这里使用并查集判断），在同一个集合中就不加入这个边，不在的话就加入。可以把所有已经使用过的结点看作一个整体，然后把他们相接的结点的结点顶点边中进行选择，选择最短的一条边把该结点入树，某种程度来说也是一种贪心？1.选择当前最短入树结点；3.更新结点距离最小生成树的距离。
字符串数组中如何删除数字1c语言
05-20
可以使用循环遍历字符串数组，判断每个字符串是否包含数字1，如果包含则删除该字符串。 具体实现方法如下： ```c #include <stdio.h> #include <string.h> #include <ctype.h> int main() { char strArr[10][20] = {"hello", "world1", "123", "456", "789", "test1", "good", "morning", "happy1", "day"}; int len = sizeof(strArr) / sizeof(strArr[0]); // 数组长度 for (int i = 0; i < len; i++) { // 判断字符串中是否包含数字1 int hasOne = 0; for (int j = 0; j < strlen(strArr[i]); j++) { if (isdigit(strArr[i][j]) && strArr[i][j] == '1') { hasOne = 1; break; } } // 删除包含数字1的字符串 if (hasOne) { for (int k = i; k < len - 1; k++) { strcpy(strArr[k], strArr[k + 1]); } len--; // 数组长度减1 i--; // 继续遍历当前位置 } } // 输出处理后的字符串数组 for (int i = 0; i < len; i++) { printf("%s\n", strArr[i]); } return 0; } ``` 输出结果为： ``` hello 456 789 good morning day ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值