SHARE
TWEET

lab4

daniil_mironoff Mar 7th, 2020 77 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. ///////////////////////////////////////////////////////////
  2.  
  3. #include <iostream>
  4. #include <string.h>
  5.  
  6. using namespace std;
  7.  
  8. ///////////////////////////////////////////////////////////
  9.  
  10. void strrev(char *str) {
  11.         int i;
  12.         int j;
  13.         unsigned char a;
  14.         unsigned len = strlen((const char *)str);
  15.  
  16.         for (i = 0, j = len - 1; i < j; i++, j--) {
  17.             a = str[i];
  18.             str[i] = str[j];
  19.             str[j] = a;
  20.         }
  21. }
  22.  
  23. ///////////////////////////////////////////////////////////
  24.  
  25. void itoa(int n, char s[], bool& minus) {
  26.      int i = 0;
  27.  
  28.     // Если число отрицательное
  29.     if (n < 0) {
  30.         minus = true;
  31.         n = -n;
  32.     // Если число положительное
  33.     } else {
  34.         minus = false;
  35.     }
  36.  
  37.     // Запись цифр
  38.     // Пока цифр не останется
  39.     do {
  40.         s[i++] = (n % 10) + '0';  // Запись числа в строку
  41.         n /= 10;                // Переход к следующему
  42.     } while (n > 0);
  43.  
  44.     // Вставка символа окончания строки
  45.     s[i] = '\0';
  46. }
  47.  
  48. ///////////////////////////////////////////////////////////
  49.  
  50. const int SZ = 100000; // Максимальный размер verylong
  51.  
  52. ///////////////////////////////////////////////////////////
  53.  
  54. class verylong {
  55.     private:
  56.        
  57.         char vlstr[SZ];  // Число в символах
  58.         bool minus;      // Хранения знака минуса
  59.         int vlen;        // Текущая длина
  60.  
  61. //---------------------------------------------------------
  62.  
  63.         // Конструктор с строкой
  64.         verylong(const char s[SZ], bool symb) {
  65.             strcpy(vlstr, s);
  66.  
  67.             minus = symb;
  68.             vlen = strlen(s);
  69.  
  70.             // Избавляемся от юзлес нулей
  71.             for (int i = vlen - 1; i > -1; i--) {
  72.                 if (vlstr[i] != '0' | i == 0 ) {
  73.                     break;
  74.                 } else {
  75.                     vlstr[i] = 0;
  76.                 }
  77.  
  78.             }
  79.  
  80.             // Избавляемся от юзлес минуса у нуля
  81.             if (vlstr[0] == '0') {
  82.                 vlen = 1;
  83.                 minus = false;
  84.             } else {
  85.                 minus = symb;
  86.             }
  87.  
  88.             vlen = strlen(vlstr);
  89.         }
  90.  
  91. //---------------------------------------------------------
  92.  
  93.     public:
  94.         // Стандартный конструктор
  95.         verylong() : vlen(0) { vlstr[0] = '\0'; }
  96.  
  97.         // Конструктор с числом
  98.         verylong(const unsigned long n) {
  99.             itoa(n, vlstr, minus);
  100.             vlen = strlen(vlstr);
  101.         }
  102.  
  103. //---------------------------------------------------------
  104.  
  105.         // Перегрузка оператор <<
  106.         friend ostream& operator<< (ostream& stream, const verylong& obj) {
  107.             char temp[SZ];
  108.             strcpy(temp, obj.vlstr);
  109.             strrev(temp);
  110.  
  111.             if (obj.minus) { stream << '-'; }
  112.  
  113.  
  114.  
  115.             return (stream << temp);
  116.         }
  117.  
  118. //---------------------------------------------------------
  119.  
  120.         // Перегрузка оператора >>
  121.         friend istream& operator>> (istream& stream, verylong& obj) {
  122.             char temp_str[SZ];
  123.             stream >> temp_str;
  124.             obj.minus = false;
  125.             obj.vlen = 0;
  126.  
  127.             // Перебор символов
  128.             for (int i = 0; temp_str[i] != 0; i++) {
  129.                 // Проверка на минус
  130.                 if (temp_str[i] == '-') {
  131.                     if (obj.vlen == 0) {
  132.                         obj.minus = !(obj.minus);
  133.                     } else {
  134.                         exit(1);
  135.                     }
  136.                 } else
  137.  
  138.                 // Проверка на неправильный символ (не цифру)
  139.                 if (temp_str[i] < '0' | temp_str[i] > '9') {
  140.                     exit(1);
  141.                 }
  142.  
  143.                 // Запись цифры
  144.                 else {
  145.                     obj.vlstr[obj.vlen++] = temp_str[i];
  146.                 }
  147.  
  148.             }
  149.  
  150.             obj.vlstr[obj.vlen] = 0;
  151.            
  152.             // Переворачиваем строку
  153.             strrev(obj.vlstr);
  154.  
  155.  
  156.  
  157.             return stream;
  158.         }
  159.  
  160. //---------------------------------------------------------
  161.  
  162.         // Оператор cравнения равенства (==)
  163.         bool operator== (const verylong obj) const {
  164.             // Проверка на разность знаков
  165.             if (minus != obj.minus) { return false; }
  166.  
  167.             // Проверка на разность кол-во символов
  168.             if (vlen != obj.vlen) { return false; }
  169.  
  170.  
  171.             // Перебор всех разрядов
  172.             for (int i = 0; i < vlen; i++) {
  173.                
  174.                 int d1 = vlstr[i];
  175.                 int d2 = obj.vlstr[i];
  176.  
  177.                 // Проверка на совпадение символа
  178.                 if (d1 != d2) { return false; }
  179.             }
  180.  
  181.             return true;
  182.         }
  183.  
  184.  
  185. };
  186.  
  187.  
  188. ///////////////////////////////////////////////////////////
  189.  
  190. template <class T>
  191. struct link {
  192.     link* prev;  // Предыдущий элемент
  193.     link* next;  // Следующий  элемент
  194.  
  195.     T data;  // Данные
  196. };
  197.  
  198. ///////////////////////////////////////////////////////////
  199.  
  200. template <class T>
  201. class list {
  202.     private:
  203.         link<T>* first;
  204.         link<T>* last;
  205.  
  206.         unsigned int count;
  207.  
  208. //---------------------------------------------------------
  209.  
  210.     public:
  211.         // Дефолтный конструктор (без аргументов)
  212.         list() : first(NULL) , last(NULL) , count(0)
  213.             { /* ... */ }
  214.  
  215. //---------------------------------------------------------
  216.  
  217.         void push_back(const T& value){
  218.             // Если Список не пустой
  219.             if (count) {
  220.                 last -> next = new link<T>;
  221.                 last -> next -> prev = last;
  222.                 last = last -> next;
  223.                 last -> next = NULL;
  224.                 last -> data = value;
  225.             }
  226.  
  227.             // Если Список пустой
  228.             else {
  229.                 first = last = new link<T>;
  230.                 first -> prev = NULL;
  231.                 first -> next = NULL;
  232.                 first -> data = value;
  233.             }
  234.  
  235.             count++;
  236.         }
  237.  
  238. //---------------------------------------------------------
  239.  
  240.         friend void killerDublications(list<verylong>&);
  241.  
  242. //---------------------------------------------------------
  243.  
  244.         friend ostream& operator<< (ostream& stream, const list<T>& container) {
  245.             for (auto iter_l = container.first; iter_l != NULL; iter_l = iter_l -> next) {
  246.                 stream << iter_l -> data << endl;
  247.             }
  248.  
  249.             return stream;
  250.         }
  251.  
  252. };
  253.  
  254. ///////////////////////////////////////////////////////////
  255.  
  256. void killerDublications(list<verylong>& container) {
  257.     for (auto iter_l = container.first; iter_l != NULL; iter_l = iter_l -> next) {
  258.         for (auto iter_v = iter_l -> next; iter_v != NULL; iter_v = iter_v -> next) {
  259.             if ( iter_l -> data == iter_v -> data ) {
  260.                 // Если удаляймый элемент - последний в контейнере
  261.                 if ((iter_v -> next) == NULL) {
  262.                     container.last = container.last -> prev;
  263.                     delete container.last -> next;
  264.                     container.last -> next = NULL;
  265.                 }
  266.                
  267.                 // Если удаляймый элемент - НЕ последний в контейнере
  268.                 else {
  269.                     link<verylong>* temp = iter_v -> prev;
  270.                     iter_v -> next -> prev = iter_v -> prev;
  271.                     iter_v -> prev -> next = iter_v -> next;
  272.                     delete iter_v;
  273.                     iter_v = temp;
  274.                 }
  275.  
  276.             }
  277.         }
  278.     }
  279. }
  280.  
  281. ///////////////////////////////////////////////////////////
  282.  
  283. int main() {
  284.     verylong tempVerylong;
  285.     list<verylong> testList;
  286.    
  287.     for (int k = 0; k < 10; k++) {
  288.         cout << "Input verylong [" << k + 1 << "/10]: "; cin >> tempVerylong;
  289.         testList.push_back(tempVerylong);
  290.     }
  291.  
  292.     cout << endl;
  293.  
  294.     killerDublications(testList);
  295.  
  296.     cout << "Result killerDublications():" << endl << testList << endl;
  297.    
  298.  
  299.  
  300.  
  301.     return 0;
  302. }
  303.  
  304. ///////////////////////////////////////////////////////////
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