Ledger Nano X - The secure hardware wallet
SHARE
TWEET

Denis_KR

oshuej May 20th, 2020 935 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.  
  93.     int c;
  94.     unsigned int i;
  95.     for (i = 0; (c = getchar()); i++) {
  96.         if (c != '\n') {                        // игнорируем начало строки
  97.             pString[i] = c;
  98.             charCounter++;
  99.             for (int g = 0; g < strlen(vowels); g++) {
  100.                 if (c == vowels[g]) {
  101.                     numberOfVowels++;
  102.                 }
  103.             }
  104.             for (int j = 0; j < strlen(delimitersArray); j++) {
  105.                 if (c == delimitersArray[j]) {
  106.                     charCounter--;
  107.                     if (charCounter == numberOfVowels) {
  108.                         pString[i + 1] = '\0';
  109.                         return pString;
  110.                     } else {
  111.                         numberOfVowels = 0;
  112.                         charCounter = 0;
  113.                     }
  114.                 }
  115.             }
  116.         } else {                                // если на вход поступил символ '\n', то необходимо уменьшить i, чтобы не нарушать порядок
  117.             i--;
  118.         }
  119.  
  120.         if (i == MAX_LENGTH) {
  121.             free(pString);
  122.         }
  123.  
  124.         if (i == inputStr_len) {                       // Блок заполнен
  125.             inputStr_len = i + CHUNK_SIZE;
  126.             pString = realloc(pString, inputStr_len);  // Расширяем блок на ещё один килобайт
  127.         }
  128.     }
  129.     pString[i] = '\0';                            // Признак конца строки
  130.     return pString;
  131. }
  132.  
  133. char* readSpecialString() {
  134.     unsigned int inputStr_len = CHUNK_SIZE;
  135.     char *pString = malloc(CHUNK_SIZE);
  136.  
  137.     int c;
  138.     unsigned int i;
  139.     for (i = 0; (c = getchar()) != '\n'; i++) {
  140.         pString[i] = c;
  141.  
  142.         if (i == MAX_LENGTH) {
  143.             free(pString);
  144.         }
  145.  
  146.         if (i == inputStr_len) {                       // Блок заполнен
  147.             inputStr_len = i + CHUNK_SIZE;
  148.             pString = realloc(pString, inputStr_len);  // Расширяем блок на ещё один килобайт
  149.         }
  150.     }
  151.     pString[i] = '\0';                            // Признак конца строки
  152.     return pString;
  153. }
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