Facebook
From Michaił Kubik, 2 Years ago, written in C.
Embed
Download Paste or View Raw
Hits: 233
  1. //
  2. // Created by kubik on 12.05.2018.
  3. // Edited by kubik on 18.07.2018.
  4. //
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9.  
  10. #include "util.h"
  11.  
  12. int add(const char *, const char *, char **);
  13.  
  14. int validate(const char *number) {
  15.     if (number == 0) return 2;
  16.     int i;
  17.     if (*number == '-' && *(number + 1) == '\0') {
  18.         return 1;
  19.     }
  20.     if (*number != '-' && (*number < '0' || *number > '9')) {
  21.         return 1;
  22.     }
  23.     for (i = 1; *(number + i) != '\0'; i++) {
  24.         if (*(number + i) < '0' || *(number + i) > '9') {
  25.             return 1;
  26.         }
  27.     }
  28.     if (i == 0) {
  29.         return 1;
  30.     }
  31.     return 0;
  32. }
  33.  
  34. int compare(const char *number1, const char *number2) {
  35.     printf("WITAMY %s i %s!\n", number1, number2);
  36.     if (number1 == NULL || number2 == NULL) return 2;
  37.     if (validate(number1) || validate(number2)) return 3;
  38.     if (*number1 == '-' && *number2 != '-') return -1;
  39.     if (*number1 != '-' && *number2 == '-') return 1;
  40.     if (*number1 == '-') {
  41.         number1++;
  42.         number2++;
  43.         const char *temp = number1;
  44.         number1 = number2;
  45.         number2 = temp;
  46.     }
  47.     if ((*number1 == '0' && *(number1 + 1) != '\0') || (*number2 == '0' && *(number2 + 1) != '\0')) return 3;
  48.     if (length(number1) > length(number2)) {
  49.         if (*number1 == '-') {
  50.             return -1;
  51.         } else {
  52.             return 1;
  53.         }
  54.     }
  55.     if (length(number1) < length(number2)) {
  56.         if (*number1 == '-') {
  57.             return 1;
  58.         } else {
  59.             return -1;
  60.         }
  61.     }
  62.     size_t i;
  63.     for (i = 0; i < length(number1); i++) {
  64.         printf("BADANE: %c %c\n", *(number1 + i), *(number2 + i));
  65.         if (*(number1 + i) > *(number2 + i)) {
  66.             printf("1>2\n");
  67.             if (*number1 == '-') {
  68.                 return -1;
  69.             } else {
  70.                 printf("hejho\n");
  71.                 return 1;
  72.             }
  73.         }
  74.         if (*(number1 + i) < *(number2 + i)) {
  75.             printf("1<2\n");
  76.             if (*number1 == '-') {
  77.                 return 1;
  78.             } else {
  79.                 return -1;
  80.             }
  81.         }
  82.     }
  83.     return 0;
  84.  
  85. }
  86.  
  87. int subtract(const char *number1, const char *number2, char **result) {
  88.     if (number1 == 0 || number2 == 0 || result == 0) return 1;
  89.     if (validate(number1) || validate(number2)) return 2;
  90.     if (*number1 == '-' && *number2 != '-') {
  91.         char *arr = malloc(length(number1) + 2);
  92.         clone(number1, arr);
  93.         pull(arr);
  94.         add(arr, number2, result);
  95.         push(*result);
  96.         **result = '-';
  97.         free(arr);
  98.         return 0;
  99.     }
  100.     if (*number1 != '-' && *number2 == '-') {
  101.         char *arr = malloc(length(number2) + 2);
  102.         clone(number2, arr);
  103.         pull(arr);
  104.         add(number1, arr, result);
  105.         free(arr);
  106.         return 0;
  107.     }
  108.     int m = 0;
  109.     if (*number1 == '-' && *number2 == '-') {
  110.         m = 1;
  111.     }
  112.  
  113.     *result = malloc((length(number1) > length(number2) ? (length(number1)) : (length(number2))) + 2);
  114.     if (*result == NULL) {
  115.         return 3;
  116.     }
  117.     int s = 0;
  118.     int i, l1 = length(number1) - 1, l2 = length(number2) - 1, c = (l1 < l2) ? (l1) : (l2);
  119.     char *arr = malloc(sizeof(*arr) * (l1 + 2));
  120.     if (arr == NULL) {
  121.         free(*result);
  122.         return 3;
  123.     }
  124.     char *arrt = malloc(sizeof(*arrt) * (l2 + 2));
  125.     if (arrt == NULL) {
  126.         free(arr);
  127.         free(*result);
  128.         return 3;
  129.     }
  130.  
  131.     clone(number1, arr);
  132.     clone(number2, arrt);
  133.     if (m) {
  134.         pull(arr);
  135.         pull(arrt);
  136.         c--;
  137.     }
  138.     char *temp;
  139.     switch (compare(arr, arrt)) {
  140.         case -1:
  141.             temp = arr;
  142.             arr = arrt;
  143.             arrt = temp;
  144.             i = l1;
  145.             l1 = l2;
  146.             l2 = i;
  147.             if (m == 1) {
  148.                 m = 0;
  149.             } else {
  150.                 m = 1;
  151.             }
  152.             break;
  153.         case 0:
  154.             free(arr);
  155.             free(arrt);
  156.             **result = '0';
  157.             *(*result + 1) = '\0';
  158.             return 0;
  159.         default:
  160.             break;
  161.     }
  162.     revert(arr);
  163.     revert(arrt);
  164.     for (i = 0; i <= c; i++) {
  165.         char num = (char) (*(arr + i) - '0' - *(arrt + i) + '0' - s);
  166.         s = 0;
  167.         if (num < 0) {
  168.             s = 1;
  169.             num += 10;
  170.         }
  171.         *(*result + i) = (char) ('0' + num);
  172.     }
  173.     revert(*result);
  174.     revert(*result);
  175.     if (l1 == l2) {
  176.         *(*result + i) = '\0';
  177.         revert(*result);
  178.     } else {
  179.         int len;
  180.         if (l1 > l2) {
  181.             temp = arr;
  182.             len = l1;
  183.         } else {
  184.             temp = arrt;
  185.             len = l2;
  186.         }
  187.         for (i = c + 1; i <= len; i++) {
  188.             char num = (char) (*(temp + i) - '0' - s);
  189.             s = (num < 0) ? (1) : (0);
  190.             if (num < 0) {
  191.                 num += 10;
  192.             }
  193.             *(*result + i) = (char) ('0' + num);
  194.         }
  195.         *(*result + i) = '\0';
  196.         revert(*result);
  197.     }
  198.     free(arr);
  199.     free(arrt);
  200.     zero_delet(*result);
  201.     workaround(*result);
  202.     if (m) {
  203.         if (**result != '-') {
  204.             push(*result);
  205.             **result = '-';
  206.         }
  207.     }
  208.     return 0;
  209. }
  210.  
  211.  
  212. int add(const char *number1, const char *number2, char **result) {
  213.     if (number1 == 0 || number2 == 0 || result == 0) return 1;
  214.     if (validate(number1) || validate(number2)) return 2;
  215.     if (*number1 == '-' && *number2 != '-') {
  216.         char *arr = malloc(length(number1) + 2);
  217.         if (arr == NULL) {
  218.             return 3;
  219.         }
  220.         clone(number1, arr);
  221.         pull(arr);
  222.         subtract(number2, arr, result);
  223.         free(arr);
  224.         return 0;
  225.     }
  226.     if (*number1 != '-' && *number2 == '-') {
  227.         char *arr = malloc(length(number2) + 2);
  228.         if (arr == NULL) {
  229.             return 3;
  230.         }
  231.         clone(number2, arr);
  232.         pull(arr);
  233.         subtract(number1, arr, result);
  234.         free(arr);
  235.         return 0;
  236.     }
  237.     int m = 0;
  238.     if (*number1 == '-' && *number2 == '-') {
  239.         m = 1;
  240.     }
  241.     int i, l1 = length(number1) - 1, l2 = length(number2) - 1, c = (l1 < l2) ? (l1) : (l2);
  242.     char *arr = malloc(sizeof(*arr) * (l1 + 2));
  243.     if (arr == NULL) {
  244.         return 3;
  245.     }
  246.     char *arrt = malloc(sizeof(*arrt) * (l2 + 2));
  247.     if (arrt == NULL) {
  248.         free(arr);
  249.         return 3;
  250.     }
  251.     clone(number1, arr);
  252.     clone(number2, arrt);
  253.     if (m) {
  254.         pull(arr);
  255.         pull(arrt);
  256.         l1--;
  257.         c--;
  258.         l2--;
  259.     }
  260.     char s = 0;
  261.     if (length(arr) == length(arrt) && (*(arr) - '0' + *(arrt) - '0' > 9)) s = 1;
  262.     *result = malloc((length(number1) > length(number2) ? (length(number1)) : (length(number2))) + s + 3);
  263.     if (*result == NULL) {
  264.         free(arr);
  265.         free(arrt);
  266.         return 3;
  267.     }
  268.     s = 0;
  269.  
  270.     revert(arr);
  271.     revert(arrt);
  272.     for (i = 0; i <= c; i++) {
  273.         char num = (char) (*(arr + i) - '0' + *(arrt + i) - '0' + s);
  274.         *(*result + i) = (char) ('0' + num % 10);
  275.         s = (char) (num / 10);
  276.     }
  277.     if (l1 == l2) {
  278.         if (s == 1) {
  279.             *(*result + i) = '1';
  280.             *(*result + i + 1) = '\0';
  281.         } else {
  282.             *(*result + i) = '\0';
  283.         }
  284.         revert(*result);
  285.     } else {
  286.         char *temp;
  287.         int len;
  288.         if (l1 > l2) {
  289.             temp = arr;
  290.             len = l1;
  291.         } else {
  292.             temp = arrt;
  293.             len = l2;
  294.         }
  295.         for (i = c + 1; i <= len; i++) {
  296.             char num = (char) (*(temp + i) - '0' + s);
  297.             *(*result + i) = (char) ('0' + num % 10);
  298.             s = (char) (num / 10);
  299.         }
  300.         if (s == 1) {
  301.             *(*result + i) = '1';
  302.             *(*result + i + 1) = '\0';
  303.         } else {
  304.             *(*result + i) = '\0';
  305.         }
  306.         revert(*result);
  307.     }
  308.     free(arr);
  309. //    arr = NULL;
  310.     free(arrt);
  311. //    arrt = NULL;
  312.     if (m) {
  313.         if (**result != '-') {
  314.             push(*result);
  315.             **result = '-';
  316.         }
  317.     }
  318.     return 0;
  319. }
  320.  
  321. int multiply(const char *number1, const char *number2, char **result) {
  322.     char symbol = 0;
  323.     if (*number1 == '-') {
  324.         symbol++;
  325.         number1++;
  326.     }
  327.     if (*number2 == '-') {
  328.         symbol = (char) ((symbol + 1) % 2);
  329.         number2++;
  330.     }
  331.     if (!strcmp(number2, "0") != 0) {
  332.         *result = malloc(sizeof(char) * 2);
  333.         if (*result == NULL) {
  334.             return 3;
  335.         }
  336.         *result = "0";
  337.         return 0;
  338.     }
  339.     if (!compare(number2, "1")) {
  340.         *result = malloc(sizeof(char) * strlen(number1));
  341.     }
  342.     char switcher = 0;
  343.     int ret;
  344.     char *temp12 = NULL, *temp22 = NULL, *temp2 = malloc(strlen(number2) + 1), *temp1;
  345.     if (temp2 == NULL) {
  346.         return 3;
  347.     }
  348.     temp1 = malloc(strlen(number1) + 1);
  349.     if (temp1 == NULL) {
  350.         free(temp2);
  351.         return 3;
  352.     }
  353.     strcpy(temp1, number1);
  354.     strcpy(temp12, number2);
  355.  
  356.     while (1) {
  357.         printf("sw: %d\n", switcher);
  358.         if (!switcher) {
  359.             printf("%s + %s", temp1, number1);
  360.             ret = add(temp1, number1, &temp12);
  361.             printf("dodawanko\n%d\n", ret);
  362.             if (ret) {
  363.                 break;
  364.             }
  365.             free(temp1);
  366.             switcher++;
  367.             subtract(temp2, "1", &temp22);
  368.             free(temp2);
  369.             printf("aaa\n");
  370.             if (strcmp(temp22, "0") != 0) {
  371.                 break;
  372.             }
  373.             printf("eee\n");
  374.         } else {
  375.             ret = add(temp12, number1, &temp1);
  376.             if (ret) {
  377.                 break;
  378.             }
  379.             free(temp12);
  380.             switcher--;
  381.             subtract(temp22, "1", &temp2);
  382.             free(temp22);
  383.             if (strcmp(temp2, "0") != 0) {
  384.                 break;
  385.             }
  386.         }
  387.     }
  388.     if (ret) {
  389.         if (switcher) {
  390.             free(temp12);
  391.             free(temp2);
  392.         } else {
  393.             free(temp1);
  394.             free(temp22);
  395.         }
  396.         free(temp2);
  397.     }
  398.     if (switcher) {
  399.         strcpy(*result, temp12);
  400.         free(temp12);
  401.         free(temp2);
  402.     } else {
  403.         strcpy(*result, temp1);
  404.         free(temp1);
  405.         free(temp22);
  406.     }
  407.     if (symbol) {
  408.         char *temp = malloc(strlen(*result) + 2);
  409.         strcpy(temp, *result);
  410.         free(*result);
  411.         push(temp);
  412.         *temp = '-';
  413.         *result = temp;
  414.     }
  415.     return 0;
  416.  
  417.  
  418. }
  419.  
  420. int main(void) {
  421.     char *arr = malloc(201), *arrt = malloc(201), *result = NULL;
  422.     if (arr == NULL || arrt == NULL) {
  423.         if (arr != NULL) {
  424.             free(arr);
  425.         }
  426.         if (arrt != NULL) {
  427.             free(arrt);
  428.         }
  429.         printf("Failed to allocate memory");
  430.         return 2;
  431.     }
  432.     printf("Podaj pierwsza liczbe:\n");
  433.     scanf("%200s", arr);
  434.     char c;
  435.     while ((c = (char) getchar()) != '\n' && c != EOF);
  436.     beksleszendelet(arr);
  437.     printf("Podaj druga liczbe:\n");
  438.     fgets(arrt, 201, stdin);
  439.     beksleszendelet(arrt);
  440.     int ret = multiply(arr, arrt, &result);
  441.     if (ret == 3) {
  442.         free(arr);
  443.         free(arrt);
  444.         printf("failed to allocate memory");
  445.         return 2;
  446.     }
  447.     if (ret) {
  448.         printf("error");
  449.         free(arr);
  450.         free(arrt);
  451.         if (result != NULL) {
  452.             free(result);
  453.         }
  454.         return 1;
  455.     }
  456.     printf("%s\n", result);
  457.     free(result);
  458.     /*   ret = subtract(arr, arrt, &result);
  459.        if (ret == 3) {
  460.            free(arr);
  461.            free(arrt);
  462.            printf("failed to allocate memory");
  463.            return 2;
  464.        }
  465.        if (ret) {
  466.            printf("error");
  467.            free(arr);
  468.            free(arrt);
  469.            if (result != NULL) {
  470.                free(result);
  471.            }
  472.            return 1;
  473.        }
  474.        printf("%s", result);
  475.        free(arr);
  476.        free(arrt);
  477.        free(result);*/
  478.     return 0;
  479. }