Arrays 检查字符数组是否包含特殊序列而不使用C中Unix上的字符串库

假设我们有一个字符数组和一个序列。接下来我们要检查char数组是否包含不带库的特殊序列

：if yes->return true；如果否->返回false

bool contains(char *Array, char *Sequence) {
     // CONTAINS - Function
     for (int i = 0; i < sizeof(Array); i++) {
         for (int s = 0; s < sizeof(Sequence); s++) {
             if (Array[i] == Sequence[i]) {
            
                 // How to check if Sequence is contained ?  
             }
         }
     }
    return false;
}
// in Main Function
char *Arr = "ABCDEFG";
char *Seq = "AB";
bool contained = contains(Arr, Seq);
if (contained) {
    printf("Contained\n");
} else {
    printf("Not Contained\n"); 
}

bool包含（字符*数组，字符*序列）{
//包含-函数
对于（int i=0；i

有什么想法、建议、网站吗

提前感谢,，
问候，来自∆
 这不是最有效的算法，但我不想对您的代码做太多更改

size_t mystrlen(const char *str)
{
    const char *end = str;
    while(*end++);

    return end - str - 1;
}

bool contains(char *Array, char *Sequence) {
     // CONTAINS - Function
     bool result = false;
     size_t s, i;

     size_t arrayLen = mystrlen(Array);
     size_t sequenceLen = mystrlen(Sequence);

    if(sequenceLen <= arrayLen)
    {
        for (i = 0; i < arrayLen; i++) {
            for (s = 0; s < sequenceLen; s++) 
            {
                if (Array[i + s] != Sequence[s]) 
                {
                    break;
                }
            }
            if(s == sequenceLen) 
            {
                result = true;
                break;
            }

        }
    }
    return result;
}

int main()
{
    char *Arr = "ABCDEFG";
    char *Seq = "AB";
    bool contained = contains(Arr, Seq);
    if (contained) 
    {
        printf("Contained\n");
    } 
    else 
    {
        printf("Not Contained\n"); 
    }
}

size\u t mystrlen（const char*str）
{
const char*end=str；
而（*end++）；
返回端str-1；
}
bool包含（字符*数组，字符*序列）{
//包含-函数
布尔结果=假；
尺寸s，i；
大小\u t数组长度=mystrlen（数组）；
大小\u t sequenceLen=mystrlen（序列）；
如果（sequenceLen最简单的方法是朴素搜索函数：

for (i = 0; i < lenS1; i++) {
    for (j = 0; j < lenS2; j++) {
        if (arr[i] != seq[j]) {
            break; // seq is not present in arr at position i!
        }
    }
    if (j == lenS2) {
        return true;
    }
 }

一个明显且简单的改进是将i限制在0和lenS1-lenS2之间，如果lenS1
if (lenS1 < lenS2) {
    return false; // You will never find "PEACE" in "WAR".
}
lenS1minuslenS2 = lenS1 - lenS2;

for (i = 0; i < lenS1minuslenS2; i++)

if（lenS1

进一步的改进取决于您的用例

在许多数组中寻找相同的序列，在同一个数组中寻找不同的序列，在许多不同的数组中寻找许多不同的序列-所有这些都需要不同的优化

数组和序列中字符的长度和分布也很重要，因为如果你知道一个长字符串中只有（比如）三个E，并且你知道它们在哪里，你需要搜索HELLO，那么HELLO可能只适合三个位置。所以你不必扫描整个字符串“我们祝你圣诞快乐，我们祝你圣诞快乐，新年快乐”字符串。实际上，你可能会注意到数组中没有L，并立即返回false

bool contains(char *Array, char *Sequence) {
     // CONTAINS - Function
     for (int i = 0; i < sizeof(Array); i++) {
         for (int s = 0; s < sizeof(Sequence); s++) {
             if (Array[i] == Sequence[i]) {
            
                 // How to check if Sequence is contained ?  
             }
         }
     }
    return false;
}
// in Main Function
char *Arr = "ABCDEFG";
char *Seq = "AB";
bool contained = contains(Arr, Seq);
if (contained) {
    printf("Contained\n");
} else {
    printf("Not Contained\n"); 
}

一个普通用例的平衡选项（它确实有病理案例）可能由（C源代码和链接中提供的解释）提供。这有一个设置成本，所以如果你需要在非常大的文本中寻找不同的短字符串，这不是一个好的选择（有一个并行搜索版本，适用于某些情况）。
基本上这是
strstr

const char* strstrn(const char* orig, const char* pat, int n)
{
    const char* it = orig;
    do
    {
        const char* tmp = it;
        const char* tmp2 = pat;
        if (*tmp == *tmp2) {
            while (*tmp == *tmp2 && *tmp != '\0') {
                tmp++;
                tmp2++;
            }
            if (n-- == 0)
                return it;
        }
        tmp = it;
        tmp2 = pat;
    } while (*it++ != '\0');
    return  NULL;
}

上面返回的
n
匹配字符串中的子字符串。
什么是
bools
？
sizeof（数组）
和
sizeof（序列）
不是字符串的长度，而是指针的大小。@MikeCAT噢，谢谢，那该用什么呢？@MikeCAT\bools->写错误，我道歉；（使用
strlen）
。它返回一个指向字符串中匹配的n个匹配项的指针，并返回一个指向匹配项的指针，如果您是否需要匹配的
bool
，可以检查
NULL
，这只是一个建议。@IlianZaprynaow我需要一个bool或出现的次数，这应该不难