Semester 2 exam task added

Author: potat-dev

Exam/Semester_2/Task_3/main.cpp

@@ -0,0 +1,66 @@
+#include <iostream>
+#include <string.h>
+using namespace std;
+
+class Vector {
+  private:
+    int *arr;
+    size_t size;
+
+  public:
+    Vector(size_t size);
+    Vector(Vector& v);
+    ~Vector();
+    Vector& operator=(Vector& v);
+    Vector& set(size_t index, int value);
+    void print();
+};
+
+Vector::Vector(size_t size) {
+  this->size = size;
+  arr = new int[size];
+}
+
+Vector::Vector(Vector& v) {
+  this->size = v.size;
+  arr = new int[size];
+  memcpy(arr, v.arr, sizeof(int) * size);
+}
+
+Vector& Vector::operator=(Vector& v) {
+  if (&v == this) return *this; // присваивание самому себе
+  this->size = v.size;
+  delete[] arr;
+  arr = new int[size];
+  memcpy(arr, v.arr, sizeof(int) * size);
+  return *this;
+}
+
+Vector::~Vector() {
+  delete[] arr;
+}
+
+Vector& Vector::set(size_t index, int value) {
+  arr[index] = value;
+  return *this;
+}
+
+void Vector::print() {
+  for (size_t i = 0; i < size; i++)
+    std::cout << arr[i] << " ";
+  cout << endl;
+}
+
+int main() {
+  Vector a(4);
+  a.set(0, 0).set(1, 1).set(2, 42).set(3, 618).print();
+
+  Vector b(a);
+  b.print();
+
+  a.set(0, 777).print();
+  b.print();
+
+  b = a;
+  b.print();
+}

Exam/Semester_2/Task_4/main.cpp

@@ -0,0 +1,116 @@
+#include <stdlib.h>
+#include <iostream>
+using namespace std;
+
+class node_t {
+  private:
+    int value;
+    node_t* next;
+  public:
+    node_t(int v = 0);
+    node_t* get_next();
+    int get_value();
+    void set_next(node_t *n);
+};
+
+node_t::node_t(int v) {
+  value = v;
+  next = NULL;
+}
+
+node_t* node_t::get_next() {
+  return next;
+}
+
+int node_t::get_value() {
+  return value;
+}
+
+void node_t::set_next(node_t *n) {
+  this->next = n;
+}
+
+class list_t {
+  private:
+    node_t *head;
+    size_t size;
+  public:
+    list_t();
+    list_t(list_t& l);
+    ~list_t();
+
+    list_t& push_back(int value);
+    list_t& set(int index, int value);
+    void print();
+};
+
+list_t::list_t() {
+  head = NULL;
+  size = 0;
+}
+
+list_t::list_t(list_t& l) {
+  head = NULL;
+  node_t *last = NULL;
+  for (node_t *lcurr = l.head; lcurr != NULL; lcurr = lcurr->get_next()) {
+    node_t *curr = new node_t(lcurr->get_value());
+    if (head == NULL) {
+      head = curr;
+    } else {
+      last->set_next(curr);
+    }
+    last = curr;
+  }
+  size = l.size;
+}
+
+list_t::~list_t() {
+  node_t *curr = head;
+  while (curr != NULL) {
+    node_t *next = curr->get_next();
+    delete curr;
+    curr = next;
+  }
+  size = 0; head = NULL;
+}
+
+list_t& list_t::push_back(int value) {
+  node_t *n = new node_t(value);
+  if (head == NULL) {
+    head = n;
+  } else {
+    node_t *curr = head;
+    while (curr->get_next() != NULL) {
+      curr = curr->get_next();
+    }
+    curr->set_next(n);
+  }
+  return *this;
+}
+
+list_t& list_t::set(int index, int value) {
+  node_t *curr = head;
+  for (int id = 0; id != index; id++) {
+    curr = curr->get_next();
+  }
+  
+  return *this;
+}
+
+void list_t::print() {
+  for (node_t *curr = head; curr != NULL; curr = curr->get_next()) {
+    cout << curr->get_value() << " ";
+  }
+  cout << endl;
+}
+
+
+int main() {
+  list_t l;
+  l.push_back(1).push_back(2).push_back(42).push_back(618).print();
+
+  list_t l2(l);
+  l2.push_back(0);
+  l2.print();
+  l.print();
+}

Exam/Semester_2/Task_5/main.cpp

@@ -0,0 +1,23 @@
+// class Figure {
+//   private:
+//     int x, y;
+// };
+
+// class Rect : public Figure {
+//   private:
+//     int h, w;
+// };
+
+#include <iostream>
+using namespace std;
+
+class Date {
+  private:
+    int y, m, d;
+  
+  public:
+    friend ostream& operator<<(std::ostream& out, const Date& d) {
+      out << d.y << "." << d.m << "." << d.d;
+      return out;
+    }
+};

Exam/Semester_2/Task_9/hugeint.cpp

@@ -0,0 +1,106 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+class HugeInt {
+  public:
+    HugeInt(string str = "0", int digits_count = 40);
+    HugeInt(const HugeInt &temp, bool invert = false);
+    HugeInt(long long n);
+
+    void set(string str);
+    bool is_zero();
+    bool has_minus();
+    string to_str();
+    void remove_leading_zeros();
+
+    HugeInt& operator=(const HugeInt &temp);
+    HugeInt& operator=(const long long &temp);
+    HugeInt& operator=(const string &str);
+
+    friend istream& operator>>(istream &in, HugeInt &a);
+    friend ifstream& operator>>(ifstream &in, HugeInt &a);
+
+    friend ostream& operator<<(ostream &out, const HugeInt &a);
+    friend ofstream& operator<<(ofstream &out, HugeInt &a);
+
+    friend bool operator==(const HugeInt &a, const HugeInt &b);
+    friend bool operator!=(const HugeInt &a, const HugeInt &b);
+
+    friend bool operator>(const HugeInt&a, const HugeInt &b);
+    friend bool operator>=(const HugeInt &a, const HugeInt &b);
+ 
+    friend bool operator<(const HugeInt &a, const HugeInt &b);
+    friend bool operator<=(const HugeInt &a, const HugeInt &b);
+
+    // friend HugeInt operator+(const HugeInt &a, const HugeInt &b);
+    // friend HugeInt operator-(const HugeInt &a, const HugeInt &b);
+  
+    const HugeInt operator-();
+
+    friend HugeInt operator+(HugeInt a, const HugeInt &b);
+    // friend HugeInt operator+(HugeInt &a, HugeInt &b);
+	  friend HugeInt operator+(const HugeInt &a, long long value);
+	  friend HugeInt operator+(long long value, const HugeInt &a);
+
+    friend HugeInt operator-(HugeInt left, const HugeInt &right);
+    // friend HugeInt operator-(HugeInt &a, HugeInt &b);
+	  friend HugeInt operator-(const HugeInt &a, long long value);
+	  friend HugeInt operator-(long long value, const HugeInt &a);
+    
+
+  private:
+    vector<unsigned char> array;
+    unsigned int digit_count;
+    unsigned int capacity;
+    bool minus = false;
+};
+
+bool operator==(const HugeInt &a, const HugeInt &b) {
+  if (a.digit_count == b.digit_count && a.minus == b.minus) {
+    for (int i = 0; i < a.digit_count; i++)
+      if (a.array[i] != b.array[i]) return false;
+    return true;
+  } else return false;
+}
+
+bool operator<(const HugeInt &a, const HugeInt &b) {
+  if (a.minus == b.minus) {
+    if (a.minus) {
+      // если оба отрицательные
+      if (a.digit_count == b.digit_count) {
+        // сравниваем каждую цифру
+        for (int i = 0; i < a.digit_count; i++)
+          if (a.array[i] == b.array[i]) continue;
+          else return (a.array[i] > b.array[i]);
+        return false;
+      } else return (a.digit_count > b.digit_count);
+    } else {
+      // если оба положительные
+      if (a.digit_count == b.digit_count) {
+        for (int i = 0; i < a.digit_count; i++)
+          if (a.array[i] == b.array[i]) continue;
+          else return (a.array[i] < b.array[i]);
+        return false;
+        // сравниваем каждую цифру
+      } else return (a.digit_count < b.digit_count);
+    }
+  } else return a.minus;
+}
+
+ostream& operator<<(ostream &out, const HugeInt &a) {
+  if (a.minus) out << "-";
+  for (int i = a.digit_count - 1; i > -1; i--)
+    out << (char) (a.array[i] + '0');
+  return out;
+}
+
+class complex {
+  private:
+    double re, im;
+  public:
+    complex(double re = 0, double im = 0) : re(re), im(im) {}
+    friend ostream& operator<<(ostream& out, const complex& c) {
+      out << "(" << c.re << "+" << c.im << "*i)";
+    }
+};