如何检查输入的字符串中是否存在模式？

Question

I have an assignment where the user enters a string and then a pattern in one function, and then has to check if the pattern exists in the string and how many times it appears and at what offset. I'm stumped and my classmates keep giving me cryptic hints. Below is my get function

int getNums()
{
    printf("Please enter a number: ");      //Initial printf

    int count, patcount;
    int torf;
    char len_num[31];       //The character array for the initial entered string
    char pat_num[6];        //The character array for the entered pattern after initial string
    char *lenptr = len_num;     //pointer to the address of the first element of len_num
    char *patptr = pat_num;     //pointer to the address of the first element of len_num

    scanf("%s", len_num);       //Where the user scans in their wanted number, which is treated as a string
    printf("\n");

    printf("%s\n", lenptr);
    int len = stringLength(lenptr);     //Checks how long string is
    int valid = isValid(len_num);       //Checks if string is valid


    for(count=0; count<len_num[count]; count++)     //Checks if length of string is within appropriate range
    {
        if(len>=10 && len<=30)      //Continues to pattern get if within range
        {
            torf=1;
        }

        else                        //Denies continuation if string is outside of range
        {
            torf=0;
            printf("Not within range! Try again!\n");
            return (1);
        }
    }

    printf("Please enter a pattern: ");     //Initial entry statement for pattern

    scanf("%s", pat_num);                   //User scans in pattern
    printf("\n");

    printf("%s\n", pat_num);
    len = stringPattern(patptr);            //Check how long pattern is
    valid = isValid(pat_num);               //Checks if pattern is valid

    for(patcount=0; patcount<pat_num[patcount]; patcount++) //Checks if length of pattern is within appropriate range
    {
        if(len>=2 && len<=5)                //Continues to pattern check if within range
        {
            torf=1;
        }

        else                                //Denies continuation if pattern is outside of range
        {
            torf=0;
            printf("Pattern not within range! Try again!\n");
            return (1);
        }
    }

    checkPattern();
}

I don't know how I should start my check function. Not to mention I have to pass by reference with pointers and I'm stuck with that too

Answer 1

Since you have asked for the pattern matching function, I did not check your string input function. You may use this simple driver code to test my solution:

#include <stdio.h>

void findPattern(char* input, char* pattern);

int main()
{
    char input[31], pattern[6];
    printf("Enter the string: ");
    scanf("%s", input);
    printf("Enter the pattern: ");
    scanf("%s", pattern);
    findPattern(input, pattern);
    return 0;
}

I prefer findPattern over checkPattern . You shall rename it according to your convenience. I have not used any library functions apart from that in stdio.h as per your requirement. Following is my take on this task, I have explained the logic in the comments. Basically, it just iterates over the entire input string once where it checks for a match with the initial character in the pattern. If so, it marks the offset and searches further down the pattern to find a complete match.

void findPattern(char* input, char* pattern)
{
    int i = 0; // iterator for input
    int j = 0; // iterator for pattern

    // solution variables
    int offset = 0;
    int occurrence = 0;

    // Search the entire input string
    while (input[i] != '\0')
    {
        // Mark the offset whenever the first character of the pattern matches
        if (input[i] == pattern[j])
        {
            offset = i;
            // I didn't quite get the relativity of your offset
            // Maybe you need: offset = i + 1;
        }

        // Search for complete pattern match
        while (input[i] != '\0' && pattern[j] == input[i])
        {
            // Go for the next character in the pattern
            ++j;

            // The pattern matched successfully if the entire pattern was searched
            if (pattern[j] == '\0')
            {
                // Display the offset
                printf("\nPattern found at offset %d", offset);

                // Increment the occurrence
                ++occurrence;

                // There are no more characters left in the pattern
                break;
            }
            else
            {
                // Go for the next character in the input
                // only if there are more characters left to be searched in the pattern
                ++i;
            }
        }

        // Reset the pattern iterator to search for a new match
        j = 0;

        // Increment the input iterator to search further down the string
        ++i;
    }

    // Display the occurrence of the pattern in the input string
    printf("\nThe pattern has occurred %d times in the given string", occurrence);
}

I have to pass by reference with pointers and I'm stuck with that too

If that's the case then instead of findPattern(input, pattern); , call this function as:

findPattern(&input, &pattern);

Answer 2

You may be way over thinking the solution. You have a string input with a number of characters that you want to count the number of multi-character matches of pattern in. One nice thing about strings is you do not need to know how long they are to iterate over them, because by definition a string in C ends with the nul-terminating character.

This allows you to simply keep an index within your findpattern function and you increment the index each time the character from input matches the character in pattern (otherwise you zero the index). If you reach the point where pattern[index] == '\\0' you have matched all characters in your pattern.

You must always declare a function with a type that will provide a meaningful return to indicate success/failure of whatever operation the function carries out if it is necessary to the remainder of your code (if the function just prints output -- then void is fine).

Otherwise, you need to choose a sane return type to indicate whether (and how many) matches of pattern were found in input . Here a simple int type will do. (which limits the number of matches that can be returned to 2147483647 which should be more than adequate).

Putting those pieces together, you could simplify your function to something similar to:

int findpattern (const char *input, const char *ptrn)
{
    int n = 0, idx = 0;             /* match count and pattern index */

    while (*input) {                /* loop over each char in s */
        if (*input == ptrn[idx])    /* if current matches pattern char */
            idx++;                  /* increment pattern index */
        else    /* otherwize */
            idx = 0;                /* zero pattern index */
        if (!ptrn[idx]) {           /* if end of pattern - match found */
            n++;                    /* increment match count */
            idx = 0;                /* zero index for next match */
        }
        input++;                    /* increment pointer */
    }

    return n;                       /* return match count */
}

Adding a short example program that allows you to enter the pattern and input as the first two arguments to the program (or uses the defaults shown if one or both are not provided):

int main (int argc, char **argv) {

    char  *pattern = argc > 1 ? argv[1] : "my",
            *input = argc > 2 ? argv[2] : "my dog has fleas, my cat has none";
    int n;

    if ((n = findpattern (input, pattern)))
        printf ("'%s' occurs %d time(s) in '%s'\n", pattern, n, input);
    else
        puts ("pattern not found");
}

Note how providing a meaningful return allows you to both (1) validate whether or not a match was found; and (2) provides the number of matches found through the return. The complete code just needs the header stdio.h , eg

#include <stdio.h>

int findpattern (const char *input, const char *ptrn)
{
    int n = 0, idx = 0;             /* match count and pattern index */

    while (*input) {                /* loop over each char in s */
        if (*input == ptrn[idx])    /* if current matches pattern char */
            idx++;                  /* increment pattern index */
        else    /* otherwize */
            idx = 0;                /* zero pattern index */
        if (!ptrn[idx]) {           /* if end of pattern - match found */
            n++;                    /* increment match count */
            idx = 0;                /* zero index for next match */
        }
        input++;                    /* increment pointer */
    }

    return n;                       /* return match count */
}

int main (int argc, char **argv) {

    char  *pattern = argc > 1 ? argv[1] : "my",
            *input = argc > 2 ? argv[2] : "my dog has fleas, my cat has none";
    int n;

    if ((n = findpattern (input, pattern)))
        printf ("'%s' occurs %d time(s) in '%s'\n", pattern, n, input);
    else
        puts ("pattern not found");
}

Example Use/Output

Check for multiple matches:

$ ./bin/findpattern
'my' occurs 2 time(s) in 'my dog has fleas, my cat has none'

A single match:

$ ./bin/findpattern fleas
'fleas' occurs 1 time(s) in 'my dog has fleas, my cat has none'

Pattern not found

$ ./bin/findpattern gophers
pattern not found

All the same pattern:

$ ./bin/findpattern my "mymymy"
'my' occurs 3 time(s) in 'mymymy'

---

Output From Function Itself

While it would be better to provide a return to indicate the number of matches (which would allow the function to be reused in a number of different ways), if you did just want to make this an output function that outputs the results each time it is called, then simply move the output into the function and declare another pointer to input so input is preserved for printing at the end.

The changes are minimal, eg

#include <stdio.h>

void findpattern (const char *input, const char *ptrn)
{
    const char *p = input;          /* pointer to input */
    int n = 0, idx = 0;             /* match count and pattern index */

    while (*p) {                    /* loop over each char in s */
        if (*p == ptrn[idx])        /* if current matches pattern char */
            idx++;                  /* increment pattern index */
        else    /* otherwize */
            idx = 0;                /* zero pattern index */
        if (!ptrn[idx]) {           /* if end of pattern - match found */
            n++;                    /* increment match count */
            idx = 0;                /* zero index for next match */
        }
        p++;                        /* increment pointer */
    }

    if (n)  /* output results */
        printf ("'%s' occurs %d time(s) in '%s'\n", ptrn, n, input);
    else
        puts ("pattern not found");
}

int main (int argc, char **argv) {

    char  *pattern = argc > 1 ? argv[1] : "my",
            *input = argc > 2 ? argv[2] : "my dog has fleas, my cat has none";

    findpattern (input, pattern);
}

(use and output are the same as above)

Look things over and let me know if you have further questions.