字符串2s总结

4.字符串

字符串理论基础

什么是字符串

字符串是若⼲字符组成的有限序列,也可以理解为是⼀个字符数组,但是很多语⾔对字符串做了特殊的规定,接下来我来说⼀说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类型。

字符串套路总结

双指针法

在344.反转字符串 (opens new window),我们使用双指针法实现了反转字符串的操作,双指针法在数组,链表和字符串中很常用。

接着在字符串:替换空格 (opens new window),同样还是使用双指针法在时间复杂度O(n)的情况下完成替换空格。

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

那么针对数组删除操作的问题,其实在27. 移除元素 (opens new window)中就已经提到了使用双指针法进行移除操作。

同样的道理在151.翻转字符串里的单词 (opens new window)中我们使用O(n)的时间复杂度,完成了删除冗余空格。

反转系列

在反转上还可以在加一些玩法,其实考察的是对代码的掌控能力。

541. 反转字符串II (opens new window)中,一些同学可能为了处理逻辑:每隔2k个字符的前k的字符,写了一堆逻辑代码或者再搞一个计数器,来统计2k,再统计前k个字符。

其实当需要固定规律一段一段去处理字符串的时候,要想想在在for循环的表达式上做做文章

只要让 i += (2 * k),i 每次移动 2 * k 就可以了,然后判断是否需要有反转的区间。

因为要找的也就是每2 * k 区间的起点,这样写程序会高效很多。

在151.翻转字符串里的单词 (opens new window)中要求翻转字符串里的单词,这道题目可以说是综合考察了字符串的多种操作。是考察字符串的好题。

这道题目通过 先整体反转再局部反转,实现了反转字符串里的单词。

后来发现反转字符串还有一个牛逼的用处,就是达到左旋的效果。

在字符串:反转个字符串还有这个用处? (opens new window)中,我们通过先局部反转再整体反转达到了左旋的效果

KMP

什么是KMP

说到KMP,先说一下KMP这个名字是怎么来的,为什么叫做KMP呢。

因为是由这三位学者发明的:Knuth,Morris和Pratt,所以取了三位学者名字的首字母。所以叫做KMP

KMP有什么用

KMP主要应用在字符串匹配上。

KMP的主要思想是当出现字符串不匹配时,可以知道一部分之前已经匹配的文本内容,可以利用这些信息避免从头再去做匹配了。

所以如何记录已经匹配的文本内容,是KMP的重点,也是next数组肩负的重任

什么是前缀表

写过KMP的同学,一定都写过next数组,那么这个next数组究竟是个啥呢?

next数组就是一个前缀表(prefix table)。

前缀表有什么作用呢?

前缀表是用来回退的,它记录了模式串与主串(文本串)不匹配的时候,模式串应该从哪里开始重新匹配。前缀表是如何记录的呢?

首先要知道前缀表的任务是当前位置匹配失败,找到之前已经匹配上的位置,再重新匹配,此也意味着在某个字符失配时,前缀表会告诉你下一步匹配中,模式串应该跳到哪个位置。

那么什么是前缀表:记录下标i之前(包括i)的字符串中,有多大长度的相同前缀后缀。

最长公共前后缀

文章中字符串的前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串

后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串

正确理解什么是前缀什么是后缀很重要!

因为前缀表要求的就是相同前后缀的长度。

而最长公共前后缀里面的“公共”,更像是说前缀和后缀公共的长度。这其实并不是前缀表所需要的。

所以字符串a的最长相等前后缀为0。 字符串aa的最长相等前后缀为1。 字符串aaa的最长相等前后缀为2。 等等…。

为什么一定要用前缀表

这就是前缀表,那为啥就能告诉我们 上次匹配的位置,并跳过去呢?

回顾一下,刚刚匹配的过程在下标5的地方遇到不匹配,模式串是指向f,如图: KMP精讲1

然后就找到了下标2,指向b,继续匹配:如图: KMP精讲2

以下这句话,对于理解为什么使用前缀表可以告诉我们匹配失败之后跳到哪里重新匹配 非常重要!

下标5之前这部分的字符串(也就是字符串aabaa)的最长相等的前缀 和 后缀字符串是 子字符串aa ,因为找到了最长相等的前缀和后缀,匹配失败的位置是后缀子串的后面,那么我们找到与其相同的前缀的后面重新匹配就可以了。

所以前缀表具有告诉我们当前位置匹配失败,跳到之前已经匹配过的地方的能力。

很多介绍KMP的文章或者视频并没有把为什么要用前缀表?这个问题说清楚,而是直接默认使用前缀表。

如何计算前缀表

接下来就要说一说怎么计算前缀表。

如图:

KMP精讲5

长度为前1个字符的子串a,最长相同前后缀的长度为0。(注意字符串的前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。)

KMP精讲6

长度为前2个字符的子串aa,最长相同前后缀的长度为1。

KMP精讲7

长度为前3个字符的子串aab,最长相同前后缀的长度为0。

以此类推: 长度为前4个字符的子串aaba,最长相同前后缀的长度为1。 长度为前5个字符的子串aabaa,最长相同前后缀的长度为2。 长度为前6个字符的子串aabaaf,最长相同前后缀的长度为0。

那么把求得的最长相同前后缀的长度就是对应前缀表的元素,如图: KMP精讲8

可以看出模式串与前缀表对应位置的数字表示的就是:下标i之前(包括i)的字符串中,有多大长度的相同前缀后缀。

再来看一下如何利用 前缀表找到 当字符不匹配的时候应该指针应该移动的位置。如动画所示:

KMP精讲2

找到的不匹配的位置, 那么此时我们要看它的前一个字符的前缀表的数值是多少

为什么要前一个字符的前缀表的数值呢,因为要找前面字符串的最长相同的前缀和后缀。

所以要看前一位的 前缀表的数值。

前一个字符的前缀表的数值是2, 所以把下标移动到下标2的位置继续比配。 可以再反复看一下上面的动画。

最后就在文本串中找到了和模式串匹配的子串了。

前缀表与next数组

很多KMP算法的实现都是使用next数组来做回退操作,那么next数组与前缀表有什么关系呢?

next数组就可以是前缀表,但是很多实现都是把前缀表统一减一(右移一位,初始位置为-1)之后作为next数组。

为什么这么做呢,其实也是很多文章视频没有解释清楚的地方。

其实这并不涉及到KMP的原理,而是具体实现,next数组既可以就是前缀表,也可以是前缀表统一减一(右移一位,初始位置为-1)。

后面我会提供两种不同的实现代码,大家就明白了。

使用next数组来匹配

以下我们以前缀表统一减一之后的next数组来做演示

有了next数组,就可以根据next数组来 匹配文本串s,和模式串t了。

注意next数组是新前缀表(旧前缀表统一减一了)。

匹配过程动画如下:

KMP精讲4

时间复杂度分析

其中n为文本串长度,m为模式串长度,因为在匹配的过程中,根据前缀表不断调整匹配的位置,可以看出匹配的过程是O(n),之前还要单独生成next数组,时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。

暴力的解法显而易见是O(n × m),所以KMP在字符串匹配中极大地提高了搜索的效率。

为了和力扣题目28.实现strStr保持一致,方便大家理解,以下文章统称haystack为文本串, needle为模式串。

都知道使用KMP算法,一定要构造next数组。

还是感觉太复杂,直接用string::find()来代替KMP功能

练习

Hjk掌握的单词个数

题目描述
有一个字符串数组 words 和一个字符串 chars。

假如可以用 chars 中的字母拼写出 words 中的某个“单词”(字符串),那么我们就认为你掌握了这个单词。

words 的字符仅由 a-z 英文小写字母组成,例如 “abc”

chars 由 a-z 英文小写字母和 “?” 组成。其中英文 “?” 表示万能字符,能够在拼写时当作任意一个英文字母。例如:“?” 可以当作 “a” 等字母。

注意:每次拼写时,chars 中的每个字母和万能字符都只能使用一次。

输出词汇表 words 中你掌握的所有单词的个数。没有掌握任何单词,则输出0。

输入描述
第一行:输入数组 words 的个数,记作N。
第二行 ~ 第N+1行:依次输入数组words的每个字符串元素
第N+2行:输入字符串chars

3
blue
hair
id
bd?lue

输出描述
输出一个整数,表示词汇表 words 中你掌握的单词个数

2

备注
1 ≤ words.length ≤ 100
1 ≤ words[i].length, chars.length ≤ 100
所有字符串中都仅包含小写英文字母、英文问号

首先读入words数组的大小和元素,然后读入chars字符串。接着,它使用getwords函数来计算可以使用chars字符串中的字符(包括万能字符)拼写的单词数量。canspell函数用于判断单个单词是否可以被拼写,通过对字符的使用计数和处理万能字符的逻辑。最后,程序输出掌握的单词数量。

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>

bool canspell(std::string& word, std::unordered_map<char, int> charsmap, int wildcount ) {
    for(char c: word) {
        if (charsmap[c] > 0) {
            charsmap[c] --;
        }
        else if (wildcount > 0) { // 如果有通配符可用
            wildcount--;
        } else { // 如果字符不在映射中且没有通配符可用
            return false;
        }
    }
    return true;
}
    
int getwords(std::vector<std::string>& words, const std::string& chars) {
    std::unordered_map<char, int> charsmap;
    int wildcount = 0;
    for (char i: chars) {
        if (i == '?') wildcount ++;
        else charsmap[i] ++;
    }
    int count = 0;
    for (std::string word: words) {
        if (canspell(word, charsmap, wildcount)) {
            count ++;
        }
    }
    return count;
}

int main() {
    //处理输入
    int N;
    std::cin >> N;
    std::cin.ignore();
    std::vector<std::string> words(N);
    for (int i = 0; i < N; i ++) {
        std::getline(std::cin, words[i]);
    }
    std::string chars;
    std::getline(std::cin, chars);
    std::cout << getwords(words, chars) << std::endl;
    return 0;
    
}

Hkj url拼接

拼接URL
题目描述
给定一个url前缀和url后缀,通过,分割 需要将其连接为一个完整的url
如果前缀结尾和后缀开头都没有/,需要自动补上/连接符
如果前缀结尾和后缀开头都为/,需要自动去重
约束:不用考虑前后缀URL不合法情况
输入描述:
url前缀(一个长度小于100的字符串) url后缀(一个长度小于100的字符串)

输出描述:
拼接后的url

示例

输入: /acm,/bb
输出: /acm/bb

输入: /abc/,/bcd
输出: /abc/bcd

输入: /acd,bef
输出: /acd/bef

输入: ,
输出: /

Hkj字符串切割方法

给定一个由小写字母组成的字符串。请找出两个位置,将字符串分为三部分。这三部分的总和应该是相同的,其中每部分的总和是其字符的ASCII码值的总和。注意,这两个位置的字符不包括在这三部分内。

如果你找到了这两个位置,请输出它们的位置。如果没有找到,请输出0,0。

例子:

输入: acdbbbca
输出: 2,5
这是因为当我们在位置2和5进行分割,我们得到三个部分:ac,bb,ca。它们的ASCII码值的总和都是相同的。

输入: abcabc
输出: 0,0
在这个例子中,我们找不到这样的两个位置。

题目分析

遍历字符串,尝试所有可能的两个位置作为分割点,然后比较这三部分的ASCII值之和。为了高效计算,我们可以首先计算字符串的累积ASCII值之和,这样就可以在常数时间内获取任何子字符串的ASCII值之和。

#include <iostream>
#include <string>
#include <vector>

int main() {
    std::string s;
    std::getline(std::cin, s);

    //定义前缀和
    int n = s.size();
    std::vector<int> prefixsum(n + 1, 0);
    for (int i = 1; i <= s.size(); i++) {
        prefixsum[i] = prefixsum[i - 1] + s[i - 1];
    }

    bool find = false;
    for (int i = 0; i < n; i++) {
        for (int j = i + 2; j < n; j++) {
            int sum1 = prefixsum[i] - prefixsum[0]; // 第一部分的和
            int sum2 = prefixsum[j] - prefixsum[i + 1]; // 第二部分的和
            int sum3 = prefixsum[n] - prefixsum[j + 1]; // 第三部分的和
            if (sum1 == sum2 && sum2 == sum3) {
                std::cout <<  i << "," << j <<std::endl;
                find = true;
            }
        }
    }

    if (!find) std::cout <<"0,0" << std::endl;


    return 0;

}

Hjk回文字符串

什么是"回文串"?就是一个字符串正着读和反着读都一样,而且要注意大小写的区别。

例如:
"leVel"是一个回文串,因为正着反着都一样。
"art"就不是,反过来就变成"tra"了。
"Level"也不是,因为大小写不同。

现在,你要做的就是用给定的一个字符串(只含有大小写字母)来构建一个最长的回文串。有一个小要求:每个字母只能用一次,或者干脆不用。如果最长的回文串有好几个,那就选字母顺序最小的那个返回。

比如:输入"abczcccddzz",你可以构造出"ccdzazdcc"这样一个回文串。

为了构建给定字符串中可能的最长回文串,我们可以遵循以下步骤:

  1. 计数每个字符的出现次数:首先,我们需要计算字符串中每个字符出现的次数。这可以通过使用一个字符到其出现次数的映射(例如,使用std::map<char, int>)来完成。
  2. 构造回文串:接下来,我们可以使用每个字符的最大偶数出现次数来构造回文串的一半。如果有字符出现了奇数次,我们可以选择其中一个作为中心字符(如果有多个奇数出现的字符,选择字母顺序最小的那个作为中心)。构造过程中,对于每个字符,将它的一半加到回文串的一侧,然后如果有中心字符,将其放在中间,最后按相反顺序将字符加到回文串的另一侧。
  3. 返回结果:构造完成后,我们得到的就是满足条件的最长回文串。
#include <iostream>
#include <string>
#include <map>
#include <algorithm>

int main() {
    std::string s;
    std::getline(std::cin, s);
    std::map<char, int> charsmap;
    for (int i = 0; i < s.size(); i++){
        charsmap[s[i]] ++;
    }

    //构建回文串
    char center = '\0';
    std::string palindromehalf;
    for (auto chars : charsmap) {
        if (chars.second % 2 == 1 && (center == '\0' || chars.first < center)) {
            center = chars.first;
        }
        else palindromehalf.append(std::string(chars.second / 2, chars.first));
    }
    std::string palindrome = palindromehalf;
    if (center != '\0') palindrome += center;
    std::reverse(palindromehalf.begin(), palindromehalf.end());
    palindrome += palindromehalf;

    std::cout << palindrome << std::endl;
    return 0;
}

Hjk IPV4地址转化为整数

存在一种虚拟IPv4地址,由4小节组成,每节的范围为0~255,以#号间隔,虚拟IPv4地址可以转换为一个32位的整数,例如:

128#0#255#255,转换为32位整数的结果为2147549183(0x8000FFFF)1#0#0#0,转换为32位整数的结果为16777216(0x01000000)

现以字符串形式给出一个虚拟IPv4地址,限制第1小节的范围为1128,即每一节范围分别为(1128)#(0255)#(0255)#(0-255),要求每个IPV4地址只能对应到唯一的整数上。如

果是非法IPV4,返回invalidIP

输入描述

输入一行,虚拟IPv4地址格式字符串

输出描述

输出一行,按照要求输出整型或者特定字符

示例

输入: 100#101#1#5
输出: 1684340997

输入: 1#2#3
输出: invalid IP

分析

split函数:将输入的字符串按指定的分隔符(在这个例子中是#)分割成子字符串,并将它们存储在一个vector<string>中返回。

convertToInteger函数:将存储有四部分虚拟IPv4地址的字符串数组转换为一个32位的整数。这是通过将每部分解析为整数,然后左移适当的位数(基于它是地址中的哪一部分)并通过位或操作合并到结果中实现的。

isValidIP`函数:验证输入的虚拟IPv4地址是否合法。它检查地址是否有四部分,并且每部分的数值是否在合法范围内(对于第一部分是1到128,其余部分是0到255)。

**main函数**:读取输入,使用split函数分割输入的虚拟IPv4地址,然后检查它是否合法。如果地址合法,它将调用convertToInteger`函数来转换地址,并输出结果;否则,输出"invalid IP"。

#include <iostream>
#include <vector>
#include <string>
#include <sstream>

std::vector<std::string> split(std::string& s) {
    std::stringstream ss(s);
    std::string token;
    std::vector<std::string> parts;
    while (std::getline(ss, token, '#')) {
        parts.push_back(token);
    }
    return parts;
}

bool isvalid(std::vector<std::string>& parts) {
    if (parts.size() != 4) return false;
    for (int i = 0; i < parts.size(); i++) {
        int num = std::stoi(parts[i]);
        if (i == 0 && (num < 1 || num > 128)) {
            return false;
        }
        else if (num < 0 || num > 255) {
            return false;
        }
    }
    return true;
}

unsigned long getres(std::vector<std::string>& parts) {
    unsigned long res = 0;
    for (int i = 0; i < parts.size(); i++) {
        res |= std::stoul(parts[i]) << (3 - i)*8;
    }
    return res;
}


int main() {
    std::string s;
    std::getline(std::cin, s);
    //分割string存入vector
    std::vector<std::string> parts = split(s);

    //判断IP是否有效
    if (!isvalid(parts)) {
        std::cout << "invalid IP" << std::endl;
    }
    // 计算整数
    else {
        unsigned int res = getres(parts);
        std::cout << res << std::endl;
    }
  
    return 0;
}

Hjk响应报文时间

假设你正在接收网络报文,并且需要在一定时间内对它们作出响应。每次当你收到一个报文时,它会有一个“最大响应时间”来告诉你最晚需要在什么时候回应。但是,如果在等待回应期间又收到了新的报文,你可能需要更新你的响应时间。

“最大响应时间”是这样计算的:

如果它的代码小于128,那么响应时间就是这个代码。

如果它的代码是128或更大,我们会使用一种特殊的方式来计算。简单来说,我们会把这个代码转换为二进制,然后根据它的某些位来获取两个值: exp 和 mant。响应时间将是 (mant | 0x10) << (exp + 3)。

注:exp最大响应时间的高5~7位mant为最大响应时间的低4位。

现在,你的任务是,根据给定的报文数量、收到报文的时间和最大响应时间代码,计算你应该在什么时候发出响应。

输入

第一行是你收到的报文数量。
接下来的每一行都会有两个数字:收到报文的时间和最大响应时间代码。
输出

你应该在什么时候发送响应。
注意

保证在所有的输入中,你只会发送一次响应,且在你的响应计时结束后,不会再收到新的报文。
示例

输入
3
0 20
1 10
8 20
输出
11
说明
收到3个报文,
第0秒收到第1个报文,响应时间为20秒,则要到0+20=20秒响应;
第1秒收到第2个报文,响应时间为10秒,则要到1+10=11秒响应,与上面的报文的响应时间比较获得响应时间最小为11秒;
第8秒收到第3个报文,响应时间为20秒,则要到8+20=28秒响应,与第上面的报文的响应时间比较获得响应时间最小为11秒;
最终得到最小响应报文时间为11秒

示例2

输入
2
0 255
200 60
输出
260
说明
收到2个报文,
第0秒收到第1个报文,响应时间为255秒,则要到(1510×10)<<(7+3)=31744秒响应;(mant=15,exp=7)
第200秒收到第2个报文,响应时间为60秒,则要到200+60-260秒响应,
与第上面的报文的响应时间比较获得响应时间最小为260秒:
最终得到最小响应报文时间为260秒

这种题纯纯恶心

#include <iostream>
#include <algorithm> // 用于std::max函数

int main() {
    int numMessages;
    std::cin >> numMessages; // 读取报文数量

    int finalResponseTime = 0; // 初始化最终响应时间

    for (int i = 0; i < numMessages; ++i) {
        int receivedTime, code;
        std::cin >> receivedTime >> code; // 读取每个报文的接收时间和代码

        int responseTime;

        if (code < 128) {
            // 如果代码小于128,响应时间就是这个代码
            responseTime = receivedTime + code;
        } else {
            // 如果代码是128或更大,使用特殊方式计算响应时间
            int exp = (code >> 5) & 0x07; // 获取高3位作为exp
            int mant = code & 0x0F; // 获取低4位作为mant
            responseTime = receivedTime + ((mant | 0x10) << (exp + 3));
        }

        // 更新最终响应时间
        if (i == 0 || responseTime < finalResponseTime) {
            finalResponseTime = responseTime;
        }
    }

    // 输出最终响应时间
    std::cout << finalResponseTime << std::endl;

    return 0;
}

Hjk报文重排序

对报文进行重传和重排序是常用的可靠性机制,重传缓冲区内有一定数量的子报文,每个子报文在原始报文中的顺序已知,现在需要恢复出原始报文。

输入描述

输入第一行为N,表示子报文的个数,0 < N <= 1000。

输入第二行为N个子报文,以空格分开,子报文格式为字符串报文内容+后缀顺序索引,字符串报文内容由|a-z,A-Z)组成后缀为整形值,表示顺序。顺序值唯一,不重复。

输出描述:

EN输出恢复出的原始报文。按照每个子报文的顺序的升席排序恢复出原始报文,顺序后缀需要从恢复出的报文中删除掉

用例1

输入:

4

rolling3 stone4 like1 a2

输出:

like a rolling stone

说明:

4个子报文的内容分别为roling,stone,like,a,顺序值分别为3,4,1,2,按照顺序值升序并删除掉顺序后缀得到恢复的原始报文: like a rolling stone

用例2

输入:

8

Lgifts6 and7 Exchanging1 all2 precious5 things8 kinds3 of43

// 注: 这里需要注意:and7与Exchanging1有两个空格

输出:

Exchanging all kinds of precious gifts and things

分析

我们可以把每个子报文的顺序索引作为键,子报文内容作为值。这样,在插入过程中map会自动根据顺序索引对子报文进行排序,然后我们只需要按顺序遍历map并输出子报文内容即可。

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <cctype>

std::map<int, std::string> splitword(std::vector<std::string>& words) {
    std::map<int, std::string> messmap;
    for (const auto& word: words) {
        std::string mes;
        std::string numStr;
        //从字符串末尾开始遍历,分离数字和文本
        for (int i = word.size() - 1; i >= 0; i--) {
            if (std::isdigit(word[i])) {
                numStr.insert(numStr.begin(), word[i]);
            }
            else {
                mes = word.substr(0, i + 1);
                break;
            }
        }
        int num = std::stoi(numStr);
        messmap[num] = mes;
        // std::string mes = word.substr(0, word.size() - 1);
        // int num = word.back() - '0';
        // std::pair<int, std::string> iter = {num, mes};
        // messmap.insert(iter);
    }
    return messmap;
}

int main() {
    int N;
    std::cin >> N;
    std::cin.ignore(); 
    std::string s ;
    std::vector<std::string> words(N);
    for(int i = 0;i < N; i++) {
        std::cin >> words[i];
        // std::getline(std::cin, words[i]);
    }
    std::map<int, std::string> wordmap = splitword(words);
    for (auto word:wordmap) {
        std::cout << word.second << " ";
    }
    return 0;
}

Hjk 查找人名

题目有问题

Hjk去除多余的空格

题目
你需要写一个功能,它能处理一段文本,去除其中不必要的空格。但是如果这些空格被一对单引号包围起来,就保留它们不变。同时,你还要调整一些特定词汇的位置,这些词汇的位置会以坐标的方式给出,坐标要基于新的文本。

特别注意:

关键词的位置一定不是空格。
一个关键词的前后不会有额外空格。
如果文本中有单引号,那肯定是成对出现的。
关键词可能会有重复出现。

输入格式
如果文本中有单引号,那一定是成对的。
接下来是关键词的位置。每对关键词的开始和结束位置用空格隔开,不同关键词间用逗号隔开。
输出格式

返回经过处理的文本。
输出关键词的新位置。
范例

输入

Life is painting a picture, not doing ‘a sum’.
8 15,20 26,43 45
输出

Life is painting a picture, not doing ‘a sum’.
[8, 15] [19, 25] [42, 44]
解释:这里“a”和“picture”之间的空格被删去了,但在单引号内的空格保持不变。

shit

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/527750.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Android Activity 介绍

Activity Activity 是一个应用组件&#xff0c;用户可与其提供的屏幕进行交互&#xff0c;以执行拨打电话、拍摄照片、发送电子邮件或查看地图等操作。 每个 Activity 都会获得一个用于绘制其用户界面的窗口。窗口通常会充满屏幕&#xff0c;但也可小于屏幕并浮动在其他窗口之…

Cherno CPP学习笔记-01-背景知识

0、工具网站收集 C语言版本特性 https://en.cppreference.com https://www.cplusplus.com https://www.tutorialspoint.com/cplusplus https://www.learncpp.com https://github.com/fffaraz/awesomecpp https://stackoverflow.com 网页CPP编译器 [C] gcc 12.1.0 - Wa…

expected scalar type long but found float

在报这个错误的情况下&#xff0c;找到报错的路径&#xff0c;将target 改为target.long()就可以解决了

Chatgpt掘金之旅—有爱AI商业实战篇|虚拟助理|(九)

演示站点&#xff1a; https://ai.uaai.cn 对话模块 官方论坛&#xff1a; www.jingyuai.com 京娱AI 一、AI技术创业在虚拟助理业务有哪些机会&#xff1f; 人工智能&#xff08;AI&#xff09;技术作为当今科技创新的前沿领域&#xff0c;为创业者提供了广阔的机会和挑战。随…

【Leetcode每日一题】 递归 - 二叉树剪枝(难度⭐⭐)(50)

1. 题目解析 题目链接&#xff1a;814. 二叉树剪枝 这个问题的理解其实相当简单&#xff0c;只需看一下示例&#xff0c;基本就能明白其含义了。 2.算法原理 想象一下&#xff0c;你有一堆层层叠叠的积木&#xff0c;你想从底部开始&#xff0c;把那些标记为0的积木拿走。如…

设计模式之观察者模式讲解

概念&#xff1a;定义对象间一种一对多的依赖关系&#xff0c;使得当每一个对象改变状态&#xff0c;则所有依赖于它的对象都会得到通知并被自动更新。 抽象主题&#xff1a;或者叫被观察者&#xff0c;可以持有、增加、删除观察者对象。具体主题&#xff1a;实现抽象主题定义的…

定时任务原理方案综述

定时任务原理方案综述 背景概述 定时任务&#xff0c;顾名思义&#xff0c;就是指定时间点进行执行相应的任务。业务场景中包括&#xff1a; 每天晚上12点&#xff0c;将当日的销售数据发送给各个VP&#xff1b;订单下单十分钟未付款将自动取消订单&#xff1b;用户下单后发…

【JavaScript】预解析 ② ( 预解析示例分析 | 分步骤分析预解析过程 )

文章目录 一、预解析示例分析一1、要分析的代码2、代码预解析分析3、作用域链分析 二、预解析示例分析二1、要分析的代码2、代码预解析分析 三、预解析示例分析三1、要分析的代码2、预解析过程分析 一、预解析示例分析一 1、要分析的代码 要分析的 代码示例 : <!DOCTYPE ht…

人工智能前沿成科技竞争新高地

以下文章来源&#xff1a;经济参考报 近日&#xff0c;首届中国具身智能大会&#xff08;CEAI 2024&#xff09;在上海举行。作为人工智能领域的前沿热点&#xff0c;具身智能正逐步走进现实&#xff0c;成为当前全球科技竞争的新高地、未来产业的新赛道、经济发展的新引擎。 “…

人工智能_大模型018_AssistantsAPI_01_---人工智能工作笔记0154

先来说一下一些问题: 尽量不要微调,很麻烦,而且效果需要自己不断的去测试. 如果文档中有图表,大量的图片去分析就不合适了. 是否用RAG搜索,这个可以这样来弄,首先去es库去搜能直接找到答案可以就不用去RAG检索了,也可以设置一个分,如果低于60分,那么就可以去进行RAG检索 微…

视频实例分割 | 基于ViT实现的端到端end-to-end+query-based的视频实例分割

项目应用场景 面向视频实例分割场景&#xff0c;项目采用 Vision-Transformer 深度学习算法来实现。 项目效果 项目细节 > 具体参见项目 README.md (1) 创建 python 开发环境 conda create --name tevit python3.7.7 conda activate tevit (2) 安装依赖 torch1.9.0 torch…

XC7A35T-2FGG484 嵌入式FPGA现场可编程门阵列 Xilinx

XC7A35T-2FGG484 是一款由Xilinx&#xff08;赛灵思&#xff09;制造的FPGA&#xff08;现场可编程门阵列&#xff09;芯片 以下是XC7A35T-2FGG484 的主要参数&#xff1a; 1. 系列&#xff1a;Artix-7 2. 逻辑单元数量&#xff1a;33280个 3. 工艺技术&#xff1a;28nm 4. …

postgresql发布和订阅

一、发布订阅介绍 发布和订阅使用了pg的逻辑复制的功能&#xff0c;通过发布端创建publication与表绑定&#xff0c;订阅端创建subscription同时会在发布端创建逻辑复制槽实现逻辑复制功能 逻辑复制基于 发布&#xff08;Publication&#xff09; 与 订阅&#xff08;Subscri…

Few-Shot目标检测数据集 | Few-Shot目标检测数据集_已经整理成MS-COCO数据格式_含60000+张图_可直接用于目标检测算法训练

项目应用场景 面向 Few-Shot 目标检测场景&#xff0c;项目提供 6000 张图&#xff0c;已经整理成 MS-COCO 数据格式&#xff0c;可用于 Few-Shot 目标检测的训练数据集&#xff0c;或作为 Few-Shot 目标检测数据集的补充。 数据集展示 数据集下载 > 具体参见项目 README.m…

FreeBuf 全球网络安全产业投融资观察(3月)

综述 据不完全统计&#xff0c;2024年3月&#xff0c;全球网络安全市场共发生投融资事件53起&#xff0c;其中国内4起&#xff0c;国外49起。 3月全球络安全产业投融资统计表&#xff08;数据来源&#xff1a;航行资本、36氪&#xff09; 整体而言&#xff0c;国内4起投融资事…

数字图像处理基础

目录 概述 仿射变换 常见的灰度处理算法 空间域滤波原理 空间域平滑滤波&#xff08;低通滤波&#xff09; 空间域锐化滤波&#xff08;高通滤波&#xff09; 傅里叶变换 频率域与空间域的对应关系 频率域滤波 形态学处理基础知识 边缘检测原理 检测孤立点 检测线…

软考之零碎片段记录(九)+复习巩固(四)

一、学习 1. 英语单词 delivery:交付 automation:自动化 build-in:内置 Iwell-konwn:众所周知 modern:现代 hands-off:无干预 labor-free:免人工 visual:可视化 object-oriented:面向对象的 structural:结构化的 2. 案例 E1: 租户信息 E2: 农户 E3: 租户 E4: 用户 3. 案例…

giteegit的连结使用

目标&#xff1a;在windows的本地的git上操作的项目存放到Gitee云端上 不适用于linux的terminal终端下 1.先下载好Git这个软件 2.创建一个文件夹&#xff08;项目名称&#xff09; 然后用gitbash的形式打开 3.创建ssh密钥到Gitee上 因为我们在Git与Gitee上的传输是通过ssh…

OpenCV图像处理——基于OpenCV的ORB算法实现目标追踪

概述 ORB&#xff08;Oriented FAST and Rotated BRIEF&#xff09;算法是高效的关键点检测和描述方法。它结合了FAST&#xff08;Features from Accelerated Segment Test&#xff09;算法的快速关键点检测能力和BRIEF&#xff08;Binary Robust Independent Elementary Feat…

Golang | Leetcode Golang题解之第17题电话号码的字母组合

题目&#xff1a; 题解&#xff1a; var phoneMap map[string]string map[string]string{"2": "abc","3": "def","4": "ghi","5": "jkl","6": "mno","7": &…