1
0
Fork 0
This commit is contained in:
Arthur K. 2025-05-29 19:24:43 +03:00
commit 810a9654a4
Signed by: wzray
GPG key ID: B97F30FDC4636357
50 changed files with 4450 additions and 0 deletions

49
2/A.cpp Normal file
View file

@ -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;
}

65
2/B.cpp Normal file
View file

@ -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;
}

78
2/C.cpp Normal file
View file

@ -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;
}

22
2/D.cpp Normal file
View file

@ -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;
}

7
2/D.py Normal file
View file

@ -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)))

79
2/E.cpp Normal file
View file

@ -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;
}

121
2/F.cpp Normal file
View file

@ -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;
}

72
2/G.cpp Normal file
View file

@ -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;
}

37
2/G.py Normal file
View file

@ -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()

89
2/H.cpp Normal file
View file

@ -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;
}

69
2/I.cpp Normal file
View file

@ -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;
}