假设串用+python+字符串类型表示，给定两个字符串+s+和+t+，求串+t+在串+s+中不重叠出现的次数，如果不是子串则返回0

可以使用字符串的find方法来判断子串是否在主串中出现，如果出现则返回子串在主串中第一次出现的位置，如果不出现则返回-1。可以利用这个方法来判断子串是否在主串中出现过。

具体实现可以使用一个循环来遍历主串中的每一个可能的起始位置，然后使用find方法来判断子串是否在该位置出现过。如果出现过，则计数器加1，否则继续遍历下一个位置。最后返回计数器的值即可。

以下是Python代码示例：

def count_non_overlap(s, t):
    count = 0
    i = 0
    while i < len(s):
        pos = s.find(t, i)
        if pos == -1:
            break
        count += 1
        i = pos + 1
    return count

相关问题

编写一个实验程序,假设串用链串存储,将非空串str中出现的所有子串用串替 换(s和t均为非空串),不考虑子串重叠的情况,并且采用就地算法,即直接在str链串上实现替换,算法执行后不破坏s和t串。用相关数据进行测试。

编写这样的实验程序需要使用链表表示字符串，并通过遍历的方式查找并替换子串。以下是使用C++的一个基本示例，这个例子中我们创建了一个`Node`结构来存储字符及其指向下一个节点的指针，然后实现了`findAndReplaceSubstring`函数来进行操作：

#include <iostream>
using namespace std;

// 定义链表节点
struct Node {
    char data;
    Node* next;
};

class StringLinkedList {
public:
    Node* head;
    
    // 添加新字符到链表尾部
    void add(char c) {
        if (!head) {
            head = new Node{c, nullptr};
        } else {
            Node* current = head;
            while (current->next) {
                current = current->next;
            }
            current->next = new Node{c, nullptr};
        }
    }

    // 查找并替换子串
    void findAndReplaceSubstring(const string& str, const string& s, const string& t) {
        int i = 0, j = 0;
        while (i <= str.size() - s.size()) {
            if (str.substr(i, s.size()) == s) { // 检查是否匹配
                for (j = 0; j < t.size(); ++j) {
                    replace(i + j, i + j + 1); // 替换子串
                }
                i += t.size();
            } else {
                i++;
            }
        }
    }

private:
    // 就地替换单个字符
    void replace(int index) {
        if (index >= head->next->data) {
            return; // 如果越界，跳过
        }
        Node* current = head;
        while (current->next && current->next->data != index) {
            current = current->next;
        }
        if (current->next) {
            current->next->data = t[j]; // 替换字符
            j++; // 移动到下个字符
        }
    }
};

int main() {
    StringLinkedList list;
    list.add('H');
    list.add('e');
    list.add('l');
    list.add('l');
    list.add('o', 'W', 'o'); // 添加'Hello'作为初始串

    list.findAndReplaceSubstring(list.head->next->data, "ll", "yy"); // 替换"ll"为"yy"

    // 打印结果
    Node* node = list.head;
    while (node) {
        cout << node->data;
        node = node->next;
    }
    cout << endl;

    return 0;
}

在这个例子中，我们首先初始化一个链表`list`，然后在其上执行子串替换操作。注意，由于链表不是线性的数组，实际应用中可能会遇到边界检查等问题。你可以通过输入不同的`str`, `s`, 和 `t` 来测试这个程序。

1) 串的模式匹配：设s、t为两个字符串，判断t是否为s的子串。如果是，输出子串所在位置（第一个字符），否则输出-1。 2) 根据位置和长度，删除子串。使用顺序串用BF算法 的完整代码

好的，我会尽力回答您的问题。以下是我的答案：

1）串的模式匹配可以使用暴力匹配算法，也称为 BF（Brute Force）算法。该算法的思想是：从主串 S 的第一个字符开始，依次与模式串 P 的第一个字符、第二个字符……第 m 个字符比较，如果所有字符都匹配成功，则返回子串第一个字符在主串中的位置，否则向右移动一位，继续比较。

具体实现的代码如下：

int BF(string s, string t)
{
int slen = s.length(), tlen = t.length();
for(int i = 0; i <= slen - tlen; i++)
{
int j;
for(j = 0; j < tlen; j++)
if(s[i + j] != t[j]) break;
if(j == tlen) return i;
}
return -1;
}

其中，s 为主串，t 为模式串，返回值为子串在主串中的位置，如果不存在则返回 -1。

2）根据位置和长度删除子串，可以先用 substr() 函数找到要删除的子串，然后再用 erase() 函数删除子串，最后返回删除后的新串。具体实现代码如下：

string DeleteSubstr(string s, int pos, int len)
{
string sub = s.substr(pos, len);
s.erase(pos, len);
return s;
}

其中，s 为原串，pos 表示要删除的子串开始位置，len 表示要删除的子串长度。返回值为删除后的新串。

希望我的回答可以帮助到您，如果还有其他问题，请随时提出。