利用index()函数和删除子串函数循环实现采用顺序结构存储串,编写一个函数 index(n1,s2),用于判断 s2 是否是 s1的子串若是,则返回其在主串中的位置,否则返回-1

def index(n1, s2):
i = 0
while i < len(n1):
j = 0
k = i
while j < len(s2) and k < len(n1) and s2[j] == n1[k]:
j += 1
k += 1
if j == len(s2):
return i
i += 1
return -1

# 测试
s1 = "hello world"
s2 = "world"
print(index(s1, s2)) # 输出 6

s3 = "hello world"
s4 = "python"
print(index(s3, s4)) # 输出 -1

相关问题

采用顺序结构存储串，编写一个函数，求串s和串t的一个最长公共子串。

### 回答1：
可以采用暴力枚举的方法，从s串中每个字符开始，依次与t串中的每个字符比较，如果相同则继续比较下一个字符，直到不相同为止。记录下每次比较相同的字符数，最后得到的最大值即为最长公共子串的长度。同时记录下最长公共子串的起始位置，即可得到最长公共子串。

### 回答2：
解题思路：

最长公共子串是指两个字符串中相同的最长的连续子串。这里我们可以使用顺序结构存储串，以字符数组的形式将串存储下来，然后遍历两个串，求它们的最长公共子串。

具体实现细节：

首先，我们需要定义一个函数来求两个串中最长公共子串的长度。这个函数需要接受两个参数，即两个串的指针和它们的长度。

然后，我们可以使用一个双重循环来遍历两个串，对于每个位置，我们判断两个串该位置的字符是否相同。如果相同，就将它们的长度加1，否则将它们的长度设置为0，这样就可以求出它们最长公共子串的长度。

最后，我们需要遍历两个串找到最长公共子串，具体方法是在上一步的双重循环中记录下最长公共子串的起始位置和长度，然后再去两个串中寻找这个子串。

代码实现：

下面是一个基于顺序结构存储串的最长公共子串求解的函数实现：

#include <stdio.h>
#include <string.h>

#define MAXLEN 100

int GetMaxCommonLength(char* s, int len_s, char* t, int len_t)
{
    int i, j;
    int max_len = 0;
    int common_len[MAXLEN][MAXLEN] = {0};  // 记录公共子串的长度
    
    for (i = 0; i < len_s; i++)
    {
        for (j = 0; j < len_t; j++)
        {
            if (s[i] == t[j])
            {
                if (i == 0 || j == 0)  // 考虑边界情况
                    common_len[i][j] = 1;
                else
                    common_len[i][j] = common_len[i-1][j-1] + 1;
                
                if (common_len[i][j] > max_len)
                    max_len = common_len[i][j];
            }
        }
    }
    
    return max_len;
}

int main(void)
{
    char s[MAXLEN] = "abcdeamnopq";
    char t[MAXLEN] = "xyzamnopqrs";
    int len_s = strlen(s);
    int len_t = strlen(t);
    int max_common_len;
    
    max_common_len = GetMaxCommonLength(s, len_s, t, len_t);
    printf("最长公共子串为：%.*s, 其长度为：%d\n", max_common_len, s, max_common_len);
    
    return 0;
}

注意事项：

- 这个算法的时间复杂度是 $O(mn)$，其中 $m$ 和 $n$ 分别是两个串的长度，空间复杂度也是 $O(mn)$，因为需要使用一个二维数组记录公共子串的长度。
- 在实际应用中，我们也可以使用其他更优秀的算法来求解最长公共子串，例如后缀数组、后缀树等。

### 回答3：
串是计算机中常见的一种数据类型，通常由字符组成。在不同的问题和应用中，有时需要找到两个串之间的相同部分，这种相同的部分称为公共子串。求最长公共子串是一种经典的问题，可以通过不同的算法进行求解。

若采用顺序结构存储串，可以使用两重循环遍历串s和串t的所有子串，并计算它们的长度和相同的字符个数，找出它们之间长度最长且相同的子串即可。

具体地，可以定义一个函数longestCommonSubstring来解决这个问题。函数的参数为两个串s和t，类型均为char*。函数的返回值为一个指向最长公共子串的指针。如果没有公共子串，返回一个空指针。

下面给出函数的伪代码：

char* longestCommonSubstring(char* s, char* t) {
int len_s = strlen(s); // 串s的长度
int len_t = strlen(t); // 串t的长度
char* result = NULL; // 最长公共子串的指针
int max_length = 0; // 最长公共子串的长度
for (int i = 0; i < len_s; i++) {
for (int j = 0; j < len_t; j++) {
int length = 0; // 当前公共子串的长度
while (s[i+length] == t[j+length] && i+length < len_s && j+length < len_t) {
length++;
}
if (length > max_length) {
max_length = length;
result = s+i;
}
}
}
return result;
}

在上述代码中，首先通过strlen函数获取串s和串t的长度，然后定义了两个循环变量i和j，遍历串s和串t的所有子串。对于每个子串，通过一个while循环来计算它的长度和相同的字符个数。如果当前公共子串的长度大于已知的最长公共子串长度，则更新最长公共子串的长度和指针。最后返回指向最长公共子串的指针即可。

需要注意的是，上述算法的时间复杂度为O(n^3)，其中n为串s和串t的长度，因为需要遍历所有子串，每个子串的比较次数为O(n)。在实际应用中，还有更高效的算法可以用于求解最长公共子串问题，例如后缀数组和动态规划等。

采用顺序结构存储串，编写一个函数index(s1,s2),用于判断s2是否是s1的子串。若是，则返回其在主串中的位置，否则返回-1。

以下是Python实现：

def index(s1, s2):
    n = len(s1)
    m = len(s2)
    for i in range(n-m+1):
        j = 0
        while j < m and s1[i+j] == s2[j]:
            j += 1
        if j == m:
            return i
    return -1

其中，n和m分别为主串和子串的长度。通过循环遍历主串中每一个可能的起始位置，并在每个位置上逐个比较子串中的字符和主串中对应位置的字符是否相等，直到找到子串完全匹配主串的一段位置，或者遍历完所有可能的位置都没有找到匹配的子串。如果找到匹配的子串，则返回其在主串中的起始位置。如果遍历完所有可能的位置都没有找到匹配的子串，则返回-1表示未找到。