字符串基础题目总结

1.字符串长度
给定一行长度不超过100的字符串，请你求出它的具体长度。
输入格式
输入一行，表示一个字符串。注意字符串中可能包含空格。
输出格式
输出一个整数，表示它的长度。
输入样例：
I love Beijing.
输出样例：
15
算法1
C语言代码

#include
#include
int main()
{
     
    char s[105];
    gets(s);
    printf("%d",strlen(s));
    return 0;
}

算法2
C++ 代码

#include 
#include 
using namespace std;
int main()
{
     
    string a;
    getline(cin,a);
    cout<<a.size()<<endl;
    return 0;
}

算法3
C++ 代码

#include 
#include 
using namespace std;
int main()
{
     
    char a[105];
    cin.get(a,105);
    cout<<strlen(a)<<endl;
    return 0;
}

算法4
C++ 代码

#include 
#include 
using namespace std;
int main()
{
     
    char a[105];
    cin.getline(a,105);
    cout<<strlen(a)<<endl;
    return 0;
}
// cin 和 scanf读入字符串时遇到空格就停止了。

2.字符串中的数字个数
输入一行字符，长度不超过100，请你统计一下其中的数字字符的个数。
输入格式
输入一行字符。注意其中可能包含空格。
输出格式
输出一个整数，表示字数字字符的个数。
输入样例：
I am 18 years old this year.
输出样例：
2

#include
using namespace std;
int main(){
     
	char str[101];
	cin.getline(str,101);
		int res=0;
		int len=strlen(str);
		for(int i=0;i<len;i++){
     
		if(str[i]=='0'||str[i]=='1'||str[i]=='2'||str[i]=='3'||str[i]=='4'||str[i]=='5'||str[i]=='6'||str[i]=='7'||str[i]=='8'||str[i]=='9') res++;
		}
		printf("%d",res); 
	return 0;
}

3.字符串匹配
给定两个长度相同的字符串 a 和字符串 b。
如果在某个位置 i 上，满足字符串 a 上的字符a[i]和字符串 b 上的字符b[i]相同，那么这个位置上的字符就是匹配的。
如果两个字符串的匹配位置的数量与字符串总长度的比值大于或等于k，则称两个字符串是匹配的。
现在请你判断给定的两个字符串是否匹配。
输入格式
第一行包含一个浮点数k，第二行包含字符串 a，第三行包含字符串 b。
输入的字符串中不包含空格。
输出格式
如果两个字符串匹配，则输出“yes”。
否则，输出“no”。
数据范围
0≤k≤10≤k≤1,
字符串的长度不超过100。
输入样例：
0.4
abcde
xbacd
输出样例：
no

#include
using namespace std;
int main()
{
     
    string a,b;
    int sum=0;
    double t;
    cin>>t>>a>>b;
    for(int i=0;i < a.size(); i++)
        if(a[i] == b[i])
            sum++;
    double n = (double)sum / a.size();
    n >= t ? cout<<"yes" : cout<<"no";
}

4.循环相克令
循环相克令是一个两人玩的小游戏。
令词为“猎人、狗熊、枪”，两人同时说出令词，同时做出一个动作——猎人的动作是双手叉腰;狗熊的动作是双手搭在胸前;枪的动作是双手举起呈手枪状。
双方以此动作判定输赢，猎人赢枪、枪赢狗熊、狗熊赢猎人，动作相同则视为平局。
现在给定你一系列的动作组合，请你判断游戏结果。
输入格式
第一行包含整数T，表示共有T组测试数据。
接下来T行，每行包含两个字符串，表示一局游戏中两人做出的动作，字符串为“Hunter”, “Bear”, “Gun”中的一个，这三个单词分别代表猎人，狗熊和枪。
输出格式
如果第一个玩家赢了，则输出“Player1”。
如果第二个玩家赢了，则输出“Player2”。
如果平局，则输出“Tie”。
数据范围
1≤N≤1001≤N≤100
输入样例
3
Hunter Gun
Bear Bear
Hunter Bear
输出样例
Player1
Tie
Player2

#include 

using namespace std;

int main()
{
     
    int t;
    cin>> t;
   string a, b;
    while(t--){
     
        cin>> a >> b;
        if(a == "Hunter" && b == "Bear")  cout<< "Player2" << endl;
         if(a == "Hunter" && b == "Gun") cout<< "Player1" << endl;
         if(a == "Hunter" && b == "Hunter") cout<< "Tie" << endl;
         if(a == "Bear" && b == "Hunter") cout<< "Player1" << endl;
         if(a == "Bear" && b == "Bear") cout<< "Tie" << endl;
         if(a == "Bear" && b == "Gun") cout<< "Player2" << endl;
         if(a == "Gun" && b == "Hunter") cout << "Player2"<< endl;
         if(a == "Gun" && b == "Bear") cout<< "Player1" << endl;
         if(a == "Gun" && b == "Gun") cout<< "Tie" << endl;
    }
    return 0;
}

5.输出字符串
给定一个字符串a，请你按照下面的要求输出字符串b。
给定字符串a的第一个字符的ASCII值加第二个字符的ASCII值，得到b的第一个字符；
给定字符串a的第二个字符的ASCII值加第三个字符的ASCII值，得到b的第二个字符；
给定字符串a的倒数第二个字符的ASCII值加最后一个字符的ASCII值，得到b的倒数第二个字符；
给定字符串a的最后一个字符的ASCII值加第一个字符的ASCII值，得到b的最后一个字符。
输入格式
输入共一行，包含字符串a。注意字符串中可能包含空格。
数据保证字符串内的字符的ASCII值均不超过63。
输出格式
输出共一行，包含字符串b。
数据范围
2≤a的长度≤100
输入样例：
1 2 3
输出样例：
QRRSd

#include 
using namespace std;
int main() {
     
    string a;
    getline(cin, a);
    for(int i = 0; i < a.size(); ++i)
        cout << (char)(a[i] + a[(i + 1) % a.size()]);
    return 0;
}

6.字符串加空格
给定一个字符串，在字符串的每个字符之间都加一个空格。
输出修改后的新字符串。
输入格式
共一行，包含一个字符串。注意字符串中可能包含空格。
输出格式
输出增加空格后的字符串。
数据范围
1≤字符串长度≤1001≤字符串长度≤100
输入样例：
test case
输出样例：
t e s t c a s e

#include
#include
#include
using namespace std;
int main(){
     
    char str[101];
    cin.getline(str,101);
    int len=strlen(str);
    for(int i=0;i<len-1;i++){
     
        cout<<str[i]<<" ";
    }
    cout<<str[len-1];
    
    return 0;
}

7.去掉多余的空格
输入一个字符串，字符串中可能包含多个连续的空格，请将多余的空格去掉，只留下一个空格。
输入格式
共一行，包含一个字符串。
输出格式
输出去掉多余空格后的字符串，占一行。
数据范围
输入字符串的长度不超过200。
输入样例：
Hello world.This is c language.
输出样例：
Hello world.This is c language.

#include 
using namespace std;

int main()
{
     
    string s;
    getline(cin, s);
    for(int i = 0; i < s.size(); i++)
        if(s[i] != ' ' || s[i+1] != ' ') cout << s[i];
    return 0;
}

8.信息加密
在传输信息的过程中，为了保证信息的安全，我们需要对原信息进行加密处理，形成加密信息，从而使得信息内容不会被监听者窃取。
现在给定一个字符串，对其进行加密处理。
加密的规则如下：
字符串中的小写字母，a加密为b，b加密为c，…，y加密为z，z加密为a。
字符串中的大写字母，A加密为B，B加密为C，…，Y加密为Z，Z加密为A。
字符串中的其他字符，不作处理。
请你输出加密后的字符串。
输入格式
共一行，包含一个字符串。注意字符串中可能包含空格。
输出格式
输出加密后的字符串。
数据范围
输入字符串的长度不超过100。
输入样例：
Hello! How are you!
输出样例：
Ifmmp! Ipx bsf zpv!

#include 
using namespace std;

int main()
{
     
    string s;int i;
    getline(cin,s);
    for(i=0;i<s.length();i++)
    {
     
        if(s[i]>='A'&&s[i]<='Y') s[i]+=1;else
        if(s[i]=='Z') s[i]='A';
        if(s[i]>='a'&&s[i]<='y') s[i]+=1;else
        if(s[i]=='z') s[i]='a';
        cout<<s[i];
    }
    return 0;
}

9.忽略大小写比较字符串大小
一般我们用strcmp可比较两个字符串的大小，比较方法为对两个字符串从前往后逐个字符相比较（按ASCII码值大小比较），直到出现不同的字符或遇到’\0’为止。
如果全部字符都相同，则认为相同；如果出现不相同的字符，则以第一个不相同的字符的比较结果为准。
但在有些时候，我们比较字符串的大小时，希望忽略字母的大小，例如”Hello”和”hello”在忽略字母大小写时是相等的。
请写一个程序，实现对两个字符串进行忽略字母大小写的大小比较。
输入格式
输入为两行，每行一个字符串，共两个字符串。注意字符串中可能包含空格。
数据保证每个字符串的长度都不超过80。
输出格式
如果第一个字符串比第二个字符串小，输出一个字符”<”。
如果第一个字符串比第二个字符串大，输出一个字符”>”。
如果两个字符串相等，输出一个字符”=”。
输入样例：
Hello
hello
输出样例：

#include 
using namespace std;
int main() {
     
    string s,t;
    int i,j,lens,lent;
   getline(cin,s);
    getline(cin,t);
    lens =s.length();
    lent = t.length();
    for(i = 0; i < lens; i++)
        s[i] = tolower(s[i]);
    for(j = 0; j < lens; j++)
        t[j] = tolower(t[j]);
    if(lens <lent) swap(lens,lent);
        for(i = 0; i < lens;) {
     
            if(t[i] == s[i]){
     
                i++;    }
            else if(t[i] < s[i]) {
     
                printf(">");
                break;
            } else if(t[i] > s[i]) {
     
                printf("<");
                break;
            }
        }
        if(i == lens)
            printf("=\n");
    return 0;
}

10.替换字符
给定一个由大小写字母构成的字符串。
把该字符串中特定的字符全部用字符“#”替换。
请你输出替换后的字符串。
输入格式
输入共两行。
第一行包含一个长度不超过30的字符串。
第二行包含一个字符，表示要替换掉的特定字符。
输出格式
输出共一行，为替换后的字符串。
输入样例：
hello
l
输出样例：
he##o

#include
#include
#include
using namespace std;
int main(){
     
    string s;
    char c;
    getline(cin,s);
    cin>>c;
    int len=s.size();
    for(int i=0;i<len;i++){
     
        if(s[i]==c) s[i]='#';
    }
      for(int i=0;i<len;i++){
     
          printf("%c",s[i]);
      }
    return 0;
}

11.单词替换
输入一个字符串，以回车结束（字符串长度不超过100）。
该字符串由若干个单词组成，单词之间用一个空格隔开，所有单词区分大小写。
现需要将其中的某个单词替换成另一个单词，并输出替换之后的字符串。
输入格式
输入共3行。
第1行是包含多个单词的字符串 s;
第2行是待替换的单词a(长度不超过100);
第3行是a将被替换的单词b(长度不超过100)。
输出格式
共一行，输出将s中所有单词a替换成b之后的字符串。
输入样例：
You want someone to help you
You
I
输出样例：
I want someone to help you
1.直接用char数组存储，输出时比较即可

#include
using namespace std;
int main()
{
     
    char s[10005][105];int i=1;
    while(cin>>s[i]) i++;
    for(int j=1;j<i-2;j++)
        if(strcmp(s[i-2],s[j])==0)
            printf("%s ",s[i-1]);
        else
            printf("%s ",s[j]);
    return  0;
}

2.正则表达式解决替换单词问题：

#include 
#include 
#include 
using namespace std;
int main(){
     
    string s,s1,s2;
    getline(cin,s);
    cin>>s1>>s2;
    cout<<regex_replace(s,regex("\\b" + s1 + "\\b"),s2)<<endl;
    return 0;
}

普及一下正则表达式常用函数：这个链接还行
regex_match：全文匹配，要求整个字符串符合正则表达式的匹配规则。用来判断一个字符串和一个正则表达式是否模式匹配，如果匹配成功则返回true，否则返回false。
regex_search：搜索匹配，根据正则表达式来搜索字符串中是否存在符合规则的子字符串。
regex_replace：替换匹配，即可以将符合匹配规则的子字符串替换为其他字符串。要求输入一个正则表达式，以及一个用于替换匹配子字符串的格式化字符串。这个格式化字符串可以通过转义序列引用匹配子字符串中的部分内容。
语法规则：

1. \ 表示将下一字符标记为特殊字符、转义字符；
2. ^ 表示字符串的开始，匹配输入字符串开始的位置；
3. ^$ 表示字符串的结尾，匹配输入字符串结尾的位置；
4. . 表示匹配除换行符" \n "以外的任意字符；
5. \w 表示任意字母、数字、下划线 ；
6. \s 表示任意空白符(tab也包含在内)；
7. \d 表示匹配单个数字字符，\D 表示非数字字符匹配；
8. [] 表示一个字符集合，匹配指定范围内的任何字符，例如[a-z]表示字母a~z所组成的集合；
9. []中使用^{来表示集合的补集，匹配不在指定的范围内的任何字符，例如[}1-3]表示除1 2 3以外数字；
10. [[:alpha:]] 表示任何字母；
11. [[:alnum:]] 表示任何字母和数字；
12. regex::icase 表示匹配时忽略大小写；
13. {n} 表示正好匹配 n 次前面的字符或表达式，例如"hello{6}",匹配字符串中符合第二个l后边有6个o的子字符串；
14. {n, } 表示至少匹配 n 次前面的字符或表达式；
15. {n,m} 表示匹配至少 n 次，至多 m 次前面的字符或表达式；
16. • 表示零次或多次匹配前面的字符或子表达式，等效于{0, }；
17. • 表示一次或多次匹配前面的字符或子表达式；
18. ? 表示零次或一次匹配前面的字符或子表达式；
19. \t \n \r这些平时非常常见，分别表示制表符匹配、换行符匹配、回车符匹配。
    相关习题：
    【GPLT】L1-058 6翻了
    【GPLT】L1-059 敲笨钟
    12.字符串中最长的连续出现的字符
    求一个字符串中最长的连续出现的字符，输出该字符及其出现次数，字符串中无空白字符（空格、回车和tab），如果这样的字符不止一个，则输出第一个。
    输入格式
    第一行输入整数N，表示测试数据的组数。
    每组数据占一行，包含一个不含空白字符的字符串，字符串长度不超过200。
    输出格式
    共一行，输出最长的连续出现的字符及其出现次数，中间用空格隔开。
    输入样例：
    2
    aaaaabbbbbcccccccdddddddddd
    abcdefghigk
    输出样例：
    d 10
    a 1

#include 
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T --)
    {
     
        int maxn = -1;//maxn记录最大长度
        string str, maxs;//maxs记录最大长度时的字符
        cin >> str;
        for(int i = 0; i < str.size(); i ++)
        {
     
            int j = i;
            int cnt = 0;
            while(str[j] == str[i] && j < str.size())//当指针j没有越界且与指针i的内容相同时移动
                j ++, cnt ++;
            if(cnt > maxn)//更新最大值
                maxn = cnt, maxs = str[i];
            i = j - 1;//移动指针i
        }
        cout << maxs << " " << maxn << endl;
    }
}

13.只出现一次的字符
给你一个只包含小写字母的字符串。
请你判断是否存在只在字符串中出现过一次的字符。
如果存在，则输出满足条件的字符中位置最靠前的那个。
如果没有，输出”no”。
输入格式
共一行，包含一个由小写字母构成的字符串。
数据保证字符串的长度不超过100000。
输出格式
输出满足条件的第一个字符。
如果没有，则输出”no”。
输入样例：
abceabcd
输出样例：
e

#include
#include
#include
using namespace std;
int main()
{
     
    string str;
    getline(cin,str);
    int s[300]={
     0};
    for(int i=0;i<str.length();i++)
    {
     
        s[str[i]]++;//统计各个字符出现的次数
    }
    char p=-1;
    for(int i=0;i<str.length();i++)//如果遇到第一个字符出现次数为1.则把该字符赋值给c,break退出for循环。
    {
     
        if(s[str[i]]==1)
        {
     
            p=str[i];
            break;
        }
    }
    if(p==-1) puts("no");
    else  printf("%c",p);
    return 0;
}

14.字符串插入
有两个不包含空白字符的字符串str和substr，str的字符个数不超过10，substr的字符个数为3。（字符个数不包括字符串结尾处的’\0’。）
将substr插入到str中ASCII码最大的那个字符后面，若有多个最大则只考虑第一个。
输入格式
输入包括若干行，每一行为一组测试数据，格式为
str substr
输出格式
对于每一组测试数据，输出插入之后的字符串。
输入样例：
abcab eee
12343 555
输出样例：
abceeeab
12345553

#include
#include
using namespace std;
int main()
{
     
    string str,s;
    while(cin>>str>>s)
    {
     
        int maxn=0,index=-1;
        for(size_t i=0;i!=str.size();++i)
            if(str[i]>maxn)
                maxn=str[i],index=i;
        cout<<str.substr(0,index+1)<<s<<str.substr(index+1,-1)<<endl;
    }
    return 0;
}

讲一下C++中substr函数的用法

#include
#include
using namespace std;

main()
{
     
string s("12345asdf");
string a=s.substr(0,5);       //获得字符串s中 从第0位开始的长度为5的字符串//默认时的长度为从开始位置到尾
cout<<a<<endl;
}
//输出结果为:
//12345

另一种写法

#include 
using namespace std;
int main()
{
     
    char str[11], substr[4];
    int n = 2;
    while(scanf("%s %s", str, substr) != EOF){
     
        int cnt = str[0], res = 0;
        for(int i = 0; i < strlen(str); i++){
     
            if(str[i] > cnt) cnt = str[i], res = i;
            else if(str[i] == cnt) continue;
        }
        for(int i = 0; i <= res; i ++){
     
            cout<< str[i];
        }
        for(int i = 0; i < strlen(substr); i++){
     
            cout<< substr[i];
        }
        for(int i = res + 1; i < strlen(str); i++){
     
            cout<< str[i];
        }
        puts("");
    }
    return 0;
}

15.最长单词
一个以’.’结尾的简单英文句子，单词之间用空格分隔，没有缩写形式和其它特殊形式，求句子中的最长单词。
输入格式
输入这个简单英文句子，长度不超过500。
输出格式
该句子中最长的单词。如果多于一个，则输出第一个。
输入样例：
I am a student of Peking University.
输出样例：
University

#include
#include
using namespace std;
string l,lm;
int len,maxx,f;
int main(){
     
    while(cin>>l){
     
        len=l.size();
        if(l[len-1]=='.'){
     
            len--;
            l.erase(len,1);//删除len后一个字符，即这个句号
            f=1;
        }
        if(len>maxx){
     //更新长度最大的那个字符串
            lm=l;
            maxx=len;
        }
        if(f) break;
    }
    cout<<lm;
    return 0;
}

这里提一下erase
// 用法一

vector<string> e = {
     "a","b","c","d","e","f","g"};
auto it = e.end()-1;  //.end()指向末尾的前一个元素，因此需要-1，指向末尾元素    
e.erase(it);           //删除末尾元素“g”

// 用法二

auto it2 = e.begin()+1;
auto it3 = e.end()-2;
e.erase(it2,it3);    //删除it2到it3之间的元素

对于第二种用法，可以拓展一下：

auto it = a.begin();
auto it2 = find(a.begin(), a.find(), "c");        //it2指向“c”所在位置
auto it3 = a.erase(it,it2);    //删除it到it2之间的所有元素，即“a”和“b”
a.erase(it3);                  //此时删除的是“c”,即先前it2所指，因为第三种用法返回的就是

第二个迭代器所指位置
实际上，erase函数本来是用来操作string的，函数原型如下：
（1）string& erase ( size_t pos = 0, size_t n = npos );删除从pos开始的n个字符，比如erase(0,1)就是删除第一个字符
（2）iterator erase ( iterator position );删除position处的一个字符(position是个string类型的迭代器)
（3）iterator erase ( iterator first, iterator last );删除从first到last之间的字符（first和last都是迭代器）
第二种第三种就是上面操作容器的方式，第一种用法如下：

string str ("This is an example phrase.");
str.find("an");
str.erase(10);            // 也可以使用下标进行删除操作，删除下标10开始及以后的字符
str.erase (10,8);          // 此处意为删除下标‘10’开始的连续8个字符
//注：第一个参数表示的是下标值“10”！不是第10个！

16.倒排单词
编写程序，读入一行英文(只包含字母和空格，单词间以单个空格分隔)，将所有单词的顺序倒排并输出，依然以单个空格分隔。
输入格式
输入为一个字符串（字符串长度至多为100）。
输出格式
输出为按要求排序后的字符串。
输入样例：
I am a student
输出样例：
student a am I

#include 
using namespace std;
int main()
{
     
    string s[10005];int i=1;
    while(cin>>s[i]) i++;
    for(int j=i-1;j>=1;j--) cout<<s[j]<<" ";
    return 0;
}

17.字符串移位包含问题
对于一个字符串来说，定义一次循环移位操作为：将字符串的第一个字符移动到末尾形成新的字符串。
给定两个字符串s1和s2，要求判定其中一个字符串是否是另一字符串通过若干次循环移位后的新字符串的子串。
例如CDAA是由AABCD两次移位后产生的新串BCDAA的子串，而ABCD与ACBD则不能通过多次移位来得到其中一个字符串是新串的子串。
输入格式
共一行，包含两个字符串，中间由单个空格隔开。
字符串只包含字母和数字，长度不超过30。
输出格式
如果一个字符串是另一字符串通过若干次循环移位产生的新串的子串，则输出true，否则输出false。
输入样例：
AABCD CDAA
输出样例：
true

#include 
#include 
using namespace std;
bool check(string a, string b)
{
     
    int len = a.size();
    a += a; //复制字符串并连接
    if (a.find(b) >= 0 && a.find(b) < len) return true; //判断是否包含
    return false;
}
int main()
{
     
    string a, b;
    cin >> a >> b;
    if (check(a, b) || check(b, a)) cout << "true";
    else cout << "false";
    return 0;
}

18.字符串乘方
给定两个字符串a和b,我们定义ab为他们的连接。
例如，如果a=”abc” 而b=”def”， 则ab=”abcdef”。
如果我们将连接考虑成乘法，一个非负整数的乘方将用一种通常的方式定义：a0a0=””(空字符串)，a(n+1)a(n+1)=a∗(an)a∗(an)。
输入格式
输入包含多组测试样例，每组测试样例占一行。
每组样例包含一个字符串s，s的长度不超过100。
最后的测试样例后面将是一个点号作为一行。
输出格式
对于每一个s，你需要输出最大的n，使得存在一个字符串a，让s=ans=an。
输入样例：
abcd
aaaa
ababab
输出样例：
1
4
3

#include
using namespace std;
int main()
{
     
    string s;
    while(cin>>s)
    {
     
        int flag;
        if(s[0]=='.')   break;
        int len=s.size();
        for(int i=1;i<=len;i++)
        {
     
            flag=0;
            if(len%i!=0)    continue;
            for(int j=0;j<len;j++)
                if(s[j]!=s[j%i])    {
     flag=1;break;}
            if(!flag)   {
     cout<<len/i<<endl;break;}
        }
        if(flag)    cout<<"-1"<<endl;
    }
}

19.字符串最大跨距
有三个字符串S,S1,S2，其中，S长度不超过300，S1和S2的长度不超过10。
现在，我们想要检测S1和S2是否同时在S中出现，且S1位于S2的左边，并在S中互不交叉（即，S1的右边界点在S2的左边界点的左侧）。
计算满足上述条件的最大跨距（即，最大间隔距离：最右边的S2的起始点与最左边的S1的终止点之间的字符数目）。
如果没有满足条件的S1，S2存在，则输出-1。
例如，S = “abcd123ab888efghij45ef67kl”, S1=”ab”, S2=”ef”，其中，S1在S中出现了2次，S2也在S中出现了2次，最大跨距为：18。
输入格式
输入共一行，包含三个字符串S,S1,S2，字符串之间用逗号隔开。
数据保证三个字符串中不含空格和逗号。
输出格式
输出一个整数，表示最大跨距。
如果没有满足条件的S1和S2存在，则输出-1.
输入样例：
abcd123ab888efghij45ef67kl,ab,ef
输出样例：
18

#include
#include
#include
using namespace std;
int main()
{
     

    string S,S1,S2;
    int i=0;
    char a;
    while(cin>>a)
    {
     
        if(a!=',')
        {
     
            if(i==0) S+=a;
            else if(i==1) S1+=a;
            else S2+=a;
        }
        else i++;
    }
    int s,s1,s2;
    s1=S.find(S1);
    s2=S.rfind(S2);
    if(s1!=-1&&s2!=-1&&(s1+S1.length()-1)<s2){
     
        cout<<s2-s1-S1.length()<<endl;
    }
    else cout<<"-1"<<endl;

}

20.最长公共字符串后缀
给出若干个字符串，输出这些字符串的最长公共后缀。
输入格式
由若干组输入组成。
每组输入的第一行是一个整数N。
N为0时表示输入结束，否则后面会继续有N行输入，每行是一个字符串（字符串内不含空白符）。
每个字符串的长度不超过200。
输出格式
共一行，为N个字符串的最长公共后缀（可能为空）。
数据范围
1≤N≤2001≤N≤200
输入样例：
3
baba
aba
cba
2
aa
cc
2
aa
a
0
输出样例：
ba
a

#include
using namespace std;
int n;
string l[201];
int main(){
     
    while(cin>>n){
     
        if(n==0) return 0;
        int lm=9999999,la=0;
        for(int i=1;i<=n;i++){
     
            cin>>l[i];
            int len=l[i].size();
            lm=min(len,lm);
        }
        for(int i=1;i<=lm;i++){
     
            int f=1;
            for(int j=1;j<n;j++){
     
                int l1=l[j].size(),l2=l[j+1].size();
                if(l[j][l1-i]!=l[j+1][l2-i]){
     
                    f=0;
                    break;
                }
            }
            if(!f) break;
            else la++;
        }
        for(int i=la;i;i--) cout<<l[1][l[1].size()-i];
        cout<<endl;
    }
}