// Реверс (переворот) информации в массиве во введенном интервале [i1 , i2]
// i1, i2 - границы интервала (вводятся с клавиатуры)
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <locale.h>
#define kl 10        // размерность массива (глобальная константа)

int main()
{
    setlocale(LC_ALL, "Russian");     // русификация вывода информации на экран
    int ms[kl], i, i1, i2, kk;        // объявление локальных данных
    printf("\nВведите массив");       // приглашение на ввод массива
    for (i = 0; i<kl; i++)            // цикл по ввода массива поэлементно
    {
        printf("\nВведите ms[%d] = ", i);
        scanf("%d", &ms[i]);
    }
    do                                 // цикл ввода чисел (границ интервала)
    {                                  // с проверкой на корректность ввода
        system("CLS");                 // очистка экрана
        printf("введите 2 числа (первое меньшее, второе большее)\n");
        fflush(stdin);                     // чистка буфера ввода
        kk = scanf_s("%d%d", &i1, &i2);    // ввод границ интервала последовательности (массива)
    } while (kk<2 || i1>i2);               // цикл повторяется пока корректно введено меньше 2 чисел
                                           // или индекс начала интервала > индекса конца интервала
    system("CLS");
    printf("\nИсходный масссив : ");     // вывод исходного массива
    for (i = 0; i < kl;  i++)            // цикл по строкам массива
        printf("%4d", ms[i]);
    printf("\n");
    for (; i1 < i2; i1++, i2--)          // цикл пока i1 < i2, т.е. пока границы (левая и правая)
    {                                    // не сойдутся
        kk = ms[i1];                     // запоминаем значение элемента по индексу i1 в kk
        ms[i1] = ms[i2];                 // заносим в элемент с индексом i1 значение элемента с индексом i2
        ms[i2] = kk;                     // переписываем значение из kk в элемент с индексом i2
    }

    printf("\nПреобразованный массив : ");  // вывод массива
    for (i = 0; i<kl; i++)               // цикл по строкам массива
        printf("%4d", ms[i]);
    printf("\n");
    return 0;
}












// Транспонировать матрицу относительно главной диагонали
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <locale.h>
#define nn 3

void main()
{
    setlocale(LC_ALL, "Russian");     // русификация вывода информации на экран
    int mas[nn][nn], i, j, kk;
    printf("\nВведите матрицу");      // ввод массива
    for (i = 0; i<nn; i++)            // цикл по строкам массива
    {
        printf("\nВведите строку %d  ", i);
        for (j = 0; j<nn; j++)        // цикл по столбцам массива
            scanf("%d", &mas[i][j]);
    }
    system("CLS");
    printf("\nИсходная матрица");     // вывод исходного массива
    for (i = 0; i<nn; i++)            // цикл по строкам массива
    {
        printf("\n");
        for (j = 0; j<nn; j++)        // цикл по столбцам массива
            printf("%5d", mas[i][j]);
    }
    /*************
    //       ====    for(){...}
    for(i=0;i<nn;i++)
    for(j=i+1;j<nn;j++)
    { kk=mas[i][j];
      mas[i][j]=mas[j][i];
      mas[j][i]=kk;
    }
    **************
    //       ====    do{...}while()
    i=0;
    do
    { j=i+1;
      do
      {  kk=mas[i][j];
         mas[i][j]=mas[j][i];
         mas[j][i]=kk;
         j++;
      }while(j<nn);
      i++;
    }while(i<nn);
    **************/
    //       ====    while(){...}
    i = 0;
    while (i<nn)
    {
        j = i + 1;
        while (j<nn)
        {
            kk = mas[i][j];
            mas[i][j] = mas[j][i];
            mas[j][i] = kk;
            j++;
        };
        i++;
    };

    printf("\nТранспонированная матрица"); /*вывод массива*/
    for (i = 0; i<nn; i++)          /*цикл по строкам массива*/
    {
        printf("\n");
        for (j = 0; j<nn; j++)        /*цикл по столбцам массива*/
            printf("%5d", mas[i][j]);
    }
}






#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <locale.h>

void srt1(int, int *);
void srt2(int, int *);
void srt3(int, int *);
void shaker(int, int *);
void shell(int,int *);

int main()
{
    const int n = 7;                  // размерность массива ms
    int ms[n], i, c;
    setlocale(LC_ALL, "Russian");     // русификация вывода информации на экран
    do
    {
        system("CLS");
        for (i = 0; i<n; i++)
        {
            printf("ms[%2d]= ", i);
            scanf("%d", &ms[i]);
        }
        system("CLS");
        printf("\nИсходный масссив : ");  // вывод исходного массива 1
        for (i = 0; i < n; i++)
            printf("%4d", ms[i]);
        printf("\nвыберите метод сортировки");
        printf("\n1 - через отбор");
        printf("\n2 - сортировка вставками");
        printf("\n3 - методом пузырька");
        printf("\n4 - шейкер сортировка");
        printf("\n5 - сортировка Шелла\n");
        scanf("%d", &i);
        switch (i)
        {
           case 1: srt1(n, ms); break;
           case 2: srt2(n, ms); break;
           case 3: srt3(n, ms); break;
           case 4: shaker(n, ms); break;
           case 5: shell(n, ms); break;
           default: printf("ошибка в выборе метода сортировки");
        }
        printf("\nИсходный масссив : ");  // вывод отсортированного массива 1
        for (i = 0; i<n; i++) printf("%3d ", ms[i]);
        fflush(stdin);
        printf("\n\nвыполнить сортировку еще (y/n).. ");
        c = getch();
    } while (c == 'y' || c == 'Y');
    return 0;
}

// сортировка массива  методом "ЧЕРЕЗ ОТБОР"
void srt1(int kl, int *ms)
{
    int i, j, m, kk;
    for (i = 0; i<kl - 1; ++i)
    {
        m = i;                     // индекс элемента для упорядочивания
        kk = ms[i];                // значение элемента
        for (j = i + 1; j<kl; ++j) // перебор последующих эл-тов справа от i-го
        if (ms[j]<kk)              // найден меньший
        {
            m = j;                 // запоминаем его индекс и значение
            kk = ms[j];
        }
        ms[m] = ms[i];             // замена выбранного и меньшего
        ms[i] = kk;
    }
}

// сортировка массива  методом " ВСТАВКИ "
void srt2(int kl, int ms[])
{
    setlocale(LC_ALL, "RUS");
    int i, j, kk;
    for (i = 1; i<kl; ++i)        // индекс элемента для упорядочивания
    {
        j = i - 1;                // индекс предыдущего элемента
        kk = ms[i];               // значение предыдущего элемента
        while (j >= 0 && kk<ms[j])
            ms[j-- + 1] = ms[j];  // сдвиг всех элементов направо
        ms[j + 1] = kk;           // запись в освободившийся или в тот же элемент
    }
}

// сортировка чисел методом "ПУЗЫРЬКА"
void srt3(int kl, int *ms)
{
    int i, j, m;
    for (i = 0; i<kl - 1; ++i)     // цикл выбора элементов до последнего к упорядочиванию
    for (j = kl - 1; j>i; --j)     // цикл перебора эл-тов с конечного до i-го
    {
        if (ms[j - 1]>ms[j])       // если (j-1)-й > j-го элемента, то
        {                          // выполныется их перестановка
            m = ms[j - 1];
            ms[j - 1] = ms[j];
            ms[j] = m;
        }
    }
}

//  "Шейкер"  сортировка чисел
void shaker(int kl, int *ms)
{
    register int i, a, b, c, d;
    c = 1;
    b = kl - 1;   //номер элемента на котором остановка
    d = kl - 1;   //номер стартового элемента для сортировки справа налево
    do
    {
        for (i = d; i >= c; --i)    // цикл попарного сравнения элементов
        {                           // справа налево по массиву
            if (ms[i - 1]>ms[i])    // выполняется условие перестановки
            {                       // (i-1)-ого и i-го элемента
                a = ms[i - 1];
                ms[i - 1] = ms[i];
                ms[i] = a;
                b = i;              // запоминаем крайний слева упорядоченный элемент
            }
        }
        c = b + 1;                  // номер стартового элемента для сортировки слева направо
        for (i = c; i <= d; ++i)    // аналогично предыдущему циклу, но движение
        {                           // слева направо по массиву
            if (ms[i - 1]>ms[i])
            {
                a = ms[i - 1];
                ms[i - 1] = ms[i];
                ms[i] = a;
                b = i;              // крайний слева упорядоченный элемент
            }
        }
        d = b - 1;
    } while (c <= d);
}

// "Шелл" сортировка чисел
void shell(int kl, int ms[])
{
    register int i, j, dp, a;
    for (dp = kl / 2; dp>0; dp /= 2)
    for (i = dp; i<kl; i++)
    for (j = i - dp; j >= 0 && ms[j]>ms[j + dp]; j -= dp)
    {
        a = ms[j];
        ms[j] = ms[j + dp];
        ms[j + dp] = a;
    }
}



#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <locale.h>
#include <windows.h>

int str_len(char *);
char *getstr(char *);
int get_str(char *, int);
int atoi(char *s);
void itoa(int , char *);
int str_cmp(char *, char *);
char * strcat(char *, char *, int);

int main()
{
    setlocale(LC_ALL, "Russian");
    char *s1, *s2;
    int n, n1, n2;
    double d;
    do
    {
        system("CLS");
        fflush(stdin);
        printf("введите размерность ПЕРВОЙ строки = ");
    } while (!scanf("%d", &n1) || n1 <= 0);
    if (!(s1 = (char *)calloc(n1, sizeof(char))))
    {
        printf("\nНедостаточно свободной памяти \n");
        return 0;
    }
    do
    {
        system("CLS");
        fflush(stdin);
        printf("введите размерность ВТОРОЙ строки = ");
    } while (!scanf("%d", &n2) || n2 <= 0);
    if (!(s2 = (char *)calloc(n2, sizeof(char))))
    {
        printf("\nНедостаточно свободной памяти \n");
        free(s1);
        return 0;
    }

    printf("Вводите первую строку  ");
    fflush(stdin);
    printf("\n строка %s", getstr(s1)); //ввод-вывод первой строки
    printf("\nДлина первой строки == %d байт", str_len(s1));
    d = atof(s1);
    printf("\nЗначение числа (double) в строке %s == %lf \n", s1, d);
    printf("\nДлина второй строки == %d байт", get_str(s2, n2));
    printf("\nЗначение числа (int) в строке %s == %d ", s2, atoi(s2));
    printf("\nВводите число для перевода в строку  ");
    scanf("%d", &n);
    itoa(n, s2);
    printf("\n строка %s", s2);
    if (str_cmp(s1, s2)>0) printf("\nСтрока 1 > строки 2");
    else if (str_cmp(s1, s2)<0) printf("\nСтрока 1 < строки 2");
    else printf("\nСтрока 1 = строке 2");
    s1 = strcat(s1, s2, 3);                // РАЗОБРАТЬСЯ (здесь возникает проблема !!!!!!!!!!!!!)
    printf("\nстрока (s1+s2) == %s", s1);
    return 0;
}

// ввод строки по адресу переданному в нее
char *getstr(char *st)
{
    if (!st) return nullptr;   // передан указатель на невыделенную под строку память
    int i = 0;
    // в цикле символы заносятся в строку из буфера клавиатуры
    // до тех пор пока не будет нажата клавиша ENTER
    while ((*(st + i++) = (char)getchar()) != '\n');
    st[--i] = '\0';    // добавляем в конец строки символ '\0'
    return st;            // выход из функции
}

// ввод строки и подсчет ее длины
// get_str возвращает значение типа int
// в указатель st копируется указатель на строку для ввода
int get_str(char *st, int k)
{
    int c, i = 0;
    printf("\nВводите вторую строку  ");
    // в цикле символы заносятся в строку из буфера клавиатуры
    // до тех пор пока не будет нажата клавиша ENTER или
    // из буфера не будет получен k-1 символ
    while (--k>0 && (c = getchar()) != EOF && c != '\n')
        st[i++] = c;    // ввод строки до заданного кол-ва символов или пока
                        // не нажата клавиша Enter или Ctrl + Z
    st[i] = '\0';
    return i;    // возврат длины строки
}

// определение длинны строки
int str_len(char *st)
{
    int n = 0;
    for (; st[n] != '\0'; n++);
    return n;
}

// перевод цифровой символьной строки в signed int
int atoi(char *st)
{
    int n, i = 0, znak;
    while (st[i] == ' ') i++;
    if (!st[i]) return 0;              // в строке одни пробелы
    znak = (st[i] == '-') ? -1 : 1;    // запоминаем знак числа
    if (st[i] == '+' || st[i] == '-')  // пропуск знака в строке
        i++;
    for (n = 0; st[i] >= '0' && st[i] <= '9'; i++)  // выбор символа цифры числа из строки
        n = 10 * n + (st[i] - '0');    // формирование числа из цифр строки
    return znak*n;                     // возврат числа со знаком
}

// перевод числа типа signed int в символьную строку
void itoa(int n, char *st)
{
    int i = 0, znak;
    if ((znak = n)<0)            // сохраняем знак
        n *= -1;                 // n - положительное число
    do                // (ВАЖНО!!!) цифры заносим в строку в обратном порядке
    {
        st[i++] = n % 10 + '0';  // выделяется последняя справа цифра числа (как символ)
    } while ((n /= 10)>0);       // удаляется эта цифра из числа путем целочисленного деления на 10

    if (znak<0) st[i++] = '-';   // добавляем в конец строки знак числа
    st[i] = '\0';
    for (n = 0; n < i/2; n++)    // цикл переворота (реверса) полученной строки
    {
        st[n] += st[i - 1 - n];
        st[i - 1 - n] = st[n] - st[i - 1 - n];
        st[n] -= st[i - 1 - n];
    }
}

// функция сравнения двух строк
int str_cmp(char *st1, char *st2)
{
    while (*st1)     // истина пока не достигнут конец ('\0') строки s1
    if (*st1 - *st2) return *st1 - *st2;  // >0 если ASCII-код  *s1 > *s2
                                          // иначе <0
    else                                  // при совпадении символов переход
    {
        st1++;                            // к анализу следующей пары символов
        st2++;
    }
    return *st1 - *st2;  // строки либо полностью совпали либо одна окончилась
}

//  -------------------------
//  for (;*s==*t; s++,t++)
//  if(!*s) return 0;
//  return *s-*t;
//  --------------------------

// функция вставки (добавления) в строку st1 строки st2
// с позиции k
char * strcat(char *st1, char *st2, int k)
{
    char *ss;
    int i, n;
    if (k>str_len(st1)) k = str_len(st1); // проверка куда вставлять строку st2
                                          // перевыделение памяти для новой строки st1
    st1 = (char*)realloc(st1, str_len(st1) + str_len(st2) + 1);
    for (i = str_len(st1); i >= k; i--)   // сдвиг в строке st1 второй части (до позиции k)
        *(st1 + i + str_len(st2)) = *(st1 + i); // вправо
    for (i = 0; i<str_len(st2); i++)      // перезапись второй строки st2 в строку st1
        *(st1 + k + i) = *(st2 + i);      // с позиции k
    return st1;
}




// пример работы с двумерным массивом (матрицей)
// используя УКАЗАТЕЛЬ на УКАЗАТЕЛЬ
#include <stdio.h>
#include <conio.h>
#include <locale.h>
#include <windows.h>
#include <stdlib.h>

int Vvod(int **MS, int n_str, int n_stl)
{
    int i, j, fl;
    if (!MS)                           // проверка не нулевой ли указатель
    {
        puts("память для массива (матрицы) не выделена");
        return 1;
    }
    printf("\nВвод массива (матрицы)\n");
    for (i = 0; i < n_str; i++)        // цикл по строкам массива(матрицы)
    for (j = 0; j < n_stl; j++)        // цикл по элементам строки (столбцам) массива(матрицы)
    {
        printf("MS[ %d ][ %d ] = ", i, j);
        fflush(stdin); //rewind(stdin);        // чистка входного буфера
        if (!scanf("%d", *(MS + i) + j)) j--;  // проверка введено ли число
        // if (!scanf("%d", &MS[i][j]));       // можно использовать и MS[i][j]
    }
    return 0;
}

void Print(int **MS, int n_str, int n_stl)
{
    int i, j;
    if (!MS)                              // проверка не нулевой ли указатель
    {
        puts("память для массива (матрицы) не выделена");
        return;
    }
    printf("\n");
    for (i = 0; i < n_str; i++)           // цикл по строкам массива(матрицы)
    {
        for (j = 0; j < n_stl; j++)       // цикл по элементам строки (столбцам) массива(матрицы)
            printf("%4d", *(*(MS + i) + j));
            // printf("%4d", MS[i][j]);   // можно использовать и MS[i][j]
        printf("\n");
    }
}

//--------------------------------------------- пример 1 -----------------------------------
// пример работы с двухмерным массивом через указатель на указатель
// найти выше главной диагонали max ст-ц и ниже min
int main()
{
    setlocale(LC_ALL, "Russian");
    int **p, n, s, i, j, j1, j2, sum1, sum2, sum;
    do
    {
        system("CLS");
        printf("\nвведите размерность квадратной матрицы\n");
        i = scanf("%d", &n);
        if (i<1)
        {
            fflush(stdin);  // чистка буффера клавиатуры при ошибке ввода
            continue;       // повтор цикла
        }
        s = n;             // матрица квадратная (число строк=числу столбцов)
        if (!(p = (int **)malloc(sizeof(int*)*n)))
            printf("\nНедостаточно свободной памяти \nУуменьшите число строк массива");
        for (i = 0; i<n; i++) // цикл выбора указателя на строку матрицы
        if (!(*(p + i) = (int *)malloc(sizeof(int)*s))) // выделение памяти под строку матрицы
        {                                               // с проверкой выделена ли память
            printf("\nНедостаточно свободной памяти \nУуменьшите число ст-цов массива");
            for (j = 0; j<i; j++) free(*(p + j)); free(p); // освобождение памяти при ошибке
            p = nullptr;   // сброс указателя для повтора операции выделения памяти
            break;         // выход из цикла по i (выбора указателя на строку матрицы)
        }
    } while (!p);

    Vvod(p, n, s);
    system("CLS");
    printf("\nВведенный массив");
    Print(p, n, s);
    sum = 0;               // sum - переменная для накопления текущей суммы (выше/ниже) диагон.
                                   // sum1 и sum2 - переменные (контрольные) для анализа сумм                               // в анализир. ст-це с их начальной инициализацией
    sum1 = *(*p + 1);              // для поиска max ст-ца выше диагонали (верхний эл-т второго ст-ца)
    sum2 = *(*(p + n - 1) + s - 2);// для поиска min ст-ца ниже диагонали (нижний эл-т предпосл. ст-ца)
    j1 = 1; j2 = s - 2;            // стартовые номера ст-цов (второй и предпоследний)
    for (j = 0; j<s; j++)          // цикл выбора очередного столбца матрицы к анализу
    {
        for (i = 0; i<n; i++)      // цикл по элементам этого (j-го) ст-ца
        if (i != j) sum += *(*(p + i) + j);// выбран для суммы не элемент диагонали
        else                               // выбран элемент диагонали
        {
            if (sum1<sum)                  // найден ст-ц с большей суммой чем sum1
            {
                sum1 = sum;  j1 = j;       // запоминаем найденную сумму и номер ст-ца с этой суммой
                sum = 0;                   // сброс суммы для подсчета суммы под диагональю
            }
        }
        if (j<s - 1 && sum2>sum)           // найден ст-ц с меньшей суммой чем sum2
        {
            sum2 = sum; j2 = j;            // запоминаем найденную сумму и номер ст-ца с этой суммой
        }
        sum = 0;                           // сброс суммы для аналица следующего ст-ца

    }
    for (i = 0; i<n; i++)                 // НАПРИМЕР обнуление найденных ст-цов (или что-либо иное)
    {
        if (i<j1) *(*(p + i) + j1) = 0;
        if (i>j2) *(*(p + i) + j2) = 0;
    }
    printf("\n\nПреобразованный массив");
    Print(p, n, s);
    for (i = 0; i<n; i++)  free(*(p + i));// освобождение памяти на которую указывает p[i]
    free(p);                              // освобождение памяти на которую указывает p
    //getch();
    return 0;
}


















//--------------------------------------------- пример 2 -----------------------------------
// пример работы с двухмерным массивом через указатель на указатель// выполнить сортировку элементов квадратной матрицы
// расположенных ниже главной диагонали
// используя указатель на матрицу

//int main()
//{
//  setlocale(LC_ALL, "Russian");
//  int *mm;      // указатель для динамического выделения памяти под массив
//  int i, i1, j, j1, n;
//  int k;        //
//  system("CLS");
//  printf("введите размерность массива  = ");
//  scanf("%d", &n);
//  if ((mm = (int *)malloc(n*n*sizeof(int))) == NULL)
//  {
//      puts("нет свободной памяти"); return 0;
//  }
//  system("CLS");
//  Vvod(mm, n, n);            // ввод значений в матрицу ms
//  system("CLS");
//  Print(mm, n, n);           // вывод введенной матрицы на экран
//  for (i = 1; i<n; i++)      // выбор строки
//  for (j = 0; j<i; j++)      // перебор элементов до диагонали в i-ой строке
//  { // k=*(mm+i*n+j);        //
//      for (i1 = n - 1; i1 >= i; i1--)        // просмотр массива с конца (с последней стр.)
//      for (j1 = i1 - 1; j1 >= 0; j1--)       // c последнего элемента i1-ой строки
//      if (mm + i*n + j < mm + i1*n + j1 &&   // выбранный адрес (i1,j1)> исходого адреса (i,j)
//          *(mm + i*n + j)>*(mm + i1*n + j1)) // и новое значение < исходного
//      {
//          k = *(mm + i1*n + j1);             // замена значений   (i,j) <-> (i1,j1)
//          *(mm + i1*n + j1) = *(mm + i*n + j);
//          *(mm + i*n + j) = k;
//      }
//  }
//  printf("\nВведенный массив MS : ");
//  Print(mm, n, n);                           // вывод введенной матрицы на экран
//  free(mm);                                  // освобождение памяти на которую указывает  ms
//  return 0;
//}





//  примеры некоторых стандартных функций для работы со строками
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <locale.h>
#include <windows.h>

int str_len(char *);
char *getstr(char *);
int get_str(char *, int);
int atoi(char *s);
void itoa(int , char *);
int str_cmp(char *, char *);
char * strcat(char *, char *, int);

int main()
{
    setlocale(LC_ALL, "Russian");
    char *s1, *s2;
    int n, n1, n2;
    double d;
    do
    {
        system("CLS");
        fflush(stdin);
        printf("введите размерность ПЕРВОЙ строки = ");
    } while (!scanf("%d", &n1) || n1 <= 0);
    if (!(s1 = (char *)calloc(n1, sizeof(char))))
    {
        printf("\nНедостаточно свободной памяти \n");
        return 0;
    }
    do
    {
        system("CLS");
        fflush(stdin);
        printf("введите размерность ВТОРОЙ строки = ");
    } while (!scanf("%d", &n2) || n2 <= 0);
    if (!(s2 = (char *)calloc(n2, sizeof(char))))
    {
        printf("\nНедостаточно свободной памяти \n");
        free(s1);
        return 0;
    }

    printf("Вводите первую строку  ");
    fflush(stdin);
    printf("\n строка %s", getstr(s1)); //ввод-вывод первой строки
    printf("\nДлина первой строки == %d байт", str_len(s1));
    d = atof(s1);
    printf("\nЗначение числа (double) в строке %s == %lf \n", s1, d);
    printf("\nДлина второй строки == %d байт", get_str(s2, n2));
    printf("\nЗначение числа (int) в строке %s == %d ", s2, atoi(s2));
    printf("\nВводите число для перевода в строку  ");
    scanf("%d", &n);
    itoa(n, s2);
    printf("\n строка %s", s2);
    if (str_cmp(s1, s2)>0) printf("\nСтрока 1 > строки 2");
    else if (str_cmp(s1, s2)<0) printf("\nСтрока 1 < строки 2");
    else printf("\nСтрока 1 = строке 2");
    s1 = strcat(s1, s2, 3);                // РАЗОБРАТЬСЯ (здесь возникает проблема !!!!!!!!!!!!!)
    printf("\nстрока (s1+s2) == %s", s1);
    return 0;
}

// ввод строки по адресу переданному в нее
char *getstr(char *st)
{
    if (!st) return nullptr;   // передан указатель на невыделенную под строку память
    int i = 0;
    // в цикле символы заносятся в строку из буфера клавиатуры
    // до тех пор пока не будет нажата клавиша ENTER
    while ((*(st + i++) = (char)getchar()) != '\n');
    st[--i] = '\0';    // добавляем в конец строки символ '\0'
    return st;            // выход из функции
}

// ввод строки и подсчет ее длины
// get_str возвращает значение типа int
// в указатель st копируется указатель на строку для ввода
int get_str(char *st, int k)
{
    int c, i = 0;
    printf("\nВводите вторую строку  ");
    // в цикле символы заносятся в строку из буфера клавиатуры
    // до тех пор пока не будет нажата клавиша ENTER или
    // из буфера не будет получен k-1 символ
    while (--k>0 && (c = getchar()) != EOF && c != '\n')
        st[i++] = c;    // ввод строки до заданного кол-ва символов или пока
                        // не нажата клавиша Enter или Ctrl + Z
    st[i] = '\0';
    return i;    // возврат длины строки
}

// определение длинны строки
int str_len(char *st)
{
    int n = 0;
    for (; st[n] != '\0'; n++);
    return n;
}

// перевод цифровой символьной строки в signed int
int atoi(char *st)
{
    int n, i = 0, znak;
    while (st[i] == ' ') i++;
    if (!st[i]) return 0;              // в строке одни пробелы
    znak = (st[i] == '-') ? -1 : 1;    // запоминаем знак числа
    if (st[i] == '+' || st[i] == '-')  // пропуск знака в строке
        i++;
    for (n = 0; st[i] >= '0' && st[i] <= '9'; i++)  // выбор символа цифры числа из строки
        n = 10 * n + (st[i] - '0');    // формирование числа из цифр строки
    return znak*n;                     // возврат числа со знаком
}

// перевод числа типа signed int в символьную строку
void itoa(int n, char *st)
{
    int i = 0, znak;
    if ((znak = n)<0)            // сохраняем знак
        n *= -1;                 // n - положительное число
    do                // (ВАЖНО!!!) цифры заносим в строку в обратном порядке
    {
        st[i++] = n % 10 + '0';  // выделяется последняя справа цифра числа (как символ)
    } while ((n /= 10)>0);       // удаляется эта цифра из числа путем целочисленного деления на 10

    if (znak<0) st[i++] = '-';   // добавляем в конец строки знак числа
    st[i] = '\0';
    for (n = 0; n < i/2; n++)    // цикл переворота (реверса) полученной строки
    {
        st[n] += st[i - 1 - n];
        st[i - 1 - n] = st[n] - st[i - 1 - n];
        st[n] -= st[i - 1 - n];
    }
}

// функция сравнения двух строк
int str_cmp(char *st1, char *st2)
{
    while (*st1)     // истина пока не достигнут конец ('\0') строки s1
    if (*st1 - *st2) return *st1 - *st2;  // >0 если ASCII-код  *s1 > *s2
                                          // иначе <0
    else                                  // при совпадении символов переход
    {
        st1++;                            // к анализу следующей пары символов
        st2++;
    }
    return *st1 - *st2;  // строки либо полностью совпали либо одна окончилась
}

//  -------------------------
//  for (;*s==*t; s++,t++)
//  if(!*s) return 0;
//  return *s-*t;
//  --------------------------

// функция вставки (добавления) в строку st1 строки st2
// с позиции k
char * strcat(char *st1, char *st2, int k)
{
    char *ss;
    int i, n;
    if (k>str_len(st1)) k = str_len(st1); // проверка куда вставлять строку st2
                                          // перевыделение памяти для новой строки st1
    st1 = (char*)realloc(st1, str_len(st1) + str_len(st2) + 1);
    for (i = str_len(st1); i >= k; i--)   // сдвиг в строке st1 второй части (до позиции k)
        *(st1 + i + str_len(st2)) = *(st1 + i); // вправо
    for (i = 0; i<str_len(st2); i++)      // перезапись второй строки st2 в строку st1
        *(st1 + k + i) = *(st2 + i);      // с позиции k
    return st1;
}