// ConsoleApplication21.cpp: определяет точку входа для консольного приложения.
//

#include "stdafx.h"
#include <iostream>
#include "string.h"
#include <cctype>
#pragma warning(disable : 4996)
using namespace std;



char *replace(char *t, char* ns,char* sl, int *array_of_start_words, unsigned int k)
{
        //Вычисляем размер новой строки
        //Размер исходной строки + количество замен *(длина слова на которое заменяем - длина искомого слова)
        unsigned int new_size = strlen(t) + k * (strlen(sl) - strlen(ns));
        //Выделяем память под новую строку
        char *new_str = new char[new_size];
        //Создаем итераторы
        unsigned int iter_array = 0, iter_new_str = 0;
        //Цикл копирования исходной строки
        for (int i = 0; i < strlen(t); i++)
        {
                //Если номер текущего элемента не совпадает с номером начала найденного слова
                if(i != array_of_start_words[iter_array])
                {
                        //То просто копируем исходную строку
                        new_str[iter_new_str] = t[i];
                        iter_new_str++;
                }
                else
                {
                        //Иначе в исходной строке пропускаем найденное слово
                        i = i + strlen(ns) - 1;
                        //и вместо него в новую строку вставляем слово, на которое нужно заменить
                        for (int j = 0; j < strlen(sl); j++)
                        {
                                new_str[iter_new_str] = sl[j];
                                iter_new_str++;

                        }
                        //Увеличиваем итератор массива начала слов
                        iter_array++;
                }
        }
        //Добавляем признак конца строки
        new_str[iter_new_str] = '\0';
        //Возвращаем результирующую строку
        return new_str;
}
char *search(char *t,char *sr, char* ns, char* sl, unsigned int *k)
{
        //Вычисляем размеры всех исходных строк
        unsigned int size_input_str = strlen(t),size_separator_chars = strlen(sr),size_search_word = strlen(ns),size_replace_word = strlen(sl);
        //Вычисляем максимальное количество замен
        int size_array = (int)size_input_str/size_search_word + 1;
        //Итератор для массива начала слов
        unsigned int array_iter = 0;
        //Массив начала слов
        int *array_of_start_words = new int[size_array];
        //Цикл по исходной строке
        for (int i = 0; i < size_input_str; i++)
        {
                int j = 0;
                //Идем до первого символа, не являющимся разделительным
                while(j < size_separator_chars && i < size_input_str)
                {
                        if(t[i] == sr[j])
                                {
                                        i++;
                                        j = 0;
                                }
                        else j++;
                }
                //Цикл, проверяющий является ли слово искомым
                j = 0;
                while(j < size_search_word && i < size_input_str)
                {
                        if(t[i] == ns[j])
                        {
                                //Если первая буква совпадает, то запоминаем номер элемента в исходной строке
                                if(j == 0)
                                {
                                        array_of_start_words[array_iter] = i;
                                }
                                //Переходим к следующему элементу в исходной строке
                                        i++;
                                //Если найденная часть слова совпадает с искомым
                                if(j == size_search_word - 1)
                                {
                                        //то увеличивает итератор массива начала строк, тем самым запоминая начало найденного слова
                                        array_iter++;
                                        //Увеличиваем счетчик найденных замен
                                        (*k)++;
                                        j = -1;
                                        break;

                                }
                        }
                        else
                        {
                        //если буква не совпадает
                                //Пропускаем все буквы до первого разделительного символа, то есть если первая буква не совпала, то слово нам не подходит и мы его пропускаем

                                while( i < size_input_str)
                                {
                                        int j1 = 0;
                                        //Ищем первый встретившийся разделительный символ
                                                while(j < size_separator_chars && i < size_input_str)
                                                {
                                                        if(t[i] != sr[j1])
                                                        {
                                                                j1++;

                                                        }
                                                        else
                                                                break;
                                                }
                                                //Если нашли, то переходим к следующей проверке нового слова
                                                if(t[i] == sr[j])
                                                        break;
                                                else
                                                        i++;

                                }
                                break;

                        }
                        j++;
                }
        }
        //Возвращаем строку с замененными словами
        return replace(t,ns,sl,array_of_start_words,*k);
}

/*int sr_sr(char V, char *sr)
{
        bool z=0;
        while (*sr != '\0' && z != 1)
        {
                if (*sr == V)
                {
                        z = 1;
                        *sr++;
                }
        }
        return z;
}*/

int main()
{
    setlocale(LC_ALL, ".1251");
    // sr - строка разделителей, vs - вводимый символ, ns - строка искомых символов, sl - слово на которое заменяем, str - строка которую вставляем, vns - вводимый набор символов
    // vsl - вводимое слово, vst - вводимая строка
    char *sr = NULL, *ns = NULL, *sl = NULL, *str = NULL, vs, vns, vsl, vst;
    char **t, **rez, b[81];
    int l = 0, l1 = 0, l2 = 0, l3 = 0;// l - длина строки разделителей, l1 - длина строки набора символов, l2 - длина строки слова, l3 - длина строки
    int x=0,n1=0;
    unsigned int k = 0;
    bool f;

    puts("Введите строку символов разделителей:");
    do
    {
        sr = (char*) realloc (sr, (1+l)*sizeof(char)); // Увеличиваем память под строку разделителей
        vs = getchar(); // считываем символ
        sr[l] = vs; // Записываем символ в строку-разделителей
        l++; // Увеличиваем значение длины
    } while (sr[l-1] != '\n'); // Если введенный символ - enter, то выход из цила
    sr[l-1] = '\0'; // Заменяем последний введенный символ (enter в данном случае) на EOF (символ окончания строки).
    //for (int l = 0; l < strlen(sr); l++)
        //printf("%c", sr[l]);

    puts("Введите строку искомых символов:");

    do
    {
        ns = (char*) realloc (ns, (1+l1)*sizeof(char)); // Увеличиваем память под строку разделителей
        vns = getchar(); // считываем символ
        ns[l1] = vns; // Записываем символ в строку-разделителей
        l1++; // Увеличиваем значение длины
    } while (ns[l1-1] != '\n'); // Если введенный символ - enter, то выход из цила
    ns[l1-1] = '\0'; // Заменяем последний введенный символ (enter в данном случае) на EOF (символ окончания строки).
    //for (int l1 = 0; l1 < strlen(ns); l1++)
        //printf("%c", ns[l1]);

    //do
    //{
    puts("Введите слово на которое мы будем заменять:");
    do
    {
            sl = (char*) realloc (sl, (1+l2)*sizeof(char)); // Увеличиваем память под строку разделителей
            vsl = getchar(); // считываем символ
            sl[l2] = vsl; // Записываем символ в строку-разделителей
            l2++; // Увеличиваем значение длины
    } while (sl[l2-1] != '\n'); // Если введенный символ - enter, то выход из цила
    sl[l2-1] = '\0'; // Заменяем последний введенный символ (enter в данном случае) на EOF (символ окончания строки).
    //f=0;
    //for (int i = 0; i < strlen(sl); i++)
    //  for (int j = 0; j < strlen(sr); j++)
    //  {
    //      if (sl[i] == sr[j])
    //          f=1;
    //  }
    //  if (f==1)
    //      puts("Ошибка! Слово не должно содержать символов-разделителей");
    //  free(sl);
    //  sl=NULL;
    //} while(f==1);


    //for (int l2 = 0; l2 < strlen(sl); l2++)
        //printf("%c", sl[l2]);

    puts("Введите строку которая будет после строк количество замен в которых:");
    do
    {
        str = (char*) realloc (str, (1+l3)*sizeof(char)); // Увеличиваем память под строку разделителей
        vst = getchar(); // считываем символ
        str[l3] = vst; // Записываем символ в строку-разделителей
        l3++; // Увеличиваем значение длины
    } while (str[l3-1] != '\n'); // Если введенный символ - enter, то выход из цила
    str[l3-1] = '\0'; // Заменяем последний введенный символ (enter в данном случае) на EOF (символ окончания строки).
    //for (int l3 = 0; l3 < strlen(str); l3++)
        //printf("%c", str[l3]);

    puts("\nВведите количество строк массива с текстом: ");
        do
        {
                puts("Количество строк: ");
                fflush(stdin);
                scanf("%d", &x);
                if (x <= 0)
                puts("ОШИБКА!\nВведите число больше нуля.");
        } while (x <= 0);

        t = (char**)malloc((x + 1)*sizeof(char*));

        //rez = (char**)malloc((x + 1)*sizeof(char*));

        puts("\nВведите строки текста с символами-разделителями.\nТекст:");
        for (int i = 0; i < x; i++)
        {
                fflush(stdin);
                gets(b);
                t[i] = (char*)malloc((strlen(b) + 1)*sizeof(char));
                //rez[i] = (char*)malloc((strlen(b) + 1)*sizeof(char));
                strcpy_s(t[i],(strlen(b) + 1),b);
        }

        /*for (int m = 0; m < x; m++)
            {
                search( t[m],  sr,  ns,  sl, &k);
            }*/
        cout << endl;
        for (int m = 0; m < x; m++)
            {
                k = 0;
                cout << search(t[m], sr, ns, sl , &k) << endl;
                cout << "Замен произведено: " << k << endl << endl;
            }

    system("pause");
    return 0;
}