SHARE
TWEET

Untitled

oshuej Jun 1st, 2020 832 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. const unsigned int MAX_LENGTH = 1 * 1024 * 1024;  // Не выделять больше мегабайта памяти
  6. const unsigned int CHUNK_SIZE = 1024;             // Выделять блоками по килобайту
  7.  
  8. char* readString(const char *delimitersArray);
  9. char* readSpecialString();
  10.  
  11. int main() {
  12.     int delimitersLength = 0, c = EOF;
  13.     char *specialString = NULL, *inputStr = NULL;
  14.  
  15.     printf("Введите длину массива разделителей: \n");
  16.     scanf("%d", &delimitersLength);
  17.  
  18.     char delimitersArray[delimitersLength];
  19.  
  20.     printf("Введите символы-разделители: \n");
  21.     // начало считывания символов-разделителей
  22.     for (int i = 0; (c = getchar()) && i < delimitersLength; i++) {
  23.         if (c != '\n') {
  24.             delimitersArray[i] = c;
  25.         } else {
  26.             i--;
  27.         }
  28.     }
  29.     // конец считывания символов-разделителей
  30.  
  31.     printf("Введите специальное слово\n");
  32.     specialString = readSpecialString();                        // считываем специальное слово
  33.  
  34.     printf("Введите строку\n");
  35.     inputStr = readString(delimitersArray);                    // считываем строку
  36.  
  37.     int delimitersIndexInString[delimitersLength],
  38.         counterFoundedDelimiters = 0,
  39.         firstDelimiterIndex = (int) strlen(inputStr);
  40.     for (int i = 0; i < delimitersLength; i++) {
  41.         char *ach = strchr(inputStr, delimitersArray[i]);
  42.         if (ach == NULL) {
  43.             printf("Не все разделители имеются в тексте\n");
  44.             break;
  45.         } else {
  46.             counterFoundedDelimiters++;
  47.             delimitersIndexInString[i] = ach - inputStr;            // записываем индекс первого вхождения разделителя
  48.             if (delimitersIndexInString[i] <= firstDelimiterIndex) {
  49.                 firstDelimiterIndex = delimitersIndexInString[i];
  50.             }
  51.         }
  52.     }
  53.  
  54.     if (counterFoundedDelimiters == delimitersLength) {
  55.         char *firstPart = malloc(CHUNK_SIZE), *secondPart = malloc(CHUNK_SIZE);
  56.  
  57.         strncpy(firstPart, inputStr, firstDelimiterIndex + 1);               // копируем первое слово
  58.         strncpy(secondPart,
  59.                 inputStr + firstDelimiterIndex + 1,
  60.                 strlen(inputStr) - (firstDelimiterIndex + 1));              // копируем остальную часть строки
  61.  
  62.         char *finalString = malloc(strlen(inputStr) + strlen(specialString) + 1);      // выделяем память размером исходная_строка + размер специального слова + 1 (под разделитель)
  63.         strcat(finalString, firstPart);                                                     // добавляем в финальную строку первое слово
  64.         char randomDelimiter = delimitersArray[random() % delimitersLength];                // берем случайный разделитель
  65.         specialString = realloc(specialString, strlen(specialString) + 1);             // на всякий случай выделяем память под разделитель
  66.         specialString[strlen(specialString)] = randomDelimiter;                             // добавляем случайный разделитель к специальному слову
  67.         strcat(finalString, specialString);                                                 // добавляем в финальную строку специальный символ с разделителем
  68.         strcat(finalString, secondPart);                                                    // добавляем в финальную строку остальную часть
  69.         printf("Итоговая строка: \"%s\"", finalString);
  70.  
  71.         free(firstPart);
  72.         firstPart = NULL;
  73.         free(secondPart);
  74.         secondPart = NULL;
  75.         free(finalString);
  76.         finalString = NULL;
  77.     }
  78.  
  79.     free(inputStr);
  80.     inputStr = NULL;
  81.     free(specialString);
  82.     specialString = NULL;
  83.  
  84.     return 0;
  85. }
  86.  
  87. char* readString(const char *delimitersArray) {
  88.     unsigned int inputStr_len = CHUNK_SIZE;
  89.     char *pString = malloc(CHUNK_SIZE), vowels[10] = {'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'};
  90.     int charCounter = 0;                    // счетчик букв, входящих в одно слово (до разделителя)
  91.     int numberOfVowels = 0;
  92.     int isConditionFulfilled = 0;
  93.  
  94.     int c;
  95.     unsigned int i;
  96.     for (i = 0; (c = getchar()); i++) {
  97.         if (c != '\n') {                        // игнорируем начало строки
  98.             pString[i] = c;
  99.             charCounter++;
  100.             for (int g = 0; g < strlen(vowels); g++) {
  101.                 if (c == vowels[g]) {
  102.                     numberOfVowels++;
  103.                 }
  104.             }
  105.             for (int j = 0; j < strlen(delimitersArray); j++) {
  106.                 if (c == delimitersArray[j]) {
  107.                     charCounter--;
  108.                     if (charCounter == numberOfVowels) {
  109.                         isConditionFulfilled = 1;
  110.                         break;
  111.                     } else {
  112.                         numberOfVowels = 0;
  113.                         charCounter = 0;
  114.                     }
  115.                 }
  116.             }
  117.         } else {                                // если на вход поступил символ '\n', то необходимо уменьшить i, чтобы не нарушать порядок
  118.             i--;
  119.             if (isConditionFulfilled == 1) {
  120.                 i++;
  121.                 break;
  122.             }
  123.         }
  124.  
  125.         if (i == MAX_LENGTH) {
  126.             free(pString);
  127.         }
  128.  
  129.         if (i == inputStr_len) {                       // Блок заполнен
  130.             inputStr_len = i + CHUNK_SIZE;
  131.             pString = realloc(pString, inputStr_len);  // Расширяем блок на ещё один килобайт
  132.         }
  133.     }
  134.     pString[i] = '\0';                            // Признак конца строки
  135.     return pString;
  136. }
  137.  
  138. char* readSpecialString() {
  139.     unsigned int inputStr_len = CHUNK_SIZE;
  140.     char *pString = malloc(CHUNK_SIZE);
  141.  
  142.     int c;
  143.     unsigned int i;
  144.     for (i = 0; (c = getchar()) != '\n'; i++) {
  145.         pString[i] = c;
  146.  
  147.         if (i == MAX_LENGTH) {
  148.             free(pString);
  149.         }
  150.  
  151.         if (i == inputStr_len) {                       // Блок заполнен
  152.             inputStr_len = i + CHUNK_SIZE;
  153.             pString = realloc(pString, inputStr_len);  // Расширяем блок на ещё один килобайт
  154.         }
  155.     }
  156.     pString[i] = '\0';                            // Признак конца строки
  157.     return pString;
  158. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top