fork download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <math.h>
  5. #include <ctype.h>
  6. #define MAX_LENGTH 160
  7.  
  8. void read_input(char *input, size_t size) {
  9.     if (fgets(input, size, stdin) == NULL) {
  10.         fprintf(stderr, "Error reading input.\n");
  11.         exit(1); 
  12.     }
  13.     input[strcspn(input, "\n")] = '\0';  
  14. }
  15.  
  16. void invertSymmetry(char *result) {
  17.     while (*result) {
  18.         *result = (*result == '1') ? 'i' : (*result == 'i' ? '1' : *result);
  19.         ++result;
  20.     }
  21. }
  22.  
  23. char* addition(char matrix[][MAX_LENGTH], int rows) {
  24.     static char result[MAX_LENGTH];  
  25.     memset(result, '0', MAX_LENGTH); 
  26.  
  27.     printf("Высота: %d\n", rows);
  28.     int columns = strlen(matrix[0]);
  29.     printf("Длина: %d\n", columns);
  30.  
  31.     printf("\nПолученная матрица:\n");
  32.     for (int i = 0; i < rows; i++) {
  33.         printf("%s\n", matrix[i]);
  34.     }
  35.  
  36.     int x, z, r, y = 0, g;
  37.     char current_result[MAX_LENGTH];  
  38.     int current_len = 0;  
  39.  
  40.     int j = columns - 1;  
  41.     while (j >= 0 || y != 0) {
  42.         x = 0; g = 0; r = 0;  
  43.  
  44.         int skip = 0;
  45.  
  46.         for (int i = 0; i < rows; i++) {
  47.             char n = (j >= 0) ? matrix[i][j] : '0';    
  48.             if (n == '1') {
  49.                 x += 1;
  50.             } else if (n == 'i') {
  51.                 x -= 1;
  52.             } else if (n == ',' || n == '.') {
  53.                 if (current_len > 0) {
  54.                     memmove(current_result + 1, current_result, current_len);
  55.                 }
  56.                 current_result[0] = ',';  
  57.                 current_len++;
  58.                 skip = 1;
  59.                 break;  
  60.             }
  61.         }
  62.  
  63.         if (skip) {
  64.             j--;  
  65.             continue;
  66.         }
  67.         x += y;  
  68.         r = (x < 0) ? -1 : 1;
  69.         z = abs(x) % 3;  
  70.         if (z == 2) {
  71.             z = -1;
  72.             g = 1;
  73.         }
  74.         z *= r;
  75.         g *= r;
  76.  
  77.         if (current_len + 1 < MAX_LENGTH) {
  78.             memmove(current_result + 1, current_result, current_len);
  79.             if (z == -1) {
  80.                 current_result[0] = 'i';
  81.             } else if (z == 1) {
  82.                 current_result[0] = '1';
  83.             } else if (z == 0) {
  84.                 current_result[0] = '0';
  85.             }
  86.             current_len++;
  87.         }
  88.  
  89.         y = x / 3;
  90.   //      y = y * r;
  91.         y += g;
  92.  
  93.         j--;
  94.     }
  95.  
  96.     result[0] = '\0';  
  97.     strncpy(result, current_result, current_len);
  98.     result[current_len] = '\0';
  99.  
  100.     return result;
  101. }
  102.  
  103. char* binary_and(char matrix[][MAX_LENGTH], int rows) {
  104.     static char final_result[MAX_LENGTH]; // Статический массив для хранения результата
  105.     int result_index = 0;  // Индекс для записи в final_result
  106.  
  107.     int columns = strlen(matrix[0]);  // Количество столбцов, предполагаем MAX_LENGTH
  108.     printf("\nColumns: %d\n", columns);
  109.     printf("Rows: %d\n", rows); 
  110.  
  111.     printf("\nПолученная матрица:\n");
  112.     for (int i = 0; i < rows; i++) {
  113.         printf("%s\n", matrix[i]);
  114.     }
  115.  
  116.     // Проходим по всем столбцам
  117.     for (int j = 0; j < columns; j++) {
  118.         // Проверяем, есть ли в столбцах символы 'i', '0', '1' или ',' и обрабатываем их
  119.         if (matrix[0][j] == 'i' || matrix[1][j] == 'i') {
  120.             final_result[result_index++] = 'i';
  121.         } else if (matrix[0][j] == '0' || matrix[1][j] == '0') {
  122.             final_result[result_index++] = '0';
  123.         } else if (matrix[0][j] == '1' && matrix[1][j] == '1') {
  124.             final_result[result_index++] = '1';
  125.         } else if (matrix[0][j] == ',' || matrix[0][j] == '.' || matrix[1][j] == ',' || matrix[1][j] == '.') {
  126.             final_result[result_index++] = ',';
  127.         } else {
  128.             final_result[result_index++] = '0';
  129.         }
  130.     }
  131.  
  132.     final_result[result_index] = '\0';  // Завершаем строку
  133.     return final_result;  // Возвращаем результат
  134. }
  135.  
  136. char* binary_or(char matrix[][MAX_LENGTH], int rows) {
  137.     static char final_result[MAX_LENGTH]; // Статический массив для хранения результата
  138.     int result_index = 0;  // Индекс для записи в final_result
  139.  
  140.     int columns = strlen(matrix[0]);  // Количество столбцов, предполагаем MAX_LENGTH
  141.     printf("\nColumns: %d\n", columns);
  142.     printf("Rows: %d\n", rows);
  143.  
  144.     printf("\nПолученная матрица:\n");
  145.     for (int i = 0; i < rows; i++) {
  146.         printf("%s\n", matrix[i]);
  147.     }
  148.     // Преобразование значений в финальную строку по логике OR
  149.     for (int j = 0; j < columns; j++) {
  150.         if (matrix[0][j] == '1' || matrix[1][j] == '1') {
  151.             final_result[result_index++] = '1';  
  152.         } else if (matrix[0][j] == '0' || matrix[1][j] == '0') {
  153.             final_result[result_index++] = '0'; 
  154.         } else if (matrix[0][j] == 'i' && matrix[1][j] == 'i') {
  155.             final_result[result_index++] = 'i';  
  156.         } else if (matrix[0][j] == ',' || matrix[0][j] == '.' || matrix[1][j] == ',' || matrix[1][j] == '.') {
  157.             final_result[result_index++] = ',';  
  158.         } else {
  159.             final_result[result_index++] = '0';
  160.         }
  161.     }
  162.  
  163.     final_result[result_index] = '\0';  // Завершаем строку
  164.     return final_result;
  165. }
  166.  
  167.  
  168. void rationing(char input1[], char input2[], int choice) {
  169.     int n1 = strlen(input1);
  170.     int n2 = strlen(input2);
  171.  
  172.     char* comma1_pos = strpbrk(input1, ",.");
  173.     char* comma2_pos = strpbrk(input2, ",.");
  174.  
  175.     if (comma1_pos) {
  176.         n1 = comma1_pos - input1;  
  177.     }
  178.  
  179.     if (comma2_pos) {
  180.         n2 = comma2_pos - input2;  
  181.     }
  182.  
  183.     int a1 = strlen(input1);
  184.     int a2 = strlen(input2);
  185.  
  186.     if (n1 < n2) {
  187.         a1 += (n2 - n1);
  188.     }
  189.  
  190.     if (n2 < n1) {
  191.         a2 += (n1 - n2);
  192.     }
  193.  
  194.     int max_a = (a1 > a2) ? a1 : a2;
  195.     int n = 2;  
  196.  
  197.     char matrix[2][MAX_LENGTH];
  198.     memset(matrix, '0', sizeof(matrix));  
  199.     matrix[0][max_a] = '\0';  
  200.     matrix[1][max_a] = '\0';
  201.  
  202.     int start_idx1 = (n1 < n2) ? n2 - n1 : 0;
  203.     memcpy(matrix[0] + start_idx1, input1, strlen(input1)); 
  204.  
  205.     int start_idx2 = (n2 < n1) ? n1 - n2 : 0;
  206.     memcpy(matrix[1] + start_idx2, input2, strlen(input2));
  207.  
  208.  
  209.     if (choice == 6) {
  210.         char* result = binary_and(matrix, n);
  211.         printf("\nРезультат: %s\n", result);
  212.     }
  213.     else if (choice == 7) {
  214.         char* result = binary_or(matrix, n);
  215.         printf("\nРезультат: %s\n", result);
  216.     }
  217.     else {
  218.         char* result = addition(matrix, n);
  219.         printf("\nРезультат: %s\n", result);
  220.     }
  221. }
  222.  
  223.  void removeChar(char* str) {
  224.         char* pos = strpbrk(str, ",.");
  225.         if (pos) {
  226.             memmove(pos, pos + 1, strlen(pos));
  227.         }
  228.     }
  229.  
  230. void multiplication(char input1[], char input2[]) {
  231.     char temp[MAX_LENGTH];
  232.     char* comma1_pos = strpbrk(input1, ",.");
  233.     char* comma2_pos = strpbrk(input2, ",.");
  234.  
  235.     int len1 = strlen(input1);
  236.     int len2 = strlen(input2);
  237.  
  238.     int index1 = comma1_pos ? (int)(comma1_pos - input1) + 1 : len1;
  239.     int index2 = comma2_pos ? (int)(comma2_pos - input2) + 1 : len2;
  240.  
  241.     int n = (len1 - index1) + (len2 - index2);
  242.  
  243.  
  244.     removeChar(input1);
  245.     removeChar(input2);
  246.  
  247.     len1 = strlen(input1);
  248.     len2 = strlen(input2);
  249.  
  250.     if (len2 > len1) {
  251.         strcpy(temp, input2);
  252.         strcpy(input2, input1);
  253.         strcpy(input1, temp);
  254.         int templen = len2;
  255.         len2 = len1;
  256.         len1 = templen;
  257.     } else {
  258.         strcpy(temp, input1);
  259.     }
  260.     invertSymmetry(temp);
  261.  
  262.     char matrix[len2][MAX_LENGTH];
  263.     memset(matrix, '0', sizeof(matrix)); 
  264.  
  265.     int len=len1-len2;
  266. int s = len2 - 1; 
  267. for (int i = 0; i < len2; i++) {
  268.     if (input2[i] == '1') {
  269.         memcpy(matrix[s] + (len2 - 1 - s), input1, MAX_LENGTH - (len2 - 1 - s));
  270.     }
  271.     else if (input2[i] == 'i') {
  272.         memcpy(matrix[s] + (len2 - 1 - s), temp, MAX_LENGTH - (len2 - 1 - s));
  273.     }
  274.     else if (input2[i] == '0') { matrix[s][len1+len2-1] = '\0';}
  275.     s--;
  276. }
  277. /*
  278.     // Выводим результат
  279.     for (int i = 0; i < len2; i++) {
  280.         // Добавляем символы '/' для пустых мест
  281.         for (int j = 0; j < len; j++) {
  282.             if (matrix[i][j] == '\0') {
  283.                 //matrix[i][j] = ' ';  // Заполняем пустые места
  284.             }
  285.         }
  286.         printf("matrix[%d]: %s\n", i, matrix[i]);
  287.     }
  288.  
  289.     
  290.     // Вывод результатов
  291.     /*printf("Значение n: %d\n", n);
  292.     printf("Первая строка после удаления: %s\n", input1);
  293.     printf("Вторая строка после удаления: %s\n", input2);
  294.     printf("Первая строка после инверсии: %s\n", temp);
  295.     printf("Длина первой строки после удаления: %d\n", len1);
  296.     printf("Длина второй строки после удаления: %d\n", len2);*/
  297.  
  298.     char* result = addition(matrix, len2);
  299.     n=strlen(result)-n;
  300.     if (n>0 && n!=(len1+len2)){
  301.     memmove(result + n + 1, result + n, strlen(result) - n + 1);
  302.     result[n] = ',';}
  303.     printf("\nРезультат третьей функции: %s\n", result);
  304.  
  305. }
  306.  
  307. void threeToTen() {
  308.     char input[MAX_LENGTH];
  309.  
  310.     printf("\nEnter a string: ");
  311.     read_input(input, MAX_LENGTH);
  312.  
  313.     char *delimiter = strpbrk(input, ".,");
  314.     int n = (delimiter) ? (delimiter - input - 1) : (strlen(input) - 1);
  315.  
  316.     long double result = 0; // Замінено double на long double
  317.  
  318.     for (int i = 0; input[i] != '\0'; i++) {
  319.         if (input[i] == '.' || input[i] == ',') {
  320.             continue;
  321.         } else if (input[i] == 'i') {
  322.             result += -1 * powl(3, n); // Використовуємо powl для long double
  323.         } else if (isdigit(input[i])) {
  324.             result += (input[i] - '0') * powl(3, n); // Використовуємо powl для long double
  325.         }
  326.         n--;
  327.     }
  328.     printf("Decimal value: %.10Lf\n", result); // Використовуємо %Lf для long double
  329. }
  330.  
  331. void symmetry(const char *input, int isNegative) {
  332.     printf("Non-symmetrical result: %s\n", input);
  333.     size_t len = strlen(input);
  334.     char result[MAX_LENGTH] = "";
  335.     int x = 0, y = 0, z = 0;
  336.  
  337.     for (int i = len - 1; i >= 0; i--) {
  338.         if (input[i] == ',') {
  339.             memmove(result + 1, result, strlen(result) + 1);
  340.             result[0] = ',';
  341.             continue;
  342.         }
  343.  
  344.         x = input[i] - '0'; 
  345.         z = y + x;
  346.  
  347.         if (z <= 1) {
  348.             memmove(result + 1, result, strlen(result) + 1);
  349.             result[0] = z + '0';
  350.             y = 0;
  351.         } else if (z == 2) {
  352.             memmove(result + 1, result, strlen(result) + 1);
  353.             result[0] = 'i';
  354.             y = 1;
  355.         } else if (z == 3) {
  356.             memmove(result + 1, result, strlen(result) + 1);
  357.             result[0] = '0';
  358.             y = 1;
  359.         }
  360.     }
  361.  
  362.     if (y != 0) {
  363.         memmove(result + 1, result, strlen(result) + 1);
  364.         result[0] = y + '0';
  365.     }
  366.  
  367.     if (isNegative) {
  368.         invertSymmetry(result);
  369.     }
  370.  
  371.     printf("Symmetrical result: %s\n", result);
  372. }
  373.  
  374. void whole_part(char *part) {
  375.     long long number = strtoll(part, NULL, 10);
  376.  
  377.     if (number == 0) {
  378.         part[0] = '0';
  379.         part[1] = '\0';
  380.     } else {
  381.         char buffer[2];
  382.         part[0] = '\0'; 
  383.  
  384.         while (number > 0) {
  385.             sprintf(buffer, "%d", number % 3);
  386.             memmove(part + 1, part, strlen(part) + 1);
  387.             part[0] = buffer[0]; 
  388.             number /= 3;
  389.         }
  390.     }
  391. }
  392.  
  393. void fraction_part(char *part) {
  394.     double fractionalValue = atof(part) / pow(10, strlen(part));
  395.     char buffer[2];
  396.     part[0] = '\0'; 
  397.  
  398.     for (int i = 0; i < 15; i++) {
  399.         fractionalValue *= 3;
  400.         int digit = (int)fractionalValue;
  401.         fractionalValue -= digit;
  402.         sprintf(buffer, "%d", digit);
  403.         strcat(part, buffer); 
  404.     }
  405. }
  406.  
  407. void translation() {
  408.     char input[MAX_LENGTH];
  409.     char firstPart[MAX_LENGTH/2] = "";
  410.     char secondPart[MAX_LENGTH/2] = "";
  411.     int isNegative = 0;
  412.  
  413.     printf("\nEnter a string: ");
  414.     read_input(input, MAX_LENGTH);
  415.  
  416.     if (strchr(input, '-') != NULL) {
  417.         isNegative = 1;
  418.         memmove(input, input + 1, strlen(input)); 
  419.     }
  420.  
  421.     char *delimiter = strpbrk(input, ".,");
  422.  
  423.     if (delimiter) {
  424.         size_t firstLen = delimiter - input;
  425.         strncpy(firstPart, input, firstLen);
  426.         firstPart[firstLen] = '\0';
  427.  
  428.         strcpy(secondPart, delimiter + 1);
  429.     } else {
  430.         strcpy(firstPart, input);
  431.     }
  432.  
  433.     whole_part(firstPart);
  434.     if (strlen(secondPart) > 0) {
  435.         fraction_part(secondPart);
  436.     } else {
  437.         strcpy(secondPart, "0"); 
  438.     }
  439.  
  440.     char combined[MAX_LENGTH] = "";
  441.     snprintf(combined, sizeof(combined), "%s,%s", firstPart, secondPart);
  442.  
  443.     symmetry(combined, isNegative);
  444. }
  445.  
  446. int main() {
  447.     int choice;
  448.     char input1[MAX_LENGTH], input2[MAX_LENGTH];
  449.     int n;  // Размер матрицы
  450.  
  451.     int matrix[MAX_LENGTH][MAX_LENGTH];  // Матрица произвольного размера
  452.  
  453.     do {
  454.         printf("\nМеню:\n");
  455.         printf("1. В трійкову симетричну\n");
  456.         printf("2. В десятичну\n");
  457.         printf("3. Сума\n");
  458.         printf("4. Різниця\n");
  459.         printf("5. Множення\n");
  460.         printf("6. AND\n");
  461.         printf("7. OR\n");
  462.         printf("0. Вихід\n");
  463.         printf("Введіть ваш вибір: ");
  464.  
  465.         if (scanf("%d", &choice) != 1) {
  466.             fprintf(stderr, "Неверный ввод. Выход.\n");
  467.             break;
  468.         }
  469.  
  470.         while (getchar() != '\n'); // Ожидаем ввода
  471.  
  472.         switch (choice) {
  473.             case 1:
  474.                 translation();
  475.                 break;
  476.             case 2:
  477.                 threeToTen();
  478.                 break;
  479.             case 3:
  480.     printf("Введите первую строку: ");
  481.     read_input(input1, MAX_LENGTH);  
  482.     printf("Введите вторую строку: ");
  483.     read_input(input2, MAX_LENGTH);  
  484.     rationing(input1, input2, choice); 
  485.                 break;
  486.             case 4:
  487.     printf("Введите первую строку: ");
  488.     read_input(input1, MAX_LENGTH);  
  489.     printf("Введите вторую строку: ");
  490.     read_input(input2, MAX_LENGTH);
  491.     invertSymmetry(input2);
  492.     rationing(input1, input2, choice); 
  493.                 break;
  494.             case 5:
  495.     printf("Введите первую строку: ");
  496.     read_input(input1, MAX_LENGTH);  
  497.     printf("Введите вторую строку: ");
  498.     read_input(input2, MAX_LENGTH);  
  499.     multiplication(input1, input2);  
  500.                 break;
  501.             case 6: //OR
  502.     printf("Введите первую строку: ");
  503.     read_input(input1, MAX_LENGTH);  
  504.     printf("Введите вторую строку: ");
  505.     read_input(input2, MAX_LENGTH);
  506.     rationing(input1, input2, choice); 
  507.                 break;
  508.                case 7: //AND
  509.     printf("Введите первую строку: ");
  510.     read_input(input1, MAX_LENGTH);  
  511.     printf("Введите вторую строку: ");
  512.     read_input(input2, MAX_LENGTH);
  513.     rationing(input1, input2, choice); 
  514.                 break; 
  515.             case 0:
  516.                 printf("Выход из программы.\n");
  517.                 break;
  518.             default:
  519.                 printf("Неверный выбор. Попробуйте снова.\n");
  520.         }
  521.     } while (choice != 0);
  522.     return 0;
  523. }
  524.  
Success #stdin #stdout #stderr 0s 5220KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Меню:
1. В трійкову симетричну
2. В десятичну
3. Сума
4. Різниця
5. Множення
6. AND
7. OR
0. Вихід
Введіть ваш вибір:
stderr
copy 
Неверный ввод. Выход.
https://ideone.com/KqmbwS
language:
C (gcc 8.3)
created:
19 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!