fork download
copy 
  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5.  
  6. #define COUNT_COMMANDS 1000000
  7. #define COUNT_STRING 100000
  8. #define SRTING_LEN 2500
  9.  
  10. typedef enum {
  11.     clear = 1, number, syntax, parameter
  12. }errors_type;
  13.  
  14.  
  15. typedef struct {
  16.     char pattern[SRTING_LEN];
  17.     char replacement[SRTING_LEN];
  18.     int flag;
  19. } SUBSTITUTION;
  20.  
  21. typedef struct {
  22.     char pattern[SRTING_LEN];
  23. } DELETION;
  24.  
  25. typedef struct {
  26.     char source[SRTING_LEN];
  27.     char dest[SRTING_LEN];
  28. } TRANSLITERATION;
  29.  
  30. typedef struct {
  31.     char pattern[SRTING_LEN];
  32.     char text[SRTING_LEN];
  33. } INSERTION;
  34.  
  35.  
  36. typedef struct {
  37.     char line[SRTING_LEN];
  38.     int start; // Строки
  39.     int end;
  40.     char command[2];
  41.     errors_type type;
  42.  
  43.     union {
  44.         SUBSTITUTION s;
  45.         DELETION d;
  46.         TRANSLITERATION y;
  47.         INSERTION i;
  48.     } data;
  49.  
  50. }COMMAND;
  51.  
  52. typedef struct {
  53.     char line[SRTING_LEN];
  54. }ARRAY;
  55.  
  56. void print_error(char string[], errors_type type) {
  57.     switch (type) {
  58.     case number:
  59.         printf("Error in command <%s>: Invalid line number.", string);
  60.         break;
  61.     case syntax:
  62.         printf("Error in command <%s>: Command syntax error.", string);
  63.         break;
  64.     case parameter:
  65.         printf("Error in command <%s>: Parameter error.", string);
  66.         break;
  67.     }
  68. }
  69.  
  70. int find_index(char string1[], char string2[]) { // где ищем что ищем
  71.  
  72.     char* result = strstr(string1, string2);
  73.  
  74.     if (result == NULL) {
  75.         return -1;
  76.     }
  77.  
  78.     return result - string1;
  79. }
  80.  
  81. void substitution(char line[], char pattern[], char replacement[], int flag) {
  82.  
  83.     if (flag == 0) {
  84.         int position = find_index(line, pattern);
  85.         if (position != -1) {
  86.  
  87.             char new_line[SRTING_LEN] = "";
  88.             int index_line = 0, index_new = 0;
  89.  
  90.             for (; index_line < position; index_line++, index_new++) // До нахождения подстроки
  91.                 new_line[index_new] = line[index_line];
  92.  
  93.             for (int i = 0; replacement[i] != '\0'; i++, index_new++) // Замена
  94.                 new_line[index_new] = replacement[i];
  95.  
  96.             for (index_line += strlen(pattern); line[index_line] != '\0'; index_line++, index_new++) // После замены
  97.                 new_line[index_new] = line[index_line];
  98.  
  99.             new_line[index_new] = '\0'; // Завершение строки - null termination
  100.  
  101.             strcpy(line, new_line);
  102.         }
  103.     }
  104.     else {
  105.         while (1) {
  106.             int position = find_index(line, pattern);
  107.             if (position != -1) {
  108.  
  109.                 char new_line[SRTING_LEN] = "";
  110.                 int index_line = 0, index_new = 0;
  111.  
  112.                 for (; index_line < position; index_line++, index_new++) // До нахождения подстроки
  113.                     new_line[index_new] = line[index_line];
  114.  
  115.                 for (int i = 0; replacement[i] != '\0'; i++, index_new++) // Замена
  116.                     new_line[index_new] = replacement[i];
  117.  
  118.                 for (index_line += strlen(pattern); line[index_line] != '\0'; index_line++, index_new++) // После замены
  119.                     new_line[index_new] = line[index_line];
  120.  
  121.                 new_line[index_new] = '\0'; // Завершение строки - null termination
  122.  
  123.                 strcpy(line, new_line);
  124.             }
  125.             else
  126.                 break;
  127.         }
  128.     }
  129. }
  130.  
  131. void deletion(char line[], char pattern[]) {
  132.     int position = find_index(line, pattern);
  133.     if (position != -1)
  134.         strcpy(line, "");
  135. }
  136.  
  137. void transliteration(char line[], char source[], char dest[]) {
  138.     for (int i = 0; line[i] != '\0'; i++) {
  139.         int position = -1;
  140.         for (int j = 0; source[j] != '\0'; j++) {
  141.             if (line[i] == source[j]) {
  142.                 position = j;
  143.                 break;
  144.             }
  145.         }
  146.         if (position != -1) {
  147.             line[i] = dest[position];
  148.         }
  149.     }
  150. }
  151.  
  152. void insertion(char line[], char pattern[], char text[]) {
  153.     int position = find_index(line, pattern);
  154.     if (position != -1) {
  155.         char new_line[SRTING_LEN] = "";
  156.         int index_line = 0, index_new = 0;
  157.  
  158.         for (; index_line < position; index_line++, index_new++)
  159.             new_line[index_new] = line[index_line];
  160.  
  161.         for (int i = 0; text[i] != '\0'; i++, index_new++)
  162.             new_line[index_new] = text[i];
  163.  
  164.         for (int i = 0; line[index_line] != '\0'; index_line++, i++, index_new++) {
  165.             new_line[index_new] = line[index_line];
  166.         }
  167.  
  168.         new_line[index_new] = '\0'; // Завершение строки - null termination
  169.         strcpy(line, new_line);
  170.     }
  171. }
  172.  
  173. int main(int argc, char* argv[]) {
  174.     int M, // Количество команд (от 1 до 1.000.000)
  175.         N; // Количество строк входного текста (от 1 до 100.000)
  176.  
  177.     char num_M[10];
  178.     fgets(num_M, sizeof(num_M), stdin);
  179.     num_M[strcspn(num_M, "\n")] = 0;
  180.     M = atoi(num_M);
  181.  
  182.     COMMAND* commands = malloc(M * sizeof(COMMAND));
  183.  
  184.     for (int i = 0; i < M; i++) { // Читаем строки
  185.  
  186.         char buffer[SRTING_LEN];
  187.         fgets(buffer, sizeof(buffer), stdin);
  188.         buffer[strcspn(buffer, "\n")] = 0;
  189.  
  190.         strcpy(commands[i].line, buffer); // Массив с текстом
  191.  
  192.         commands[i].type = clear; // По умолчанию все команды считаются корректными
  193.  
  194.         int j = 0;
  195.  
  196.         // Обозначение промежутка
  197.         if (buffer[j] == 's' || buffer[j] == 'd' || buffer[j] == 'y' || buffer[j] == 'i') { // Границ нет
  198.             commands[i].start = 1;
  199.             commands[i].end = COUNT_STRING;
  200.         }
  201.         else if (buffer[j] >= '1' && buffer[j] <= '9') { // Границы есть и они корректны
  202.  
  203.             char* line_start = malloc(COUNT_STRING); // Первое значение
  204.             int num = 0;
  205.             for (; buffer[j] != ',' && buffer[j] != ' ' && buffer[j] != '\0'; num++, j++) {
  206.                 if (buffer[j] >= '0' && buffer[j] <= '9')
  207.                     line_start[num] = buffer[j];
  208.                 else {
  209.                     commands[i].type = number; // Ошибка в промежутках
  210.                     break;
  211.                 }
  212.             }
  213.             line_start[num] = '\0'; // Завершение строки - null termination
  214.  
  215.             commands[i].start = atoi(line_start);
  216.             free(line_start);
  217.  
  218.  
  219.             if (buffer[j] == ',') { // Второе значение (если есть)
  220.                 j += 1;
  221.  
  222.                 if (buffer[j] >= '1' && buffer[j] <= '9') {
  223.  
  224.                     char* line_end = malloc(COUNT_STRING);
  225.                     num = 0;
  226.                     for (; buffer[j] != ' ' && buffer[j] != '\0'; num++, j++) {
  227.                         if (buffer[j] >= '0' && buffer[j] <= '9')
  228.                             line_end[num] = buffer[j];
  229.                         else {
  230.                             commands[i].type = syntax; // Ошибка в промежутках
  231.                             break;
  232.                         }
  233.                     }
  234.                     line_end[num] = '\0'; // Завершение строки - null termination
  235.  
  236.                     commands[i].end = atoi(line_end);
  237.                     free(line_end);
  238.                 }
  239.                 else
  240.                     commands[i].type = number; // Ошибка в промежутке
  241.  
  242.             }
  243.             else
  244.                 commands[i].end = commands[i].start;
  245.  
  246.             // Проверка на корректность найдённого промежутка
  247.             if (commands[i].start > commands[i].end)
  248.                 commands[i].type = number; // Ошибка в промежутках
  249.  
  250.             j += 1; // Указатель не на пробеле!
  251.         }
  252.         else {
  253.             int flag = 0;
  254.             for (int f = j; buffer[f]; f++) {
  255.                 if (buffer[f] == ' ' || buffer[f] == ',')
  256.                     flag = 1;
  257.             }
  258.             if (flag)
  259.                 commands[i].type = number; // Ошибка в промежутках (комманда начинается не с sdyi и не с цифр)
  260.             else
  261.                 commands[i].type = syntax;
  262.         }
  263.  
  264.         // Проверка
  265.         if (commands[i].type != clear) {
  266.             print_error(buffer, commands[i].type);
  267.             free(commands);
  268.             return EXIT_SUCCESS;;
  269.         }
  270.  
  271.         // Тип комманды
  272.         switch (buffer[j]) {
  273.         case 's':
  274.             commands[i].command[0] = 's';
  275.             break;
  276.         case 'd':
  277.             commands[i].command[0] = 'd';
  278.             break;
  279.         case 'y':
  280.             commands[i].command[0] = 'y';
  281.             break;
  282.         case 'i':
  283.             commands[i].command[0] = 'i';
  284.             break;
  285.         }
  286.  
  287.         j += 1; // Слеш
  288.  
  289.         switch (commands[i].command[0]) {
  290.         case 's':
  291.             if (buffer[j] != '/') { // Проверка
  292.                 commands[i].type = syntax;
  293.                 break;
  294.             }
  295.             else {
  296.                 j += 1;
  297.  
  298.                 // pattern
  299.                 char pattern[SRTING_LEN] = "";
  300.                 int letter = 0;
  301.                 for (; buffer[j] != '/' && buffer[j] != '\0'; letter++, j++)
  302.                     pattern[letter] = buffer[j];
  303.                 pattern[letter] = '\0'; // Завершение строки - null termination
  304.                 strcpy(commands[i].data.s.pattern, pattern);
  305.  
  306.                 if (buffer[j] == '\0') { // Проверка
  307.                     commands[i].type = syntax;
  308.                     break;
  309.                 }
  310.                 else if (commands[i].data.s.pattern[0] == '\0') { // Проверка
  311.                     commands[i].type = parameter;
  312.                     break;
  313.                 }
  314.  
  315.                 j += 1; // не слеш
  316.  
  317.                 // replacement
  318.                 char replacement[SRTING_LEN] = "";
  319.                 letter = 0;
  320.                 for (; buffer[j] != '/' && buffer[j] != '\0'; letter++, j++)
  321.                     replacement[letter] = buffer[j];
  322.                 replacement[letter] = '\0';
  323.                 strcpy(commands[i].data.s.replacement, replacement);
  324.  
  325.                 if (buffer[j] == '\0') { // Проверка
  326.                     commands[i].type = syntax;
  327.                     break;
  328.                 }
  329.                 else if (commands[i].data.s.replacement[0] == '\0') { // Проверка
  330.                     commands[i].type = parameter;
  331.                     break;
  332.                 }
  333.  
  334.                 j += 1; // не слеш
  335.  
  336.                 if (buffer[j] != '\0' && buffer[j] == 'g' && buffer[j + 1] == '\0') // flag
  337.                     commands[i].data.s.flag = 1;
  338.                 else if (buffer[j] == '\0') // Проверка
  339.                     commands[i].data.s.flag = 0;
  340.                 else
  341.                     commands[i].type = syntax;
  342.  
  343.                 break;
  344.             }
  345.         case 'd':
  346.             if (buffer[j] != '/') { // Проверка
  347.                 commands[i].type = syntax;
  348.                 break;
  349.             }
  350.             else {
  351.                 j += 1;
  352.  
  353.                 // pattern
  354.                 char pattern[SRTING_LEN] = "";
  355.                 int letter = 0;
  356.                 for (; buffer[j] != '/' && buffer[j] != '\0'; letter++, j++)
  357.                     pattern[letter] = buffer[j];
  358.                 pattern[letter] = '\0'; // Завершение строки - null termination
  359.                 strcpy(commands[i].data.d.pattern, pattern);
  360.  
  361.                 if (buffer[j] == '\0') // Проверка
  362.                     commands[i].type = syntax;
  363.                 else if (buffer[j + 1] != '\0')
  364.                     commands[i].type = syntax;
  365.                 else if (commands[i].data.d.pattern[0] == '\0')
  366.                     commands[i].type = parameter;
  367.  
  368.  
  369.                 break;
  370.             }
  371.         case 'y':
  372.             if (buffer[j] != '/') { // Проверка
  373.                 commands[i].type = syntax;
  374.                 break;
  375.             }
  376.             else {
  377.                 j += 1; // не слеш
  378.  
  379.                 // source
  380.                 char source[SRTING_LEN] = "";
  381.                 int letter = 0;
  382.                 for (; buffer[j] != '/' && buffer[j] != '\0'; letter++, j++)
  383.                     source[letter] = buffer[j];
  384.                 source[letter] = '\0'; // Завершение строки - null termination
  385.                 strcpy(commands[i].data.y.source, source);
  386.  
  387.                 if (buffer[j] == '\0') { // Проверка
  388.                     commands[i].type = syntax;
  389.                     break;
  390.                 }
  391.                 else if (commands[i].data.y.source[0] == '\0') { // Проверка
  392.                     commands[i].type = parameter;
  393.                     break;
  394.                 }
  395.  
  396.                 j += 1; // не слеш
  397.  
  398.                 // dest
  399.                 char dest[SRTING_LEN] = "";
  400.                 letter = 0;
  401.                 for (; buffer[j] != '/' && buffer[j] != '\0'; letter++, j++)
  402.                     dest[letter] = buffer[j];
  403.                 dest[letter] = '\0'; // Завершение строки - null termination
  404.                 strcpy(commands[i].data.y.dest, dest);
  405.  
  406.                 if (buffer[j] == '\0') { // Проверка
  407.                     commands[i].type = syntax;
  408.                     break;
  409.                 }
  410.                 else if (buffer[j + 1] != '\0')
  411.                     commands[i].type = syntax;
  412.                 else if (commands[i].data.y.dest[0] == '\0') { // Проверка
  413.                     commands[i].type = parameter;
  414.                     break;
  415.                 }
  416.  
  417.  
  418.                 if (strlen(commands[i].data.y.dest) != strlen(commands[i].data.y.source))
  419.                     commands[i].type = parameter;
  420.  
  421.                 break;
  422.             }
  423.         case 'i':
  424.             if (buffer[j] != '/') { // Проверка
  425.                 commands[i].type = syntax;
  426.                 break;
  427.             }
  428.             else {
  429.                 j += 1; // не слеш
  430.  
  431.                 // pattern
  432.                 char pattern[SRTING_LEN] = "";
  433.                 int letter = 0;
  434.                 for (; buffer[j] != '/' && buffer[j] != '\0'; letter++, j++)
  435.                     pattern[letter] = buffer[j];
  436.                 pattern[letter] = '\0'; // Завершение строки - null termination
  437.                 strcpy(commands[i].data.i.pattern, pattern);
  438.  
  439.                 if (buffer[j] == '\0') { // Проверка
  440.                     commands[i].type = syntax;
  441.                     break;
  442.                 }
  443.                 else if (commands[i].data.i.pattern[0] == '\0') { // Проверка
  444.                     commands[i].type = parameter;
  445.                     break;
  446.                 }
  447.  
  448.                 j += 1; // не слеш
  449.  
  450.                 // text
  451.                 char text[SRTING_LEN] = "";
  452.                 letter = 0;
  453.                 for (; buffer[j] != '/' && buffer[j] != '\0'; letter++, j++)
  454.                     text[letter] = buffer[j];
  455.                 text[letter] = '\0'; // Завершение строки - null termination
  456.                 strcpy(commands[i].data.i.text, text);
  457.  
  458.                 if (buffer[j] == '\0') // Проверка
  459.                     commands[i].type = syntax;
  460.                 else if (buffer[j + 1] != '\0')
  461.                     commands[i].type = syntax;
  462.                 else if (commands[i].data.i.text[0] == '\0' && buffer[j + 1] == '\0') // Проверка
  463.                     commands[i].type = parameter;
  464.  
  465.                 break;
  466.             }
  467.         }
  468.  
  469.         if (commands[i].type != clear) {
  470.             print_error(buffer, commands[i].type);
  471.             free(commands);
  472.             return EXIT_SUCCESS;;
  473.         }
  474.  
  475.         // Конец команд
  476.     }
  477.  
  478.     char num_N[10];
  479.     fgets(num_N, sizeof(num_N), stdin);
  480.     num_N[strcspn(num_N, "\n")] = 0;
  481.     N = atoi(num_N);
  482.  
  483.     ARRAY* strings = malloc((N) * sizeof(ARRAY));
  484.  
  485.     for (int i = 0; i < N; i++) {
  486.         char buffer[SRTING_LEN];
  487.  
  488.         fgets(buffer, sizeof(buffer), stdin);
  489.         buffer[strcspn(buffer, "\n")] = 0;
  490.  
  491.         strcpy(strings[i].line, buffer); // Массив с текстом
  492.     }
  493.  
  494.     for (int i = 0; i < M; i++) { // Перебор всех команд
  495.         if (commands[i].end == COUNT_STRING)
  496.             commands[i].end = N;
  497.         else if (commands[i].end > N) {
  498.             commands[i].type = number; // Ошибка в промежутках
  499.             print_error(commands[i].line, commands[i].type);
  500.             free(commands);
  501.             free(strings);
  502.             return EXIT_SUCCESS;;
  503.         }
  504.  
  505.         for (int index_line = commands[i].start - 1; index_line < commands[i].end; index_line++) {
  506.  
  507.             switch (commands[i].command[0]) {
  508.             case 's':
  509.                 substitution(strings[index_line].line, commands[i].data.s.pattern, commands[i].data.s.replacement, commands[i].data.s.flag);
  510.                 break;
  511.             case 'd':
  512.                 deletion(strings[index_line].line, commands[i].data.d.pattern);
  513.                 break;
  514.             case 'y':
  515.                 transliteration(strings[index_line].line, commands[i].data.y.source, commands[i].data.y.dest);
  516.                 break;
  517.             case 'i':
  518.                 insertion(strings[index_line].line, commands[i].data.i.pattern, commands[i].data.i.text);
  519.                 break;
  520.             }
  521.         }
  522.     }
  523.  
  524.     for (int i = 0; i < N - 1; i++) {
  525.         if (strings[i].line[0] != '\0')
  526.             printf("%s\n", strings[i].line);
  527.     }
  528.     printf("%s", strings[N - 1].line);
  529.  
  530.  
  531.     free(commands);
  532.     free(strings);
  533.     return EXIT_SUCCESS;;
  534. }
Success #stdin #stdout 0.01s 5284KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/CN9fHL
language:
C (gcc 8.3)
created:
14 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!