upload

2/A.cpp

@@ -0,0 +1,49 @@
+#include <iostream>
+
+void PrintArray(const int* arr, const int* size);
+void SortArray(int* arr, const int* size);
+
+
+void PrintArray(const int* arr, const int* size) {
+  for (int i = 0; i < *size; ++i) {
+    std::cout << arr[i] << " ";
+  }
+  std::cout << std::endl;
+}
+
+void SortArray(int* arr, const int* size) {
+  if (*size == 1)
+    return;
+
+  int i, j, idx;
+  idx = 0;
+  i = idx;
+  j = 1;
+
+  while (idx < *size) {
+    while (arr[i] > arr[j]) {
+      std::swap(arr[i], arr[j]);
+      if (i == 0)
+        break;
+      --j;
+      --i;
+    }
+    i = idx;
+    j = ++idx;
+  }
+}
+
+int main() {
+  int size;
+  std::cin >> size;
+
+  int* a = new int[size];
+  for (int i = 0; i < size; ++i) {
+    std::cin >> a[i];
+  }
+
+  SortArray(a, &size);
+  PrintArray(a, &size);
+
+  return 0;
+}

2/B.cpp

@@ -0,0 +1,65 @@
+#include <iostream>
+#include <cstdlib>
+#include <ctime>
+
+int Partition(int* arr, int start, int end);
+void PrintArray(int* arr, int start, int end);
+void QuickSort(int* arr, int start, int end);
+
+void PrintArray(int* arr, int start, int end) {
+  for (int i = start; i <= end; ++i) {
+    std::cout << arr[i] << " ";
+  }
+  std::cout << "\n";
+}
+
+int Partition(int* arr, int start, int end) {
+  int pivot = arr[std::rand() % (end - start + 1) + start];
+  int i = start - 1;
+  int j = end + 1;
+
+  // move pivot to the start
+  while (true) {
+    do {
+      ++i;
+    } while (arr[i] < pivot);
+
+    do {
+      --j;
+    } while (arr[j] > pivot);
+
+    if (i >= j)
+      return j;
+
+    std::swap(arr[i], arr[j]);
+  }
+}
+
+void QuickSort(int* arr, int start, int end) { // NOLINT(*-no-recursion)
+  if (start >= end)
+    return;
+
+  int pivot_idx = Partition(arr, start, end);
+
+  QuickSort(arr, start, pivot_idx);
+  QuickSort(arr, pivot_idx + 1, end);
+
+}
+
+int main() {
+  int size;
+  std::cin >> size;
+  int* a = new int[size];
+
+  for (int i = 0; i < size; ++i) {
+    std::cin >> a[i];
+  }
+
+  std::srand(std::time(nullptr));
+  QuickSort(a, 0, size - 1);
+  PrintArray(a, 0, size - 1);
+
+  delete[] a;
+
+  return 0;
+}

2/C.cpp

@@ -0,0 +1,78 @@
+#include <iostream>
+#include <cstdlib>
+#include <ctime>
+
+long long CalculateMaxSquare(long long* a, int size);
+int Partition(long long* arr, int start, int end);
+void QuickSort(long long* arr, int start, int end);
+
+int Partition(long long* arr, int start, int end) {
+  long long pivot = arr[std::rand() % (end - start + 1) + start];
+  int i = start - 1;
+  int j = end + 1;
+
+  while (true) {
+    do {
+      ++i;
+    } while (arr[i] > pivot);
+
+    do {
+      --j;
+    } while (arr[j] < pivot);
+
+    if (i >= j)
+      return j;
+
+    std::swap(arr[i], arr[j]);
+  }
+}
+
+void QuickSort(long long* arr, int start, int end) { // NOLINT(*-no-recursion)
+  if (start >= end)
+    return;
+
+  int pivot_idx = Partition(arr, start, end);
+
+  QuickSort(arr, start, pivot_idx);
+  QuickSort(arr, pivot_idx + 1, end);
+}
+
+long long CalculateMaxSquare(long long* arr, int size) {
+  long long sq_sum = 0;
+
+  long long* viable_numbers = new long long[size];
+  int viable_size = 0;
+  for (int i = 0; i < size - 1; ++i) {
+    if (std::abs(arr[i] - arr[i+1]) <= 1) {
+      viable_numbers[viable_size] = std::min(arr[i], arr[i+1]);
+      ++i;
+      ++viable_size;
+    }
+  }
+
+  QuickSort(viable_numbers, 0, viable_size - 1);
+
+  for (int i = 0; i < size - 1; i += 2) {
+    sq_sum += viable_numbers[i] * viable_numbers[i+1];
+  }
+
+  return sq_sum;
+}
+
+int main() {
+  int size;
+  std::cin >> size;
+  long long* a = new long long[size];
+
+  for (int i = 0; i < size; ++i) {
+    std::cin >> a[i];
+  }
+
+  std::srand(std::time(nullptr)); // stinky code, but i'm too lazy
+  QuickSort(a, 0, size - 1);
+
+  std::cout << CalculateMaxSquare(a, size);
+
+  delete[] a;
+  return 0;
+}

2/D.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+
+int main() {
+  int n;
+  std::cin >> n;
+  int* a = new int[n];
+
+  for (int i = 1; i <= n; ++i) {
+    a[i-1] = i;
+  }
+
+  for (int i = 2; i < n; ++i) {
+    std::swap(a[i], a[i/2]);
+  }
+
+  for (int i = 0; i < n; ++i) {
+    std::cout << a[i] << " ";
+  }
+
+  delete[] a;
+  return 0;
+}

2/D.py

@@ -0,0 +1,7 @@
+n = int(input())
+a = [*range(1, n+1)]
+
+for i in range(2, n):
+    a[i], a[i//2] = a[i//2], a[i]
+
+print(' '.join(map(str, a)))

2/E.cpp

@@ -0,0 +1,79 @@
+#include <iostream>
+
+void Merge(int* arr, int left, int mid, int right, long long& counter);
+void MergeSort(int* arr, int start, int end, long long& counter);
+
+void Merge(int* arr, int left, int mid, int right, long long& counter) {
+  int left_size = mid-left+1;
+  int right_size = right-mid;
+
+  int* left_arr = new int[left_size];
+  int* right_arr = new int[right_size];
+
+  for (int i = 0; i < left_size; ++i) {
+    left_arr[i] = arr[left + i];
+  }
+
+  for (int i = 0; i < right_size; ++i) {
+    right_arr[i] = arr[mid + 1 + i];
+  }
+
+  int i = 0, j = 0, idx = left;
+
+  while (i < left_size && j < right_size) {
+    if (left_arr[i] <= right_arr[j]) {
+      arr[idx] = left_arr[i];
+      ++i;
+    } else {
+      arr[idx] = right_arr[j];
+      ++j;
+      counter += left_size - i;
+    }
+    ++idx;
+  }
+
+  while (i < left_size) {
+    arr[idx] = left_arr[i];
+    ++i;
+    ++idx;
+  }
+
+  while (j < right_size) {
+    arr[idx] = right_arr[j];
+    ++j;
+    ++idx;
+  }
+
+  delete[] left_arr;
+  delete[] right_arr;
+}
+
+void MergeSort(int* arr, int start, int end, long long& counter) {
+  if (start >= end)
+    return;
+
+  int mid = start + (end - start) / 2;
+  MergeSort(arr, start, mid, counter);
+  MergeSort(arr, mid + 1, end, counter);
+
+  Merge(arr, start, mid, end, counter);
+}
+
+int main() {
+  int size;
+  std::cin >> size;
+  int* a = new int[size];
+
+  for (int i = 0; i < size; ++i) {
+    std::cin >> a[i];
+  }
+
+  long long counter = 0;
+
+  MergeSort(a, 0, size - 1, counter);
+
+  std::cout << counter;
+
+  delete[] a;
+  return 0;
+}

2/F.cpp

@@ -0,0 +1,121 @@
+#include <iostream>
+
+int* CalculateCriticScore(const int* critics, int** movies, int critics_count, int movie_count);
+void Merge(int* arr, int* indexes, int left, int mid, int right);
+void MergeSort(int* arr, int* indexes, int start, int end);
+
+void Merge(int* arr, int* indexes, int left, int mid, int right) {
+  int left_size = mid - left + 1;
+  int right_size = right - mid;
+
+  int* left_arr = new int[left_size];
+  int* right_arr = new int[right_size];
+
+  int* left_idxs = new int[left_size];
+  int* right_idxs = new int[right_size];
+
+  for (int i = 0; i < left_size; ++i) {
+    left_arr[i] = arr[left + i];
+    left_idxs[i] = indexes[left + i];
+  }
+
+  for (int i = 0; i < right_size; ++i) {
+    right_arr[i] = arr[mid + 1 + i];
+    right_idxs[i] = indexes[mid + 1 + i];
+  }
+
+  int i = 0, j = 0, idx = left;
+
+  while (i < left_size && j < right_size) {
+    if (left_arr[i] >= right_arr[j]) {
+      arr[idx] = left_arr[i];
+      indexes[idx] = left_idxs[i];
+      ++i;
+    } else {
+      arr[idx] = right_arr[j];
+      indexes[idx] = right_idxs[j];
+      ++j;
+    }
+    ++idx;
+  }
+
+  while (i < left_size) {
+    arr[idx] = left_arr[i];
+    indexes[idx] = left_idxs[i];
+    ++i;
+    ++idx;
+  }
+
+  while (j < right_size) {
+    arr[idx] = right_arr[j];
+    indexes[idx] = right_idxs[j];
+    ++j;
+    ++idx;
+  }
+
+  delete[] left_idxs;
+  delete[] right_idxs;
+  delete[] left_arr;
+  delete[] right_arr;
+}
+
+void MergeSort(int* arr, int* indexes, int start, int end) { // NOLINT(*-no-recursion)
+  if (start >= end)
+    return;
+
+  int mid = start + (end - start) / 2;
+  MergeSort(arr, indexes, start, mid);
+  MergeSort(arr, indexes, mid + 1, end);
+
+  Merge(arr, indexes, start, mid, end);
+}
+
+int* CalculateCriticScore(const int* critics, int** movies, int critics_count, int movie_count) {
+  int* scores = new int[movie_count];
+  int* indexes = new int[movie_count];
+  for (int i = 0; i < movie_count; ++i) {
+    scores[i] = 0;
+    indexes[i] = i + 1;
+    long long vote;
+    for (int j = 0; j < critics_count; ++j) {
+      vote = static_cast<long long>(movies[i][j]) * static_cast<long long>(critics[j]);
+      scores[i] = (static_cast<long long>(scores[i]) + vote) % 1000000007LL;
+    }
+  }
+
+  MergeSort(scores, indexes, 0, movie_count - 1);
+
+  delete[] scores;
+  return indexes;
+}
+
+int main() {
+  int critics_count, movie_count, rating_count;
+  std::cin >> critics_count >> movie_count >> rating_count;
+
+  int* critics = new int[critics_count];
+  for (int i = 0; i < critics_count; ++i) {
+    std::cin >> critics[i];
+  }
+
+  int** movies = new int* [movie_count];
+  for (int i = 0; i < movie_count; ++i) {
+    movies[i] = new int[critics_count];
+    for (int j = 0; j < critics_count; ++j) {
+      std::cin >> movies[i][j];
+    }
+  }
+
+  int* indexes = CalculateCriticScore(critics, movies, critics_count, movie_count);
+  for (int i = 0; i < rating_count; ++i) {
+    std::cout << indexes[i] << " ";
+  }
+
+  for (int i = 0; i < movie_count; ++i) {
+    delete[] movies[i];
+  }
+  delete[] movies;
+  delete[] indexes;
+
+  return 0;
+}

2/G.cpp

@@ -0,0 +1,72 @@
+#include <iostream>
+#include <functional>
+#include <cstdlib>
+#include <ctime>
+
+struct LabWork {
+  long long time_complexity;
+  long long deadline;
+};
+
+int Partition(LabWork* arr, int start, int end);
+void QuickSort(LabWork* arr, int start, int end);
+
+
+int Partition(LabWork* arr, int start, int end) {
+  int pivot = arr[rand() % (end - start + 1) + start].time_complexity; // NOLINT
+  int i = start - 1;
+  int j = end + 1;
+
+  while (true) {
+    do {
+      ++i;
+    } while (arr[i].time_complexity < pivot);
+
+    do {
+      --j;
+    } while (arr[j].time_complexity > pivot);
+
+    if (i >= j)
+      return j;
+
+    std::swap(arr[i], arr[j]);
+  }
+}
+
+void QuickSort(LabWork* arr, int start, int end) { // NOLINT(*-no-recursion)
+  if (start >= end)
+    return;
+
+  int pivot_idx = Partition(arr, start, end);
+
+  QuickSort(arr, start, pivot_idx);
+  QuickSort(arr, pivot_idx + 1, end);
+}
+
+int main() {
+  size_t size;
+  std::cin >> size;
+  LabWork* labs = new LabWork[size]; // NOLINT[*-auto]
+  for (long long i = 0; i < size; ++i) {
+    std::cin >> labs[i].time_complexity >> labs[i].deadline;
+  }
+
+  if (size < 1) {
+    std::cout << 0;
+    return 0;
+  }
+
+  std::srand(std::time(nullptr));
+  QuickSort(labs, 0, size - 1);
+
+  long long date = 0;
+  long long sum = 0;
+  for (long long i = 0; i < size; ++i) {
+    LabWork lab = labs[i];
+    date += labs[i].time_complexity;
+    sum += lab.deadline - date;
+  }
+
+  std::cout << sum;
+  return 0;
+}

2/G.py

@@ -0,0 +1,37 @@
+import itertools
+
+
+def find_number(a):
+    date = 0
+    points = 0
+    for item in a:
+        date += item["time_complexity"]
+        points += item["deadline"] - date
+    return points
+
+
+def main():
+    size = int(input())
+    a = []
+
+    for _ in range(size):
+        val = input().split(' ')
+        a.append({'time_complexity': int(val[0]), 'deadline': int(val[1])})
+
+    max_number = -999999999999999999999999999999999999
+    max_perm = {}
+    for x in itertools.permutations(a):
+        number = find_number(x)
+        if number >= max_number:
+            max_number = number
+            if number not in max_perm:
+                max_perm[number] = []
+            max_perm[number].append(x)
+
+    print(max_number)
+    for x in max_perm[max_number]:
+        print(x)
+
+
+if __name__ == "__main__":
+    main()

2/H.cpp

@@ -0,0 +1,89 @@
+// СПАСИБО БОЛЬШОЕ ЧЕЛОВЕКУ С НИКОМ РИДИСКАМУЖИК ЗА ТО ЧТО ОН МНЕ В 7:36 УТРА ОБЪЯСНИЛ ВЕСЬ ЭТОТ ПИЗДЕЦ БЯТЬ Я НЕ ЗНАЮ КАК Я ЭТУ ХУЙНЮ ЗАЩИЩУ НО ПОХУЙ БЛЯТЬ У МЕНЯ БУДЕТ КРУТАЯ АСИМПТОТИКА
+
+#include <iostream>
+
+void Merge(long long* arr, int left, int mid, int right);
+void MergeSort(long long* arr, int start, int end);
+
+void Merge(long long* arr, int left, int mid, int right) {
+  int left_size = mid-left+1;
+  int right_size = right-mid;
+
+  long long* left_arr = new long long[left_size];
+  long long* right_arr = new long long[right_size];
+
+  for (int i = 0; i < left_size; ++i) {
+    left_arr[i] = arr[left + i];
+  }
+
+  for (int i = 0; i < right_size; ++i) {
+    right_arr[i] = arr[mid + 1 + i];
+  }
+
+  int i = 0, j = 0, idx = left;
+
+  while (i < left_size && j < right_size) {
+    if (left_arr[i] <= right_arr[j]) {
+      arr[idx] = left_arr[i];
+      ++i;
+    } else {
+      arr[idx] = right_arr[j];
+      ++j;
+    }
+    ++idx;
+  }
+
+  while (i < left_size) {
+    arr[idx] = left_arr[i];
+    ++i;
+    ++idx;
+  }
+
+  while (j < right_size) {
+    arr[idx] = right_arr[j];
+    ++j;
+    ++idx;
+  }
+
+  delete[] left_arr;
+  delete[] right_arr;
+}
+
+void MergeSort(long long* arr, int start, int end) {
+  if (start >= end)
+    return;
+
+  int mid = start + (end - start) / 2;
+  MergeSort(arr, start, mid);
+  MergeSort(arr, mid + 1, end);
+
+  Merge(arr, start, mid, end);
+}
+
+int main() {
+  int size;
+  std::cin >> size;
+  long long* a = new long long[size];
+
+  for (int i = 0; i < size; ++i) {
+    long long number;
+    std::cin >> number;
+    a[i] = number + i;
+  }
+
+  MergeSort(a, 0, size - 1);
+
+  for (int i = 1; i < size; ++i) {
+    if (a[i] - i < a[i-1] - (i - 1)) {
+      std::cout << ":(";
+      return 0;
+    }
+  }
+
+  for (int i = 0; i < size; ++i) {
+    std::cout << a[i] - i << " ";
+  }
+
+  delete[] a;
+  return 0;
+}

2/I.cpp

@@ -0,0 +1,69 @@
+#include <iostream>
+#include <cstdlib>
+#include <ctime>
+
+int OrderStatistic(int32_t* arr, int size, int k);
+int Partition(int32_t* arr, int start, int end);
+
+int Partition(int32_t* arr, int start, int end) {
+  int32_t pivot = arr[std::rand() % (end - start + 1) + start];
+  int i = start - 1;
+  int j = end + 1;
+
+  while (true) {
+    do {
+      ++i;
+    } while (arr[i] > pivot);
+
+    do {
+      --j;
+    } while (arr[j] < pivot);
+
+    if (i >= j)
+      return j;
+
+    std::swap(arr[i], arr[j]);
+  }
+}
+
+int OrderStatistic(int32_t* arr, int size, int k) {
+  int left = 0;
+  int right = size - 1;
+
+  while (true) {
+    int mid = Partition(arr, left, right);
+
+    if (mid == k) {
+      return arr[mid];
+    } else if (k < mid) {
+      right = mid;
+    } else {
+      left = mid + 1;
+    }
+  }
+}
+
+int main() {
+  std::srand(std::time(nullptr));
+
+  int n, k, A, B, C;
+  std::cin >> n >> k >> A >> B >> C;
+  int32_t* a = new int32_t[n];
+  std::cin >> a[0] >> a[1];
+
+  for (int i = 2; i < n; ++i) {
+    a[i] = a[i-2]*A + a[i-1]*B + C;
+  }
+
+  OrderStatistic(a, n, k - 1);
+
+  int32_t out = 0;
+  for (int i = 0; i < k; ++i) {
+    out ^= a[i];
+  }
+
+  std::cout << out;
+
+  delete[] a;
+  return 0;
+}