Question

为即将进行的测试做一些练习。有点卡在这一个。

“编写一个程序，该程序要求用户输入两个字符串，并检查并打印一条消息，如果第二个字符串在第一个字符串中是包含循环。循环包含意味着第二个字符串中的任何一个正常显示在第一个字符串或第二个字符串中出现，以便其前缀出现在第一个字符串的末尾，而延续出现在第一个字符串的开头。”

您可以假定字符串仅包含小写字母。仅允许使用字符串函数：strlen，strcpy，strcmp，strcat

例如：

字符串A：iti sanic eday 字符串B： sanic

是正常情况

字符串A：它 isanice 天字符串B： dayit

这是周期性事件。

到目前为止我做了什么：

#include <iostream>
#include <string.h>
using namespace std;
#define Max 128

int isCyclic(char* str1, char* str2);

int main()
{
    char* str1 = new char[Max];
    char* str2 = new char[Max];

    cout << "Please enter two strings:" << endl;

    cin >> str1 >> str2;

    cout << isCyclic(str1, str2) << endl;


    delete[] str1;
    delete[] str2;
}

int isCyclic(char* str1, char* str2)
{
    int s1 = strlen(str1);
    int s2 = strlen(str2);

    if (s1!=s2) // if string size is diffrent - they are not contained cyclic
    {
        return 0;
    }


}

Answer 1

这是问题第二部分（循环部分）的解决方案。我只是简单地浏览了第一个字符串中的所有字符，并检查它们是否是第二个字符串的循环出现的开始。要检查我是否使用了％（modolu操作），如果您不知道它的剂量，那么您现在真的需要学习它。我也用bool而不是int，因为数字令人困惑（并且被诅咒）。

    #include <iostream>
    #include <string.h>
    using namespace std;
    #define Max 128

    bool isCyclic(char* str1, char* str2);
    bool isCyclic(char* str1, char* str2,int start);

    int main()
    {
        char* str1 = new char[Max];
        char* str2 = new char[Max];
        cout << "Please enter two strings:" << endl;
        cin >> str1 >> str2;
        cout << isCyclic(str1, str2) << endl;
        delete[] str1;
        delete[] str2;
    }
    bool isCyclic(char* str1, char* str2)   {
            for(int i = 0; i < strlen(str1); i++)   {
                    if(str1[i] == str2[0] && isCyclic(str1,str2,i)) {
                            return true;
                    }
            }
            return false;
    }

    bool isCyclic(char* str1, char* str2,int start)
    {
            int containingStrLen = strlen(str1);
            for(int i = 0; i < strlen(str2); i++)   {
                    if(str1[(start + i)%containingStrLen] != str2[i])       {
                            return false;
                    }
            }
            return true;
    }

此代码中仍然缺少一些东西：

1）问题的第一部分（可以很容易地从此代码中得出）。

2）一些大小验证（例如，在使用前确保str1大于str2）是循环的。而且字符串要比Max小（我认为是）。

3）打印正确的结果。

祝您考试顺利：）

Answer 2

您将需要两个循环，第一个循环在字符串1上，这是我们比较字符串1的起点，第二个循环在字符串2上，这将以循环方式与字符串1匹配。如果我们到达字符串1的末尾，但在字符串2中仍留有一些字符，则从索引0开始在字符串1中循环。


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

// Should be avoided in general. Use scope resolution instead.
using namespace std;

char* isCyclic(char* s1, char* s2){
    int s1_size = strlen(s1);
    int s2_size = strlen(s2);

    // s1 must contain s2
    if(s2_size > s1_size)
        return "No Occurence";


    for(int i = 0; i < s1_size; i++){
        int current = i;
        // Boolean to track if we are currently cycling through s1
        bool inCycle = false;
        int j = 0;
        for(; j < s2_size; j++, current++){
            // character wise comparision
            if(s2[j] != s1[current])
                break;
            if(! inCycle){
                // start from first. Note that we are setting current = -1.
                // as we will be incrementing it in the for loop.
                if(current == s1_size - 1 && j < s2_size - 1){
                    current = -1;
                    inCycle = true;
                }
            }
        }

        if(j == s2_size){
            if(inCycle)
                return "cyclic";
            else
                return "regular";
        }
    }

    return "No Occurence";
}


int main()
{
    printf("Hello World\n");

    char* s1 = "itisaniceday";
    char* s2 = "dayitis";

    cout<<"Occurence Type: "<<isCyclic(s1, s2)<<endl;

    return 0;
}

Answer 3

有一个简单的技巧：如果在字符串的末尾重复字符串的前缀，则问题将变成直接子字符串搜索，因为循环匹配将在末尾重新组合。它还处理子字符串循环返回自身的极端情况，例如"looploop"内的"loop"。

因此，您将使用破碎的C形方言来做到这一点：

bool containsCyclic(char const *string, char const *substring) {
    std::size_t const stringLen = std::strlen(string);
    std::size_t const substringLen = std::strlen(substring);

    // Too long a substring wouldn't fit in the string
    if(substringLen > 2 * stringLen)
        return false;

    // Concatenate `string` with its own substring-long prefix
    char *const loopedString = new char[stringLen + substringLen + 1];
    std::strcpy(loopedString, string);

    { // Partial reimplementation of std::strncpy(loopedString, string, substringLen)
        char const *src = string;
        char *dest = loopedString +  stringLen;
        for(std::size_t count = 0; count < substringLen; ++count)
            *dest++ = *src++;

        *dest = '\0';
    }

    { // Partial and naïve reimplementation of std::strstr(loopedString, substring)
        for(char const *start = loopedString; start < loopedString + stringLen; ++start) {
            // Check if substring is present at this offset
            char const *s1 = start;
            char const *s2 = substring;

            while(*s2 != '\0' && *s1 == *s2)
                ++s1, ++s2;

            if(*s2 == '\0') {
                // We found a complete match of substring inside loopedString
                delete[] loopedString;
                return true;
            }
        }
    }

    // No match found
    delete[] loopedString;
    return false;
}

为了踢球，这里是C ++：

bool containsCyclicCpp(std::string const &string, std::string const &substring) {
    std::string const loopedString = string + string.substr(0, substring.size());
    return loopedString.find(substring) != std::string::npos;
}

See it live on Coliru（带有测试！）

程序检查一个字符串是否在另一个字符串中包含循环

3 个答案: