» Stringverarbeitung

1. Den String von allem befreien, was keine Buchstaben sind.
2. Alle Buchstaben in Großbuchstaben umwandeln.
3. Durch den String iterieren und mit dem Teilstring vergleichen.

/* findstring.c
/  
/  Zaehlt das Vorkommen eines Teilstrings innerhalb einer Zeichenkette.
/  Gross- und Kleinschreibung wird nicht beachtet.
/  Nur Buchstaben werden beruecksichtigt. Leer- und Sonderzeichen nicht.
*/

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

#define MAX_CHAR_IN_STRING 100

/* Entfernt alle Zeichen, ausser den Buchstaben und ordnet sie lueckenlos
   aneinander. Erwartet die Quell-Zeichenkette als Parameter. */
void reArrangeStr(char *srcStr);

/* Zaehlt wie oft der Teilstring im Quellstring vorkommt.
   Erwartet als Parameter den Quellstring und den Teilstring.
   Rueckgabewert ist die Anzahl des Vorkommens. */
int countPartStr(const char *srcStr, const char *partStr);

int main(void)
{
    /* Quell-Zeichenkette, nicht aenderbar. */
    const char constSrcStr[MAX_CHAR_IN_STRING] = 
        "ic h bin ICH, weil ich Ich bin.";

    /* Teilstring, nicht aenderbar. */
    const char constPartStr[MAX_CHAR_IN_STRING] = "ICH";

    /* Veraenderbarer Quellstring. */
    char tmpSrcStr[MAX_CHAR_IN_STRING];

    strcpy(tmpSrcStr, constSrcStr);
    reArrangeStr(tmpSrcStr);

    int i = 0; /* Zaehlvariable fuer Schleife */

    /* Alle Buchstaben im temporaerem String in Grossbuchstaben
       umwandeln. */
    while (tmpSrcStr[i] && i < MAX_CHAR_IN_STRING)
    {
        tmpSrcStr[i] = toupper(tmpSrcStr[i]);
        i++;
    }

    /* Wie oft kommt der Teilstring vor? */
    int amountOfPartString = countPartStr(tmpSrcStr, constPartStr); 

    if (amountOfPartString > 0)
    {
        printf("Im Quellstring\n");
        printf("<%s>\n", constSrcStr);
        printf("konnte der Teilstring <%s> ", constPartStr);
        printf("%d Mal gefunden werden.\n", amountOfPartString);
    }
    else if (amountOfPartString == 0)
    {
        printf("\nTeilstring ist im Quellstring nicht vorhanden!\n\n");
    }
    else
    {
        printf("\nFehler! Teilstring ist laenger als der Quellstring!\n\n");
    }

    return 0;
}

void reArrangeStr(char *srcStr)
{
    /* Zum Aufangen der Buchstaben. */
    char tmpStr[MAX_CHAR_IN_STRING];

    int i = 0; /* Zaehlvariable fuer Schleife */
    int j = 0; /* Zaehlvariable fuer temporaeren String */

    while (srcStr[i] && i < MAX_CHAR_IN_STRING)
    {
        /* Ausschliesslich die Buchstaben werden vom Quellstring
           in den temporaeren String geschrieben. */
        if ((srcStr[i] >= 'A' && srcStr[i] <= 'Z') || 
            (srcStr[i] >= 'a' && srcStr[i] <= 'z'))
        {
            tmpStr[j] = srcStr[i];
            j++;
        }

        i++;
    }

    /* Zur Sicherheit bekommt der temporaere String ein NULL_Byte. */
    tmpStr[j] = '\0';

    /* Quell-String wird mit dem temporaerem String ueberschrieben. */
    strcpy(srcStr, tmpStr);
}

int countPartStr(const char *srcStr, const char *partStr)
{
    /* Zum Speichern des Rueckgabewerts, die Anzahl des vorkommenden
       Teilstrings. */
    int amount = 0;

    int lenghtOfSrcStr = strlen(srcStr);
    int lenghtOfPartStr = strlen(partStr);

    if (lenghtOfPartStr > lenghtOfSrcStr)
    {
        /* Rueckgabewert, wenn Teilstring länger ist als der Quellstring. */
        amount = -1;
    }
    else if (lenghtOfPartStr == lenghtOfSrcStr)
    {
        /* Wenn Teilstring und Quellstring gleich lang sind, dann
           koennen beide problemlos miteinander verglichen werden. */
        if (strcmp(srcStr, partStr) == 0)
        {
            amount = 1;
        }
    }
    else
    {
        /* Mit diesem String werden die Vergleiche durchgefuehrt */
        char tmpStr[MAX_CHAR_IN_STRING];

        /* Solange durch den Quellstring iterieren, bis der Teilstring
           beim letzten Durchlauf exakt am Ende des Quellstrings seht. */
        for (int i = 0; i <= lenghtOfSrcStr - lenghtOfPartStr; i++)
        {
            int countTmpStr = 0;

            /* Zeichen mit derselben Laenge wie der Teilstring in den
               temporaeren String kopieren */
            for (int j = i; j < i + lenghtOfPartStr; j++)
            {
                tmpStr[countTmpStr] = srcStr[j];
                countTmpStr++;
            }
     
            tmpStr[countTmpStr] = '\0';

            if (strcmp(tmpStr, partStr) == 0)
            {
                amount++;
            }
        }
    }

    return amount;
}

Mach mit!