upload

3/A.cpp

@@ -0,0 +1,59 @@
+#include <iostream>
+
+struct Node {
+  Node* next;
+  int message;
+};
+
+class Stack {
+ private:
+  Node* first = nullptr;
+
+ public:
+  void Add(int message) {
+    Node* new_node = new Node{first, message};
+    first = new_node;
+  };
+
+  int Poop() {
+    Node* last = first;
+    int return_value = last->message;
+    first = last->next;
+    delete last;
+    return return_value;
+  }
+};
+
+int main() {
+  Stack stack;
+  int n;
+  int stack_idx = 0;
+
+  std::cin >> n;
+
+  int* return_values = new int[n];
+
+  for (int i = 0; i < n; ++i) {
+    char action;
+    std::cin >> action;
+
+    if (action == '+') {
+      int message;
+
+      std::cin >> message;
+
+      stack.Add(message);
+    } else {
+      return_values[stack_idx] = stack.Poop();
+      ++stack_idx;
+    }
+  }
+
+  for (int i = 0; i < stack_idx; ++i) {
+    std::cout << return_values[i] << '\n';
+  }
+
+  delete[] return_values;
+
+  return 0;
+}

3/B.cpp

@@ -0,0 +1,70 @@
+#include <iostream>
+
+struct Node {
+  Node* next;
+  int message;
+};
+
+class Queue {
+ private:
+  Node* first = nullptr;
+  Node* last = nullptr;
+  size_t size = 0;
+ public:
+  void Add(int message) {
+    Node* new_node = new Node {nullptr, message};
+    if (size == 0) {
+      first = new_node;
+    } else {
+      last->next = new_node;
+    }
+    ++size;
+    last = new_node;
+  }
+
+  int Pop() {
+    if (size != 0) {
+      Node* prev = first;
+      int return_value = prev->message;
+      first = prev->next;
+      delete prev;
+      --size;
+      return return_value;
+    }
+  }
+
+};
+
+int main() {
+  Queue queue;
+  int n;
+  int stack_idx = 0;
+
+  std::cin >> n;
+
+  int* return_values = new int[n];
+
+  for (int i = 0; i < n; ++i) {
+    char action;
+    std::cin >> action;
+
+    if (action == '+') {
+      int message;
+
+      std::cin >> message;
+
+      queue.Add(message);
+    } else {
+      return_values[stack_idx] = queue.Pop();
+      ++stack_idx;
+    }
+  }
+
+  for (int i = 0; i < stack_idx; ++i) {
+    std::cout << return_values[i] << '\n';
+  }
+
+  delete[] return_values;
+
+  return 0;
+}

3/C.cpp

@@ -0,0 +1,49 @@
+#include <iostream>
+
+typedef long long ll;
+
+void RadixSort(char** arr, const ll size, const ll offset) {
+  if (size == 1)
+    return;
+
+  int i, j, idx;
+  idx = 0;
+  i = idx;
+  j = 1;
+
+  while (idx < size) {
+    while (arr[i][offset] > arr[j][offset]) {
+      std::swap(arr[i], arr[j]);
+      if (i == 0)
+        break;
+      --j;
+      --i;
+    }
+    i = idx;
+    j = ++idx;
+  }
+}
+
+int main() {
+  ll messages_size, message_length, max_offset;
+
+  std::cin >> messages_size >> message_length >> max_offset;
+
+  char** messages = new char* [messages_size];
+
+  for (ll i = 0; i < messages_size; ++i) {
+    messages[i] = new char[message_length];
+    for (ll j = 0; j < message_length; ++j){
+      std::cin >> messages[i][j];
+    }
+  }
+
+  for (ll offset = message_length - 1; message_length - offset - 1 < max_offset; --offset) {
+    RadixSort(messages, messages_size, offset);
+  }
+
+  for (ll i = 0; i < messages_size; ++i) {
+    std::cout << messages[i] << '\n';
+  }
+  return 0;
+}

3/D.cpp

@@ -0,0 +1,85 @@
+#include <iostream>
+
+struct Node {
+  Node* next;
+  Node* prev;
+  int weight;
+};
+
+class Backpack {
+ private:
+  Node* first = nullptr;
+  Node* last = nullptr;
+  int count = 0;
+ public:
+  void Add(int weight) {
+    Node* new_node = new Node {nullptr, last, weight};
+    if (count == 0) {
+      first = new_node;
+      last = new_node;
+    } else {
+      last->next = new_node;
+      last = new_node;
+    }
+    ++count;
+  }
+  int PopFirst() {
+    if (count != 0) {
+      Node* prev = first;
+      int weight = first->weight;
+      first = first->next;
+      --count;
+      delete prev;
+      return weight;
+    }
+  }
+
+  int PopLast() {
+    if (count != 0) {
+      Node* prev = last;
+      int weight = last->weight;
+      last = last->prev;
+      --count;
+      delete prev;
+      return weight;
+    }
+  }
+};
+
+int main() {
+  int n, max_count;
+  std::cin >> n >> max_count;
+  Backpack bp;
+
+  if (n <= max_count) {
+    int x;
+    while (std::cin >> x) {
+      std::cout << x << ' ';
+    }
+    return 0;
+  }
+
+  for (int i = 0; i < n; ++i) {
+    int x;
+    std::cin >> x;
+
+    if (i >= max_count) {
+      int y = bp.PopLast();
+      int z = bp.PopFirst();
+      if (x < y)
+        std::swap(x, y);
+      if (y < z)
+        std::swap(y, z);
+      if (x < y)
+        std::swap(x, y);
+      bp.Add(y);
+    }
+    bp.Add(x);
+  }
+
+  for (int i = 0; i < max_count; ++i) {
+    std::cout << bp.PopFirst() << ' ';
+  }
+
+  return 0;
+}

3/E.cpp

@@ -0,0 +1,42 @@
+#include <iostream>
+
+struct Node {
+  Node* next;
+  int message;
+};
+
+class Stack {
+ private:
+  Node* first = nullptr;
+
+ public:
+  void Add(int message) {
+    Node* new_node = new Node{first, message};
+    first = new_node;
+  };
+
+  int Poop() {
+    Node* last = first;
+    int return_value = last->message;
+    first = last->next;
+    delete last;
+    return return_value;
+  }
+};
+
+int main() {
+  char* formula = new char[10000];
+  int idx = 0;
+
+  while ((formula[idx] = static_cast<char>(std::cin.get()))) {
+    if (formula[idx] == '\n')
+      break;
+    ++idx;
+  }
+
+  for (int i = 0; i < idx; ++i) {
+    std::cout << formula[i];
+  }
+
+  return 0;
+}

3/F.cpp

@@ -0,0 +1,71 @@
+#include <iostream>
+
+struct Node {
+  Node* next;
+  int value;
+  int idx;
+};
+
+class Stack {
+ private:
+  Node* first = nullptr;
+  int size = 0;
+
+ public:
+  void Add(int message, int idx) {
+    Node* new_node = new Node{first, message, idx};
+    first = new_node;
+    ++size;
+  };
+
+  int Pop() {
+    Node* last = first;
+    int return_value = last->value;
+    first = last->next;
+    delete last;
+    --size;
+    return return_value;
+  }
+
+  int Get() {
+    return first->value;
+  }
+
+  int GetIdx() {
+    return first->idx;
+  }
+
+  int GetSize() {
+    return size;
+  }
+};
+
+int main() {
+  int n;
+  std::cin >> n;
+  Stack stack;
+  int* tasks = new int[n];
+
+  for (int i = 0; i < n; ++i) {
+    int diff;
+    std::cin >> diff;
+
+    while (stack.GetSize() != 0 && stack.Get() < diff) {
+      tasks[stack.GetIdx()] = i - stack.GetIdx();
+      stack.Pop();
+    }
+    stack.Add(diff, i);
+
+  }
+
+  while (stack.GetSize() != 0) {
+    tasks[stack.GetIdx()] = -1;
+    stack.Pop();
+  }
+
+  for (int i = 0; i < n; ++i) {
+    std::cout << tasks[i] << ' ';
+  }
+
+  return 0;
+}

3/G.cpp

@@ -0,0 +1,54 @@
+#include <iostream>
+
+class BinarySearch {
+ private:
+  int n;
+  int k;
+  int* arr;
+
+  bool IsValid(int target) {
+    int chairs = 1;
+    int last_chair = arr[0];
+    for (int i = 0; i < n; ++i) {
+      if (arr[i] - last_chair >= target) {
+        ++chairs;
+        last_chair = arr[i];
+      }
+    }
+    return chairs >= k;
+  }
+
+ public:
+  BinarySearch(int n, int k, int* arr) : n(n), k(k), arr(arr) { }
+
+  int Search() {
+    int left = 0;
+    int right = arr[n - 1] - arr[0] + 1;
+    while (right - left > 1) {
+      int mid = (left + right) / 2;
+      if (IsValid(mid))
+        left = mid;
+      else
+        right = mid;
+    }
+    return left;
+  }
+
+};
+
+int main() {
+  int n, k;
+  std::cin >> n >> k;
+
+  int* chairs = new int[n];
+
+  for (int i = 0; i < n; ++i) {
+    std::cin >> chairs[i];
+  }
+
+  BinarySearch bs(n, k, chairs);
+
+  std::cout << bs.Search();
+
+  return 0;
+}

3/I.cpp

@@ -0,0 +1 @@
+importa