SHARE
TWEET

Untitled

a guest Sep 22nd, 2019 72 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. #define ERROR_CODE -1
  6. #define RIGHT 0
  7. #define INPUT_OK 1
  8. #define ALLOWED_INPUT_SIZE 38
  9. #define SIGN_QUANTITY_LIMIT 2
  10. #define DEGREE_LIMIT 1
  11. #define DOT_LIMIT 1
  12. #define POSITIVE_NUMBER 1
  13. #define NEGATIVE_NUMBER -1
  14. #define TRUE 1
  15. #define FALSE 0
  16.  
  17. /*1)Смоделировать операцию деления действительного числа
  18. на действительное число в форме (+,-)m.n Е (+,-)K, где
  19. суммарная длина мантиссы (m+n) - до 30 значащих цифр, а
  20. величина порядка K - до 5 цифр. Результат выдать в форме
  21.  (+,-)0.m1 Е (+,-)K1, где m1 - до 30 значащих цифр, а K1 - до 5
  22. цифр.
  23.  2)
  24.  *
  25.  * */
  26. void welcome_text()
  27. {
  28.     printf("Data entry begins strictly with the sign of the number(+ or -) \n"
  29.            "If there is degree in number, then the sign of degree (+ or"
  30.            " -) is also indicated strictly after E \n"
  31.            "If you enter E, there should be no spaces between numbers and E \n"
  32.            "The number entered must not exceed 30 characters \n"
  33.            "The size of the input degree must not exceed 5 characters \n"
  34.            "Real numbers must be entered through a dot \n"
  35.            "                    ------------------------------\n");
  36. }
  37.  
  38. void swap(int *xp, int *yp)/*Функция, меняющая местами числа*/
  39. {
  40.     int temp = *xp;
  41.     *xp = *yp;
  42.     *yp = temp;
  43. }
  44.  
  45. void reverse_array(int *array, int size)
  46. {
  47.     for (int i = 0; i < size / 2; i++)
  48.     {
  49.         swap(&array[i], &array[size - i]);
  50.     }
  51. }
  52.  
  53. /*Функция, убирающая нули сразу после точки*/
  54. void remove_zero(int *digits, int *size, int *E)
  55. {
  56.     int i = 0;
  57.     int size_remember = *size;
  58.     /*Если встретился 0 в начале массива цифр, то смещаем его в конец*/
  59.     /*С последующем уменьшением размера массива цифр*/
  60.     while (digits[i] == 0)
  61.     {
  62.         for (int j = 0; j < (size_remember - 1); j++)
  63.         {
  64.             swap(&digits[j], &digits[j + 1]);
  65.         }
  66.         --*size;
  67.     }
  68. }
  69.  
  70. void number_split(char *string, int *digits, int *size, int *E, int *sign)
  71. {
  72.     /*Переменная для исключения добавления лишнего нуля в массив цифр*/
  73.     int useless_zero = FALSE;
  74.     if (string[1] == '0' && (string[0] == '-' || string[0] == '+') && (string[2] == '.'))
  75.     {
  76.         useless_zero = TRUE;
  77.     }
  78.     /*Переменная для отрезания незначащих нулей в конце*/
  79.     /*для исключения их добавления в массив цифр*/
  80.     int size_to_delete = 0;
  81.     int index = 0;
  82.     /*Проверка знака перед числом*/
  83.     if (string[0] == '-')
  84.     {
  85.         *sign = NEGATIVE_NUMBER;
  86.     }
  87.     else
  88.     {
  89.         *sign = POSITIVE_NUMBER;
  90.     }
  91.     int E_flag = FALSE;/*Переменная для проверки наличия Е в числе*/
  92.     int sign_E = POSITIVE_NUMBER;/*Знак порядка*/
  93.     /*Переменная запоминающая старый порядок перед нормализацией*/
  94.     int old_E = 0;
  95.     int point_flag = FALSE;/*Переменная для проверки наличия точки в числе*/
  96.     /*Проверка наличия целой части*/
  97.     while (index < strlen(string))
  98.     {
  99.         /*Встретилась ли точка при записи числа*/
  100.         if (string[index] == '.')
  101.         {
  102.             point_flag = TRUE;
  103.         }
  104.         /*Встретилась ли E при записи числа*/
  105.         if (string[index] == 'E')
  106.         {
  107.             if (string[index + 1] == '-')
  108.             {
  109.                 sign_E = NEGATIVE_NUMBER;
  110.             }
  111.             E_flag = TRUE;
  112.             int index_zero_check = index;
  113.             /*Удаление незначащих нулей с конца*/
  114.             while (string[index_zero_check - 1] == '0')
  115.             {
  116.                 index_zero_check--;
  117.                 ++(*E);
  118.                 size_to_delete++;
  119.             }
  120.         }
  121.         /*Проверка на наличие целой части числа*/
  122.         if ((string[index] != '+') && (string[index] != '-') && (string[index] != '.') &&
  123.             (string[index] != 'E') && (E_flag == FALSE))
  124.         {
  125.             /*Встретилась ли точка?Т.к. целой части нет, то порядок далее убывает*/
  126.             if (point_flag == TRUE)
  127.             {
  128.                 --(*E);
  129.             }
  130.             /*Перевод чисел из char в int*/
  131.             digits[*size] = string[index] - '0';
  132.             ++(*size);
  133.         }
  134.         /*Запись изначального порядка числа*/
  135.         if (E_flag == TRUE)
  136.         {
  137.             if ((string[index] != 'E') && (string[index] != '+') && (string[index] != '-'))
  138.             {
  139.                 /*Запись старого порядка числа*/
  140.                 old_E = old_E + (string[index] - '0');
  141.                 if (strlen(string) > index + 1)
  142.                 {
  143.                     old_E = old_E * 10;
  144.                 }
  145.             }
  146.         }
  147.         index++;
  148.     }
  149.     /*Корректировка размера массива цифр в соотв с наличием незначащих нулей*/
  150.     *size = *size - size_to_delete;
  151.     /*Смещение цифр в зависимости от наличия незначащего нуля в начале*/
  152.     if (useless_zero == TRUE)
  153.     {
  154.         for (int j = 0; j < (*size - 1); j++)
  155.         {
  156.             swap(&digits[j], &digits[j + 1]);
  157.         }
  158.         --(*size);
  159.     }
  160.     /*Преобразование порядка с учетом знака Е*/
  161.     old_E *= sign_E;
  162.     /*Получение финального порядка числа*/
  163.     *E = *E + old_E;
  164.     remove_zero(digits, size, E);
  165. }
  166. int number_comparsion(int *digits,int *digits2)
  167. {
  168.     for(int i = 0; digits[i]; i++)
  169.     {
  170.         if ((digits[i] - digits2[i]) < 0)
  171.             return FALSE;
  172.         if ((digits[i] - digits2[i]) > 0 )
  173.             return TRUE;
  174.     }
  175.     return TRUE;
  176. }
  177. void divide_function(int *digits, int *E, int *size,
  178.                      int *digits2, int *E2, int *size2,
  179.                      int *digits_final, int *E_final, int *size_final)
  180. {
  181.     /*Массив А1 берет цифры слева из первого числа пока оно не будет делиться на второе*/
  182.     int size_A1 = 0;
  183.     int A1 = 0;
  184.     int A1_digits[ALLOWED_INPUT_SIZE];
  185.     int B = 0;
  186.     while (size_A1 < *size2)
  187.     {
  188.         A1 = A1 * 10;
  189.         A1 += digits[size_A1];
  190.         A1_digits[size_A1] = digits[size_A1];
  191.         B = B * 10;
  192.         B += digits2[size_A1];
  193.         size_A1++;
  194.     }
  195.     if (A1 < B)
  196.     {
  197.         A1 = A1 * 10;
  198.         A1 += digits[size_A1];
  199.     }
  200.     int C = 0;
  201.     while (C * B <= A1)
  202.     {
  203.         C++;
  204.     }
  205.     C--;
  206.     digits_final[*size_final] = C;
  207.     ++(*size_final);
  208.     int CxB_array[ALLOWED_INPUT_SIZE];
  209.     int CxB = C * B;
  210.     int i = 0;
  211.     while (CxB > 0)
  212.     {
  213.         CxB_array[i] = CxB % 10;
  214.         CxB /= 10;
  215.         i++;
  216.     }
  217.     printf("\n");
  218.     reverse_array(CxB_array, i);
  219.     i = 0;
  220.     while (i < size_A1)
  221.     {
  222.         if (digits[i] - CxB_array[i] >= 0)
  223.         {
  224.             digits[i] = digits[i] - CxB_array[i];
  225.         }
  226.         else
  227.         {
  228.             digits[i - 1] = digits[i - 1] - 1;
  229.             digits[i] = 10 - CxB_array[i] + digits[i];
  230.         }
  231.         i++;
  232.     }
  233.     if (number_comparsion(digits,digits2) == TRUE)
  234.     {
  235.         divide_function(digits, E, size, digits2, E2, size2, digits_final, E_final, size_final);
  236.     }
  237.     else
  238.     {
  239.         /*Работа с остатком числа*/
  240.     }
  241. }
  242.  
  243. char input_format_check(char *string)
  244. {
  245.     /*Массив допустимых символов*/
  246.     char allowed_array[14] = "0123456789E+-.";
  247.     int size = 0;
  248.     int E_quantity_check = 0; /*Подсчет кол-ва встречаемого символа E*/
  249.     int sign_quantity_check = 0;/*Подсчет кол-ва встречаемого символа знака*/
  250.     int dot_quantity_check = 0;/*Подсчет кол-ва встречаемого символа точки*/
  251.     /*Если число не начинается со знака,то ошибка*/
  252.     if ((string[size] != '-') && (string[size] != '+'))
  253.     {
  254.         return ERROR_CODE;
  255.     }
  256.     /*Движение по строке до ее конца*/
  257.     while (size != strlen(string))
  258.     {
  259.         /*Переменная для проверки корректности введенного сивола*/
  260.         int check_correct_input = 0;
  261.         for (int i = 0; i < 14; i++)
  262.         {
  263.             /*Входит ли введенный символ в список допустиых*/
  264.             if (string[size] == allowed_array[i])
  265.             {
  266.                 check_correct_input = 1;
  267.             }
  268.         }
  269.         if (string[size] == 'E')
  270.         {
  271.             /*Проверка обязательного знака после E*/
  272.             if ((string[size + 1] != '-') && (string[size + 1] != '+'))
  273.             {
  274.                 /*Проверка введен ли порядок после E*/
  275.                 if ((string[size + 2] != '0') && (string[size + 2] != '1')
  276.                     && (string[size + 2] != '2') && (string[size + 2] != '3')
  277.                     && (string[size + 2] != '4') && (string[size + 2] != '5')
  278.                     && (string[size + 2] != '6') && (string[size + 2] != '7')
  279.                     && (string[size + 2] != '8') && (string[size + 2] != '9'))
  280.                 {
  281.                     return ERROR_CODE;
  282.                 }
  283.             }
  284.             E_quantity_check++;
  285.         }
  286.         if (string[size] == '-' || string[size] == '+')
  287.         {
  288.             /*Проверка знака на первой позиции*/
  289.             if ((size != 0))
  290.             {
  291.                 /*Проверка знака после E*/
  292.                 if (string[size - 1] != 'E')
  293.                 {
  294.                     return ERROR_CODE;
  295.                 }
  296.             }
  297.             if (string[size + 1] == 'E')
  298.             {
  299.                 return ERROR_CODE;
  300.             }
  301.             sign_quantity_check++;
  302.         }
  303.         if (string[size] == '.')
  304.         {
  305.             /*Исключение чисел с запятой в порядке*/
  306.             if (E_quantity_check == DEGREE_LIMIT)
  307.             {
  308.                 return ERROR_CODE;
  309.             }
  310.             dot_quantity_check++;
  311.         }
  312.         /*Проверка допустимого количества элементов*/
  313.         if ((check_correct_input != 1) || (sign_quantity_check > SIGN_QUANTITY_LIMIT) \
  314.  || (E_quantity_check > DEGREE_LIMIT) || (dot_quantity_check > DOT_LIMIT))
  315.         {
  316.             return ERROR_CODE;
  317.         }
  318.         /*Переход к следующему символу строки*/
  319.         size++;
  320.     }
  321.     return RIGHT;
  322. }
  323.  
  324. int input_function(char *input)
  325. {
  326.     if (scanf("%100s", input) != INPUT_OK)
  327.     {
  328.         return ERROR_CODE;
  329.     }
  330.     /*Проверка длинны введенного чилса*/
  331.     if (strlen(input) > ALLOWED_INPUT_SIZE)
  332.     {
  333.         printf("Input size exceeded");
  334.         return ERROR_CODE;
  335.     }
  336.     /*Проверка корректности введенного формата числа*/
  337.     if (input_format_check(input) != RIGHT)
  338.     {
  339.         printf("Invalid input format");
  340.         return ERROR_CODE;
  341.     }
  342.     return RIGHT;
  343. }
  344.  
  345. int main()
  346. {
  347.     /*Правила ввода текста в консоли*/
  348.     welcome_text();
  349.     char input[ALLOWED_INPUT_SIZE];/*Строка ввода первого числа*/
  350.     char input2[ALLOWED_INPUT_SIZE];/*Строка второго первого числа*/
  351.     printf("Input first number:");
  352.     /*Проверка правильного формата первого числа*/
  353.     if (input_function(input) == ERROR_CODE)
  354.     {
  355.         return ERROR_CODE;
  356.     }
  357.     printf("\n");
  358.     printf("Input second number:");
  359.     /*Проверка правильного формата второго числа*/
  360.     if (input_function(input2) == ERROR_CODE)
  361.     {
  362.         return ERROR_CODE;
  363.     }
  364.     /* Переменные для нормализации вида числа*/
  365.     int digits[ALLOWED_INPUT_SIZE]; /* Массив цифр первого числа */
  366.     int sign = 1;/*Знак первого числа*/
  367.     int size = 0;/*Размер массива цифр первого числа*/
  368.     int E = 0; /*Порядок первого числа*/
  369.     int digits2[ALLOWED_INPUT_SIZE];/* Массив цифр второго числа */
  370.     int sign2 = 1;/*Знак второго числа*/
  371.     int size2 = 0;/*Размер массива цифр второго числа*/
  372.     int E2 = 0;/*Порядок второго числа*/
  373.     number_split(input, digits, &size, &E, &sign);/*Нормализация первого числа*/
  374.     for (int i = 0; i < size; i++)
  375.     {
  376.         printf("%d ", digits[i]);
  377.     }
  378.     printf("sign = %d, E = %d \n", sign, E);
  379.     number_split(input2, digits2, &size2, &E2, &sign2);/*Нормализация второго числа*/
  380.     for (int i = 0; i < size2; i++)
  381.     {
  382.         printf("%d ", digits2[i]);
  383.     }
  384.     printf("sign = %d, E = %d \n", sign2, E2);
  385.     int digits_final[ALLOWED_INPUT_SIZE];/* Массив цифр финального числа */
  386.     int E_final = 0;/*Порядок финального числа*/
  387.     int sign_final = 1;/*Знак финального числа*/
  388.     int size_final = 0;/*Размер финального числа*/
  389.     divide_function(digits, &E, &size, digits2, &E2, &size2, digits_final, &E_final, &size_final);
  390.     for (int i = 0; i < size_final; i++)
  391.     {
  392.         printf("%d ", digits_final[i]);
  393.     }
  394.     return RIGHT;
  395. }
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