first commit
This commit is contained in:
commit
e94e758736
4
.gitignore
vendored
Executable file
4
.gitignore
vendored
Executable file
@ -0,0 +1,4 @@
|
||||
.DS_Store
|
||||
|
||||
.vscode/
|
||||
Test/
|
||||
42
First term/Algorithms/1-2/1.py
Executable file
42
First term/Algorithms/1-2/1.py
Executable file
@ -0,0 +1,42 @@
|
||||
def binary_search(arr: list, item: int) -> (int, bool):
|
||||
is_found = False
|
||||
low = 0
|
||||
high = len(arr) - 1
|
||||
|
||||
while low <= high:
|
||||
mid = (low + high) // 2
|
||||
|
||||
if arr[mid] == item:
|
||||
is_found = True
|
||||
break
|
||||
|
||||
if arr[mid] > item:
|
||||
high = mid - 1
|
||||
continue
|
||||
|
||||
low = mid + 1
|
||||
|
||||
if arr[mid] < item:
|
||||
mid += 1
|
||||
|
||||
return mid, is_found
|
||||
|
||||
|
||||
def main() -> None:
|
||||
# Config
|
||||
arr = [1, 2, 3, 4, 5, 7, 8]
|
||||
item = 6
|
||||
|
||||
# Main code
|
||||
ans = binary_search(arr, item)
|
||||
|
||||
print("Index: ", ans[0])
|
||||
print("Before:", arr)
|
||||
|
||||
if not ans[1]:
|
||||
arr.insert(ans[0], item)
|
||||
print("After: ", arr)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
62
First term/Algorithms/1-2/2.py
Executable file
62
First term/Algorithms/1-2/2.py
Executable file
@ -0,0 +1,62 @@
|
||||
def binary_search(arr: list) -> int:
|
||||
low = 0
|
||||
high = len(arr) - 1
|
||||
|
||||
while low <= high:
|
||||
mid = (low + high) // 2
|
||||
|
||||
if len(arr) - 1 == mid or mid == 0:
|
||||
return mid
|
||||
|
||||
if arr[mid-1] < arr[mid] > arr[mid+1]:
|
||||
return mid
|
||||
|
||||
if arr[mid] >= arr[mid+1]:
|
||||
high = mid - 1
|
||||
continue
|
||||
|
||||
low = mid + 1
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def checkIfPeakExist(arr: list) -> bool:
|
||||
for index in range(len(arr)):
|
||||
is_exist = True
|
||||
|
||||
for first in range(index-1):
|
||||
if not arr[first] < arr[first+1]:
|
||||
is_exist = False
|
||||
|
||||
for second in range(index, len(arr)-1):
|
||||
if not arr[second] > arr[second+1]:
|
||||
is_exist = False
|
||||
|
||||
if is_exist:
|
||||
if index == 0 or index == len(arr)-1:
|
||||
return 0
|
||||
|
||||
return arr[index]
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
def main() -> None:
|
||||
# Config
|
||||
arr = [2, 3, 7, 4, 3, 2, -1, -2, -3, -4, -5, -6, -8]
|
||||
# arr = [-8, -6, -5, -4, -3, -2, -1, 2, 3, 4, 3, 2]
|
||||
# arr = [1, 2, 3, 4, 5, 4, 3, 2, 1]
|
||||
|
||||
# Main code
|
||||
if not checkIfPeakExist(arr):
|
||||
print("Не является горным списком.")
|
||||
return
|
||||
|
||||
ans = binary_search(arr)
|
||||
|
||||
print("Ответ:", arr[ans])
|
||||
print("Индекс:", ans)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
44
First term/Algorithms/1-2/3.py
Executable file
44
First term/Algorithms/1-2/3.py
Executable file
@ -0,0 +1,44 @@
|
||||
def binary_search(arr: list) -> int:
|
||||
low = 0
|
||||
high = len(arr) - 1
|
||||
|
||||
while low <= high:
|
||||
mid = (low + high) // 2
|
||||
|
||||
if arr[mid] == 0:
|
||||
break
|
||||
|
||||
if arr[mid] > 0:
|
||||
high = mid - 1
|
||||
continue
|
||||
|
||||
low = mid + 1
|
||||
|
||||
return mid
|
||||
|
||||
|
||||
def main() -> None:
|
||||
# Config
|
||||
arr = [-5, -4, -3, -2, 2, 3, 4]
|
||||
|
||||
# Main code
|
||||
if len(arr) == 0:
|
||||
print("Пустой список.")
|
||||
return
|
||||
|
||||
index = binary_search(arr)
|
||||
|
||||
neg = index
|
||||
pos = len(arr) - neg
|
||||
|
||||
if arr[index] < 0:
|
||||
neg += 1
|
||||
|
||||
if arr[index] <= 0:
|
||||
pos -= 1
|
||||
|
||||
print(neg, pos)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
41
First term/Algorithms/1-2/4.py
Executable file
41
First term/Algorithms/1-2/4.py
Executable file
@ -0,0 +1,41 @@
|
||||
def binary_search(arr: list, item: int) -> int:
|
||||
low = 0
|
||||
high = len(arr) - 1
|
||||
|
||||
while low <= high:
|
||||
mid = (low + high) // 2
|
||||
|
||||
if arr[mid] == item:
|
||||
break
|
||||
|
||||
if arr[mid] > item:
|
||||
high = mid - 1
|
||||
continue
|
||||
|
||||
low = mid + 1
|
||||
|
||||
if arr[mid] < item:
|
||||
mid += 1
|
||||
|
||||
return mid
|
||||
|
||||
|
||||
def main() -> None:
|
||||
# Config
|
||||
arr = [5, 2, 6, 1, 9, 4, 3, 2, 4, 5]
|
||||
|
||||
# Main code
|
||||
sorted_arr = [arr[-1]]
|
||||
ans = [0]
|
||||
|
||||
for num_index in range(len(arr)-2, -1, -1):
|
||||
index = binary_search(sorted_arr, arr[num_index])
|
||||
|
||||
sorted_arr.insert(index, arr[num_index])
|
||||
|
||||
ans.append(index)
|
||||
print(ans[::-1])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
12
First term/Algorithms/2-2/1.py
Executable file
12
First term/Algorithms/2-2/1.py
Executable file
@ -0,0 +1,12 @@
|
||||
def main() -> None:
|
||||
n = int(input())
|
||||
|
||||
index = 0
|
||||
while 2 ** index < n:
|
||||
index += 1
|
||||
|
||||
print(int(2 ** index == n))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
20
First term/Algorithms/2-2/2.py
Executable file
20
First term/Algorithms/2-2/2.py
Executable file
@ -0,0 +1,20 @@
|
||||
def main() -> int:
|
||||
a = int(input())
|
||||
|
||||
if a < 10:
|
||||
return a
|
||||
|
||||
numbers = []
|
||||
for divider in range(9, 1, -1):
|
||||
while a % divider == 0:
|
||||
a //= divider
|
||||
numbers.append(divider)
|
||||
|
||||
if a >= 10:
|
||||
return 0
|
||||
|
||||
return int("".join(map(str, sorted(numbers))))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
print(main())
|
||||
21
First term/Algorithms/2-2/3.py
Executable file
21
First term/Algorithms/2-2/3.py
Executable file
@ -0,0 +1,21 @@
|
||||
def main() -> None:
|
||||
n = int(input())
|
||||
|
||||
number = 1
|
||||
numbers = []
|
||||
while len(numbers) < n:
|
||||
num = number
|
||||
for divider in 2, 3, 5:
|
||||
while num % divider == 0:
|
||||
num //= divider
|
||||
|
||||
if num == 1:
|
||||
numbers.append(number)
|
||||
|
||||
number += 1
|
||||
|
||||
print(numbers[n-1])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
24
First term/Algorithms/2-2/4.py
Executable file
24
First term/Algorithms/2-2/4.py
Executable file
@ -0,0 +1,24 @@
|
||||
import heapq
|
||||
|
||||
|
||||
def main() -> None:
|
||||
# Config
|
||||
arr = [1, 2, 3, 5]
|
||||
k = 3
|
||||
|
||||
# Main code
|
||||
heap = [(arr[0]/arr[j], 0, j) for j in range(1, len(arr))]
|
||||
heapq.heapify(heap)
|
||||
|
||||
for _ in range(k):
|
||||
val, i, j = heapq.heappop(heap)
|
||||
if i < len(arr) - 1:
|
||||
heapq.heappush(heap, (arr[i+1]/arr[j], i+1, j))
|
||||
|
||||
print([arr[i], arr[j]])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
# O(k * log(n)), где n - длина массива arr
|
||||
21
First term/Algorithms/4/1.py
Executable file
21
First term/Algorithms/4/1.py
Executable file
@ -0,0 +1,21 @@
|
||||
def main() -> None:
|
||||
arr = [86, 90, 27, 29, 38, 30, 40]
|
||||
my_dict = [None] * 7
|
||||
|
||||
for num in arr:
|
||||
key = num % 7
|
||||
d = 1
|
||||
while my_dict[key] is not None:
|
||||
key += d
|
||||
|
||||
if key >= len(arr)-1:
|
||||
d = -1
|
||||
key -= 1
|
||||
|
||||
my_dict[key] = num
|
||||
|
||||
print(my_dict)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
15
First term/Algorithms/4/2.py
Executable file
15
First term/Algorithms/4/2.py
Executable file
@ -0,0 +1,15 @@
|
||||
def main(string: str) -> None:
|
||||
some_dict = {}
|
||||
for char in string:
|
||||
if some_dict.get(char) is None:
|
||||
some_dict[char] = 1
|
||||
continue
|
||||
|
||||
some_dict[char] += 1
|
||||
|
||||
for key in some_dict.keys():
|
||||
print(f"'{key}': {some_dict[key]}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main("hello world")
|
||||
19
First term/Algorithms/4/3.py
Executable file
19
First term/Algorithms/4/3.py
Executable file
@ -0,0 +1,19 @@
|
||||
def main() -> None:
|
||||
# Config
|
||||
arr = [-1, 2, 3, 4, 7]
|
||||
n = 5
|
||||
|
||||
# Main code
|
||||
some_dict = {}
|
||||
for index in range(len(arr)):
|
||||
key = n - arr[index]
|
||||
if some_dict.get(key) is not None:
|
||||
print(some_dict[key], index)
|
||||
break
|
||||
|
||||
if some_dict.get(arr[index]) is None:
|
||||
some_dict[arr[index]] = index
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
30
First term/Algorithms/4/4.py
Executable file
30
First term/Algorithms/4/4.py
Executable file
@ -0,0 +1,30 @@
|
||||
def main() -> None:
|
||||
# Config
|
||||
first_arr = [1, 2, 3, 4, 5]
|
||||
second_arr = [0, 2, 4, 6, 8]
|
||||
|
||||
# Main code
|
||||
some_dict = {}
|
||||
ans = set()
|
||||
for index in range(max(len(first_arr), len(second_arr))):
|
||||
if index < len(first_arr):
|
||||
first_number = first_arr[index]
|
||||
|
||||
if some_dict.get(first_number) is None:
|
||||
some_dict[first_number] = 1
|
||||
elif some_dict[first_number] == 2:
|
||||
ans.add(first_number)
|
||||
|
||||
if index < len(second_arr):
|
||||
second_number = second_arr[index]
|
||||
|
||||
if some_dict.get(second_number) is None:
|
||||
some_dict[second_number] = 2
|
||||
elif some_dict[second_number] == 1:
|
||||
ans.add(second_number)
|
||||
|
||||
print(list(ans))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
16
First term/Algorithms/4/5.py
Executable file
16
First term/Algorithms/4/5.py
Executable file
@ -0,0 +1,16 @@
|
||||
def main() -> None:
|
||||
# Config
|
||||
arr = ["а", "b", "с", "d", "с", "е", "f"]
|
||||
|
||||
# Main code
|
||||
some_dict = {}
|
||||
for index in range(len(arr)):
|
||||
if some_dict.get(arr[index]) is not None:
|
||||
print(arr[index])
|
||||
break
|
||||
|
||||
some_dict[arr[index]] = index
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
23
First term/Algorithms/4/6.py
Executable file
23
First term/Algorithms/4/6.py
Executable file
@ -0,0 +1,23 @@
|
||||
|
||||
def main() -> None:
|
||||
# Config
|
||||
input_string = "minimum"
|
||||
|
||||
# Main code
|
||||
some_dict = {}
|
||||
|
||||
for char in input_string:
|
||||
if some_dict.get(char) is None:
|
||||
some_dict[char] = 1
|
||||
continue
|
||||
some_dict[char] += 1
|
||||
|
||||
for char in input_string:
|
||||
if some_dict[char] == 1:
|
||||
print(char)
|
||||
break
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
BIN
First term/Algorithms/4/Алгоритмы - Рабочая тетрадь 4.pdf
Executable file
BIN
First term/Algorithms/4/Алгоритмы - Рабочая тетрадь 4.pdf
Executable file
Binary file not shown.
17
First term/Algorithms/README.md
Executable file
17
First term/Algorithms/README.md
Executable file
@ -0,0 +1,17 @@
|
||||
# Algorithms
|
||||
|
||||
[Таблица с баллами](https://docs.google.com/spreadsheets/d/135vbCsW6saNCQs6ftMX8vYrR1yVyBFGC8ENsjEpcQBc/edit#gid=0)
|
||||
|
||||
number | name | grade
|
||||
:----: | --------------------------------------------------------------------- | :---:
|
||||
1 | Метод половинного деления. Метод хорд | ✅
|
||||
1.2 | Бинарный поиск | ✅
|
||||
2 | Числовые алгоритмы | ✅
|
||||
2.2 | Работа с делением -_- | ✅
|
||||
3 | Алгоритмы длинной арифметики: сложение, вычитание, умножение, деление | ✅
|
||||
4 | Рекурсия | ✅
|
||||
5 | Алгоритмы сортировки массивов | ✅
|
||||
6 | Структуры данных (часть 1) | ✅
|
||||
extra | Структуры данных (часть 2) | ✅
|
||||
|
||||
[Back](/NKTKLN/mirea-projects)
|
||||
34
First term/Algorithms/extra/1.cpp
Executable file
34
First term/Algorithms/extra/1.cpp
Executable file
@ -0,0 +1,34 @@
|
||||
#include <ctime>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
// srand(time(0));
|
||||
int n = rand() % 50;
|
||||
int *arr = new int[n];
|
||||
|
||||
cout << "[ ";
|
||||
for (int index = 0; index < n; ++index) {
|
||||
arr[index] = rand() % 100;
|
||||
cout << arr[index] << " ";
|
||||
}
|
||||
cout << "] (" << n << ")" << endl;
|
||||
|
||||
int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
|
||||
|
||||
for (int index = 0; index < n; ++index) {
|
||||
if (arr[index] % 2 != 0) ++a;
|
||||
if (int(sqrt(arr[index])) == sqrt(arr[index]) && int(sqrt(arr[index])) % 2 == 0) ++b;
|
||||
if (arr[index] % 3 == 0 && arr[index] % 5 != 0) ++c;
|
||||
if ((2 ^ index) < arr[index] && arr[index] < tgamma(index + 1)) ++d;
|
||||
if (index + 1 < n && index - 1 >= 0 && arr[index] < (arr[index - 1] + arr[index + 1]) / 2) ++e;
|
||||
if (index % 2 == 1 && arr[index] % 2 != 0) ++f;
|
||||
}
|
||||
|
||||
cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << endl;
|
||||
|
||||
delete[] arr;
|
||||
return 0;
|
||||
}
|
||||
46
First term/Algorithms/extra/10.cpp
Executable file
46
First term/Algorithms/extra/10.cpp
Executable file
@ -0,0 +1,46 @@
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
|
||||
using namespace std;
|
||||
|
||||
void printNumbersInOrder(const string &filename) {
|
||||
ifstream inputFile(filename);
|
||||
if (!inputFile.is_open()) {
|
||||
cerr << "Unable to open the file: " << filename << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
queue<int> singleDigitQueue;
|
||||
queue<int> doubleDigitQueue;
|
||||
|
||||
int number;
|
||||
while (inputFile >> number) {
|
||||
if (number >= 10) {
|
||||
doubleDigitQueue.push(number);
|
||||
}
|
||||
else {
|
||||
singleDigitQueue.push(number);
|
||||
}
|
||||
}
|
||||
|
||||
while (!singleDigitQueue.empty()) {
|
||||
cout << singleDigitQueue.front() << " ";
|
||||
singleDigitQueue.pop();
|
||||
}
|
||||
|
||||
while (!doubleDigitQueue.empty()) {
|
||||
cout << doubleDigitQueue.front() << " ";
|
||||
doubleDigitQueue.pop();
|
||||
}
|
||||
|
||||
inputFile.close();
|
||||
}
|
||||
|
||||
int main() {
|
||||
string filename = "input.txt";
|
||||
printNumbersInOrder(filename);
|
||||
|
||||
return 0;
|
||||
}
|
||||
31
First term/Algorithms/extra/2.cpp
Executable file
31
First term/Algorithms/extra/2.cpp
Executable file
@ -0,0 +1,31 @@
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
// srand(time(0));
|
||||
int arraySize = rand() % 50;
|
||||
int *numbers = new int[arraySize];
|
||||
|
||||
cout << "[ ";
|
||||
for (int index = 0; index < arraySize; ++index) {
|
||||
numbers[index] = rand() % 100;
|
||||
cout << numbers[index] << " ";
|
||||
}
|
||||
cout << "] (" << arraySize << ")" << endl;
|
||||
|
||||
int divisibleByFiveCount = 0;
|
||||
int divisibleByFiveSum = 0;
|
||||
|
||||
for (int index = 0; index < arraySize; ++index) {
|
||||
if (numbers[index] % 5 == 0 && numbers[index] % 7 != 0) {
|
||||
divisibleByFiveSum += numbers[index];
|
||||
++divisibleByFiveCount;
|
||||
}
|
||||
}
|
||||
|
||||
cout << divisibleByFiveCount << " " << divisibleByFiveSum << endl;
|
||||
|
||||
delete[] numbers;
|
||||
return 0;
|
||||
}
|
||||
43
First term/Algorithms/extra/3.cpp
Executable file
43
First term/Algorithms/extra/3.cpp
Executable file
@ -0,0 +1,43 @@
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
srand(time(0));
|
||||
int arraySize = rand() % 50;
|
||||
int *numbers = new int[arraySize];
|
||||
|
||||
cout << "[ ";
|
||||
for (int index = 0; index < arraySize; ++index) {
|
||||
numbers[index] = rand() % 3; // 100
|
||||
cout << numbers[index] << " ";
|
||||
}
|
||||
cout << "] (" << arraySize << ")" << endl;
|
||||
|
||||
bool hasTwoConsecutiveZeros = false;
|
||||
bool hasThreeConsecutiveZeros = false;
|
||||
int consecutiveZerosCount = 0;
|
||||
|
||||
for (int index = 0; index < arraySize; ++index) {
|
||||
if (numbers[index] != 0) {
|
||||
consecutiveZerosCount = 0;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (consecutiveZerosCount == 1) {
|
||||
hasTwoConsecutiveZeros = true;
|
||||
}
|
||||
|
||||
if (consecutiveZerosCount == 2) {
|
||||
hasThreeConsecutiveZeros = true;
|
||||
break;
|
||||
}
|
||||
|
||||
++consecutiveZerosCount;
|
||||
}
|
||||
|
||||
cout << hasTwoConsecutiveZeros << " " << hasThreeConsecutiveZeros << endl;
|
||||
|
||||
delete[] numbers;
|
||||
return 0;
|
||||
}
|
||||
55
First term/Algorithms/extra/4.cpp
Executable file
55
First term/Algorithms/extra/4.cpp
Executable file
@ -0,0 +1,55 @@
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int data;
|
||||
Node *next;
|
||||
Node(int value) : data(value), next(nullptr) {}
|
||||
};
|
||||
|
||||
Node *createList(int size) {
|
||||
if (size <= 0)
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
Node *element = new Node(1);
|
||||
Node *head = element;
|
||||
for (int index = 0; index < size - 1; index++)
|
||||
{
|
||||
Node *new_node = new Node(index);
|
||||
element->next = new_node;
|
||||
element = new_node;
|
||||
}
|
||||
return head;
|
||||
}
|
||||
|
||||
void printList(Node *head) {
|
||||
Node *ptr = head;
|
||||
while (ptr)
|
||||
{
|
||||
cout << ptr->data << " -> ";
|
||||
ptr = ptr->next;
|
||||
}
|
||||
cout << "nullptr" << endl;
|
||||
}
|
||||
|
||||
int sumOfListElements(Node *head) {
|
||||
int sum = 0;
|
||||
while (head != nullptr)
|
||||
{
|
||||
sum += head->data;
|
||||
head = head->next;
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
int main() {
|
||||
srand(time(0));
|
||||
|
||||
Node *head = createList(10);
|
||||
|
||||
printList(head);
|
||||
cout << sumOfListElements(head) << endl;
|
||||
return 0;
|
||||
}
|
||||
33
First term/Algorithms/extra/5.cpp
Executable file
33
First term/Algorithms/extra/5.cpp
Executable file
@ -0,0 +1,33 @@
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
srand(time(0));
|
||||
int arraySize = rand() % 50;
|
||||
int *numbers = new int[arraySize];
|
||||
|
||||
cout << "[ ";
|
||||
for (int index = 0; index < arraySize; ++index) {
|
||||
numbers[index] = rand() % 10;
|
||||
cout << numbers[index] << " ";
|
||||
}
|
||||
cout << "] (" << arraySize << ")" << endl;
|
||||
|
||||
bool isDescending = true;
|
||||
int previousNumber = numbers[0];
|
||||
|
||||
for (int index = 0; index < arraySize; ++index) {
|
||||
if (numbers[index] >= previousNumber) {
|
||||
isDescending = false;
|
||||
break;
|
||||
}
|
||||
previousNumber = numbers[index];
|
||||
}
|
||||
|
||||
cout << isDescending << endl;
|
||||
|
||||
delete[] numbers;
|
||||
return 0;
|
||||
}
|
||||
|
||||
134
First term/Algorithms/extra/6.cpp
Executable file
134
First term/Algorithms/extra/6.cpp
Executable file
@ -0,0 +1,134 @@
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int data;
|
||||
Node* next;
|
||||
|
||||
Node(int value) : data(value), next(nullptr) {}
|
||||
};
|
||||
|
||||
Node* constructList(int size) {
|
||||
if (size <= 0) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
Node* element = new Node(rand() % 100 + 1);
|
||||
Node* head = element;
|
||||
|
||||
for (int i = 0; i < size - 1; i++) {
|
||||
Node* new_node = new Node(rand() % 100 + 1);
|
||||
element->next = new_node;
|
||||
element = new_node;
|
||||
}
|
||||
|
||||
return head;
|
||||
}
|
||||
|
||||
bool isListEmpty(Node* head) {
|
||||
return (head == nullptr);
|
||||
}
|
||||
|
||||
int countOfListElements(Node* head) {
|
||||
int count = 0;
|
||||
while (head != nullptr) {
|
||||
++count;
|
||||
head = head->next;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
void addElementToHead(Node*& head, int value) {
|
||||
Node* element = new Node(value);
|
||||
element->next = head;
|
||||
head = element;
|
||||
}
|
||||
|
||||
void addElementToLast(Node*& head, int value) {
|
||||
Node* element = new Node(value);
|
||||
Node* ptr = head;
|
||||
|
||||
while (ptr) {
|
||||
if (ptr->next == nullptr) {
|
||||
ptr->next = element;
|
||||
break;
|
||||
}
|
||||
ptr = ptr->next;
|
||||
}
|
||||
}
|
||||
|
||||
void addElementToN(Node*& head, int value, int index) {
|
||||
Node* element = new Node(value);
|
||||
Node* ptr = head;
|
||||
|
||||
while (ptr) {
|
||||
--index;
|
||||
|
||||
if (index < 0) {
|
||||
element->next = head;
|
||||
break;
|
||||
}
|
||||
|
||||
if (index == 0) {
|
||||
element->next = ptr->next;
|
||||
ptr->next = element;
|
||||
break;
|
||||
}
|
||||
|
||||
ptr = ptr->next;
|
||||
}
|
||||
}
|
||||
|
||||
void printList(Node* head) {
|
||||
Node* ptr = head;
|
||||
while (ptr) {
|
||||
cout << ptr->data << " -> ";
|
||||
ptr = ptr->next;
|
||||
}
|
||||
cout << "nullptr" << endl;
|
||||
}
|
||||
|
||||
Node* copyListExceptFirst(Node* head) {
|
||||
if (head == nullptr || head->next == nullptr) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
Node* newHead = new Node(head->next->data);
|
||||
Node* current = newHead;
|
||||
Node* original = head->next->next;
|
||||
|
||||
while (original) {
|
||||
current->next = new Node(original->data);
|
||||
current = current->next;
|
||||
original = original->next;
|
||||
}
|
||||
|
||||
return newHead;
|
||||
}
|
||||
|
||||
int main() {
|
||||
srand(time(0));
|
||||
Node* numbers = nullptr;
|
||||
|
||||
cout << isListEmpty(numbers) << endl;
|
||||
|
||||
numbers = constructList(10);
|
||||
printList(numbers);
|
||||
|
||||
addElementToHead(numbers, 1);
|
||||
printList(numbers);
|
||||
|
||||
addElementToLast(numbers, 10);
|
||||
printList(numbers);
|
||||
|
||||
addElementToN(numbers, 5, 5);
|
||||
printList(numbers);
|
||||
|
||||
Node* newList = copyListExceptFirst(numbers);
|
||||
printList(newList);
|
||||
|
||||
cout << countOfListElements(numbers) << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
203
First term/Algorithms/extra/7.cpp
Executable file
203
First term/Algorithms/extra/7.cpp
Executable file
@ -0,0 +1,203 @@
|
||||
#include <map>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int data;
|
||||
Node* next;
|
||||
|
||||
Node(int value) : data(value), next(nullptr) {}
|
||||
};
|
||||
|
||||
Node* createList(int size) {
|
||||
if (size <= 0) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
Node* element = new Node(1);
|
||||
Node* head = element;
|
||||
|
||||
for (int index = 0; index < size - 1; index++) {
|
||||
Node* new_node = new Node(index);
|
||||
element->next = new_node;
|
||||
element = new_node;
|
||||
}
|
||||
|
||||
return head;
|
||||
}
|
||||
|
||||
void printList(Node* head) {
|
||||
Node* ptr = head;
|
||||
while (ptr) {
|
||||
cout << ptr->data << " -> ";
|
||||
ptr = ptr->next;
|
||||
}
|
||||
cout << "nullptr" << endl;
|
||||
}
|
||||
|
||||
bool areListsEqual(Node* head1, Node* head2) {
|
||||
Node* ptr1 = head1;
|
||||
Node* ptr2 = head2;
|
||||
|
||||
while (ptr1 && ptr2) {
|
||||
if (ptr1->data != ptr2->data) {
|
||||
return false;
|
||||
}
|
||||
ptr1 = ptr1->next;
|
||||
ptr2 = ptr2->next;
|
||||
}
|
||||
|
||||
return ptr1 == ptr2;
|
||||
}
|
||||
|
||||
bool doAllElementsExist(Node* head1, Node* head2) {
|
||||
map<int, bool> m;
|
||||
Node* ptr = head2;
|
||||
|
||||
while (ptr) {
|
||||
m[ptr->data] = true;
|
||||
ptr = ptr->next;
|
||||
}
|
||||
|
||||
ptr = head1;
|
||||
|
||||
while (ptr) {
|
||||
if (!m[ptr->data]) {
|
||||
return false;
|
||||
}
|
||||
ptr = ptr->next;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool hasDuplicateElements(Node* head) {
|
||||
map<int, bool> m;
|
||||
Node* ptr = head;
|
||||
|
||||
while (ptr) {
|
||||
if (m[ptr->data]) {
|
||||
return true;
|
||||
}
|
||||
|
||||
m[ptr->data] = true;
|
||||
ptr = ptr->next;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void moveToLast(Node*& head) {
|
||||
Node* newHead = head->next;
|
||||
Node* ptr = head;
|
||||
|
||||
while (ptr->next != nullptr) {
|
||||
ptr = ptr->next;
|
||||
}
|
||||
|
||||
head->next = nullptr;
|
||||
ptr->next = head;
|
||||
|
||||
head = newHead;
|
||||
}
|
||||
|
||||
void moveToFirst(Node*& head) {
|
||||
Node* ptr = head;
|
||||
|
||||
while (ptr->next->next != nullptr) {
|
||||
ptr = ptr->next;
|
||||
}
|
||||
|
||||
Node* newHead = ptr->next;
|
||||
ptr->next = nullptr;
|
||||
newHead->next = head;
|
||||
|
||||
head = newHead;
|
||||
}
|
||||
|
||||
void appendList(Node*& head1, Node* head2) {
|
||||
Node* ptr = head1;
|
||||
|
||||
while (ptr->next != nullptr) {
|
||||
ptr = ptr->next;
|
||||
}
|
||||
|
||||
ptr->next = head2;
|
||||
}
|
||||
|
||||
void reverseList(Node*& head) {
|
||||
Node* newHead = nullptr;
|
||||
Node* ptr = head;
|
||||
|
||||
while (ptr) {
|
||||
Node* nextPtr = ptr->next;
|
||||
ptr->next = newHead;
|
||||
newHead = ptr;
|
||||
ptr = nextPtr;
|
||||
}
|
||||
|
||||
head = newHead;
|
||||
}
|
||||
|
||||
void keepDistinctElements(Node*& head) {
|
||||
map<int, bool> m;
|
||||
Node* newHead = nullptr;
|
||||
Node* ptr = head;
|
||||
Node* prev = nullptr;
|
||||
|
||||
while (ptr) {
|
||||
if (!m[ptr->data]) {
|
||||
m[ptr->data] = true;
|
||||
|
||||
if (!newHead) {
|
||||
newHead = ptr;
|
||||
}
|
||||
|
||||
if (prev) {
|
||||
prev->next = ptr;
|
||||
}
|
||||
|
||||
prev = ptr;
|
||||
}
|
||||
|
||||
ptr = ptr->next;
|
||||
}
|
||||
|
||||
if (prev) {
|
||||
prev->next = nullptr;
|
||||
}
|
||||
|
||||
head = newHead;
|
||||
}
|
||||
|
||||
int main() {
|
||||
srand(time(0));
|
||||
|
||||
Node* list1 = createList(10);
|
||||
Node* list2 = createList(10);
|
||||
appendList(list2, new Node(10));
|
||||
|
||||
printList(list1);
|
||||
printList(list2);
|
||||
|
||||
cout << areListsEqual(list1, list2) << endl;
|
||||
cout << doAllElementsExist(list1, list2) << endl;
|
||||
cout << hasDuplicateElements(list1) << endl;
|
||||
|
||||
moveToLast(list1);
|
||||
printList(list1);
|
||||
|
||||
moveToFirst(list1);
|
||||
printList(list1);
|
||||
|
||||
appendList(list1, list2);
|
||||
printList(list1);
|
||||
|
||||
reverseList(list1);
|
||||
printList(list1);
|
||||
|
||||
keepDistinctElements(list1);
|
||||
printList(list1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
31
First term/Algorithms/extra/8.cpp
Executable file
31
First term/Algorithms/extra/8.cpp
Executable file
@ -0,0 +1,31 @@
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
int* arr;
|
||||
int temp;
|
||||
int size = 10;
|
||||
int shift = 23;
|
||||
|
||||
arr = new int[size];
|
||||
for (int index = 0; index < size; ++ index) {
|
||||
arr[index] = index;
|
||||
cout << arr[index] << " ";
|
||||
}
|
||||
cout << endl;
|
||||
|
||||
shift %= size;
|
||||
for (int count = 0; count < shift; ++count) {
|
||||
temp = arr[9];
|
||||
for (int index = size-1; index > 0; --index)
|
||||
arr[index] = arr[index-1];
|
||||
arr[0] = temp;
|
||||
}
|
||||
|
||||
for (int index = 0; index < size; ++index)
|
||||
cout << arr[index] << " ";
|
||||
cout << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
24
First term/Algorithms/extra/9.cpp
Executable file
24
First term/Algorithms/extra/9.cpp
Executable file
@ -0,0 +1,24 @@
|
||||
#include <stack>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
stack<char> stack;
|
||||
ifstream inputFile("input.txt");
|
||||
|
||||
if (inputFile.is_open()) {
|
||||
while (inputFile) {
|
||||
stack.push(inputFile.get());
|
||||
}
|
||||
}
|
||||
stack.pop();
|
||||
|
||||
while (!stack.empty()) {
|
||||
cout << char(stack.top());
|
||||
stack.pop();
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
325
First term/Informatics/IT-1.md
Executable file
325
First term/Informatics/IT-1.md
Executable file
@ -0,0 +1,325 @@
|
||||
# Рабочая тетрадь № 1
|
||||
|
||||
## Задачи № 1
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
4 mb = 4 * 1024 * 1024 * 8 bit = 33554432 bit
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
2 gb = 2 * 1024 * 1024 * 1024 byte = 2147483648 byte
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
6291456 byte = 6291456 / 1024 / 1024 mb = 6 mb
|
||||
```
|
||||
|
||||
## Задачи № 2
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
log2(26) = 5 bit
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
log2(5) = 3 bit
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
log2(21) = 5 bit
|
||||
```
|
||||
|
||||
## Задачи № 3
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
-0.5 * log2(0.5) = 0.5
|
||||
-0.5 * log2(0.5) = 0.5
|
||||
|
||||
H = 0.5 + 0.5 = 1
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
-1/6 * log2(1/6) = 0.431
|
||||
-1/6 * log2(1/6) = 0.431
|
||||
-1/6 * log2(1/6) = 0.431
|
||||
-1/6 * log2(1/6) = 0.431
|
||||
-1/6 * log2(1/6) = 0.431
|
||||
-1/6 * log2(1/6) = 0.431
|
||||
|
||||
H = 0.431 + 0.431 + 0.431 + 0.431 + 0.431 + 0.431 = 2586
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
-0.6 * log2(0.6) = 0.442
|
||||
-0.4 * log2(0.4) = 0.529
|
||||
|
||||
H = 0.442 + 0.529 = 0.971
|
||||
```
|
||||
|
||||
## Задачи № 4
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
77
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
u
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
73 74 75 64 65 6E 74
|
||||
```
|
||||
|
||||
## Задачи № 5
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
110010010
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
101000011
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
Да
|
||||
```
|
||||
|
||||
## Задачи № 6
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
00111011
|
||||
|
||||
000 000 111 111 111 000 111 111
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
001 011 010 110 011 010 001 111
|
||||
|
||||
01011001
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
CCz oYo mdm ppS uRu tpt wee Qrr __* Rss acc iBi eee nn% Fcc jee
|
||||
|
||||
Computer_science
|
||||
```
|
||||
|
||||
## Задачи № 7
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
B 1010100
|
||||
C 0011110
|
||||
0110101
|
||||
|
||||
3
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
A 0101010
|
||||
B 1010100
|
||||
C 0011110
|
||||
|
||||
ρ(A,B)
|
||||
|
||||
A 0101010
|
||||
B 1010100
|
||||
0000001
|
||||
|
||||
6
|
||||
|
||||
ρ(A,C)
|
||||
|
||||
A 0101010
|
||||
C 0011110
|
||||
1001011
|
||||
|
||||
3
|
||||
|
||||
ρ(B,C)
|
||||
|
||||
B 1010100
|
||||
C 0011110
|
||||
0110101
|
||||
|
||||
3
|
||||
|
||||
ρ(A,B) ≤ ρ(A,C) + ρ(C,B) - Да
|
||||
ρ(A,C) ≤ ρ(A,B) + ρ(B,C) - Да
|
||||
ρ(B,C) ≤ ρ(B,A) + ρ(A,C) - Да
|
||||
|
||||
Да
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
d = min(6, 3, 3) = 3
|
||||
|
||||
3 >= 2n + 1
|
||||
|
||||
n = 1
|
||||
```
|
||||
|
||||
## Тест
|
||||
|
||||
1. 1
|
||||
2. 3
|
||||
3. 2
|
||||
4. 4
|
||||
5. 4
|
||||
6. 2
|
||||
7. 3
|
||||
8. 1
|
||||
9. 3
|
||||
10. 4
|
||||
|
||||
## Задачи № 8
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
print("Калинин Никита Викторович ЭФБО-09-23")
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
a = int(input())
|
||||
b = int(input())
|
||||
|
||||
print(a + b)
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```python
|
||||
a = float(input())
|
||||
|
||||
print(x ** 5 - 2 * x ** 3 + 1)
|
||||
```
|
||||
|
||||
## Задачи № 9
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
strange = [[], 1]
|
||||
|
||||
print(type(strange))
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
for x in 0, 1:
|
||||
for y in 0, 1:
|
||||
if (x or y) and (not(x) or y) and not(x and y):
|
||||
print(x, y)
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```python
|
||||
some_list = []
|
||||
|
||||
for i in range(4):
|
||||
some_list.append(i)
|
||||
|
||||
for i in some_list[::-1]:
|
||||
print(i)
|
||||
```
|
||||
|
||||
## Задачи № 10
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
from math import log, ceil
|
||||
|
||||
def hartly(n: int) -> float:
|
||||
return ceil(log(n, 2))
|
||||
|
||||
print(hartly(int(input())))
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
from math import log
|
||||
|
||||
def entropy(p1, p2: float) -> float:
|
||||
h1 = -1 * p1 * log(p1, 2)
|
||||
h2 = -1 * p2 * log(p2, 2)
|
||||
|
||||
return h1 + h2
|
||||
|
||||
a = float(input())
|
||||
b = float(input())
|
||||
|
||||
print(entropy(a, b))
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```python
|
||||
from math import tan, cos, sin, e, log
|
||||
|
||||
def some_func(x: float) -> float:
|
||||
return tan(cos(x) * sin(2 * x) / x * e**x) ** log(x, 7)
|
||||
|
||||
x = float(input())
|
||||
print(some_func(x))
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```python
|
||||
def parity_bit(string: str) -> str:
|
||||
if string.count("1") % 2 == 0:
|
||||
return string + "0"
|
||||
|
||||
return string + "1"
|
||||
|
||||
s = input()
|
||||
|
||||
print(parity_bit(s))
|
||||
```
|
||||
286
First term/Informatics/IT-2.md
Executable file
286
First term/Informatics/IT-2.md
Executable file
@ -0,0 +1,286 @@
|
||||
# Рабочая тетрадь № 2
|
||||
|
||||
## Задачи № 1
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
101010 bin = 1 * 2 ^ 1 + 1 * 2 ^ 3 + 1 * 2 ^ 5 = 42 dec
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
563 oct = 3 * 8 ^ 0 + 6 * 8 ^ 1 + 5 * 8 ^ 2 = 371 dec
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
A1286 двенадцатиричной = 6 * 12 ^ 0 + 8 * 12 ^ 1 + 2 * 12 ^ 2 + 1 * 12 ^ 3 + 10 * 12 ^ 4 = 209478 dec
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```math
|
||||
127 dec = 1111111 bin
|
||||
|
||||
7
|
||||
```
|
||||
|
||||
## Задачи № 2
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
367 / 7 = 52 3
|
||||
52 / 7 = 7 3
|
||||
7 / 7 = 1 0
|
||||
1 / 7 = 0 1
|
||||
|
||||
1033
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
1143 / 12 = 95 3
|
||||
95 / 12 = 7 11
|
||||
7 / 12 = 0 7
|
||||
|
||||
7B3
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```ma# Рабочая тетрадь № 2
|
||||
|
||||
## Задачи № 1
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
101010 bin = 1 * 2 ^ 1 + 1 * 2 ^ 3 + 1 * 2 ^ 5 = 42 dec
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
563 oct = 3 * 8 ^ 0 + 6 * 8 ^ 1 + 5 * 8 ^ 2 = 371 dec
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
A1286 двенадцатиричной = 6 * 12 ^ 0 + 8 * 12 ^ 1 + 2 * 12 ^ 2 + 1 * 12 ^ 3 + 10 * 12 ^ 4 = 209478 dec
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```math
|
||||
127 dec = 1111111 bin
|
||||
|
||||
7
|
||||
```th
|
||||
127 oct = 7 * 8 ^ 0 + 2 * 8 ^ 1 + 1 * 8 ^ 2 = 87 dec
|
||||
|
||||
87 / 9 = 9 6
|
||||
9 / 9 = 1 0
|
||||
1 / 9 = 0 1
|
||||
|
||||
106
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```math
|
||||
AB4 = 4 * 13 ^ 0 + 11 * 13 ^ 1 + 10 * 13 ^ 2 = 1837
|
||||
|
||||
1837 / 6 = 306 1
|
||||
306 / 6 = 51 0
|
||||
51 / 6 = 8 3
|
||||
8 / 6 = 1 2
|
||||
1 / 6 = 0 1
|
||||
|
||||
|
||||
12301
|
||||
```
|
||||
|
||||
## Задачи № 3
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
0010 1001 1101
|
||||
|
||||
29D
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
1 1 4 7 4 5 3
|
||||
|
||||
1001100111100101011
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
1 2 7
|
||||
|
||||
0000 0101 0111
|
||||
|
||||
57
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```math
|
||||
C 3 E 1
|
||||
|
||||
110000111100001
|
||||
|
||||
8
|
||||
```
|
||||
|
||||
### № 5
|
||||
|
||||
```math
|
||||
A F 3 8
|
||||
|
||||
0101 0011 1100 0110 1001
|
||||
|
||||
53C69
|
||||
|
||||
001 010 011 110 001 101 001
|
||||
|
||||
1236151
|
||||
|
||||
1010011110001101001
|
||||
```
|
||||
|
||||
## Тест № 2
|
||||
|
||||
1. A - 100101
|
||||
2. C - 26
|
||||
3. D - 11011000
|
||||
4. B - X<Z<Y
|
||||
5. C - 7
|
||||
6. A - 3
|
||||
7. C - 100000
|
||||
8. 6 9 12
|
||||
9. 5
|
||||
10. 81
|
||||
|
||||
001011101010100000001110
|
||||
001011101010100000001110
|
||||
|
||||
## Задачи № 4
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
n = int(input())
|
||||
a = input()
|
||||
|
||||
print(int(a, n))
|
||||
```
|
||||
|
||||
## Задачи № 5
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
a = int(input())
|
||||
|
||||
if a % 10 == 3 or a // 10 == 3:
|
||||
print("Входит")
|
||||
else:
|
||||
print("Не входит")
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
a = int(input())
|
||||
|
||||
if a % 10 > a // 10:
|
||||
print("Первая цифра больше")
|
||||
elif a % 10 < a // 10:
|
||||
print("Вторая цифра больше")
|
||||
else:
|
||||
print("Они одинаковые")
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```python
|
||||
a = float(input())
|
||||
b = float(input())
|
||||
c = float(input())
|
||||
|
||||
d = b ** 2 - 4 * a * c
|
||||
|
||||
if d >= 0:
|
||||
a1 = (-b + d ** 0.5) / (2 * a)
|
||||
a2 = (-b - d ** 0.5) / (2 * a)
|
||||
print(a1, a2)
|
||||
else:
|
||||
print("Корней нет")
|
||||
```
|
||||
|
||||
## Задачи № 6
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
a = int(input())
|
||||
i = 0
|
||||
while a % i != 0:
|
||||
i += 1
|
||||
|
||||
print(i)
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
a = int(input())
|
||||
i = 0
|
||||
while a != 0:
|
||||
i += a
|
||||
a -= 1
|
||||
print(i)
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```python
|
||||
a = int(input())
|
||||
|
||||
k = 0
|
||||
for i in range(2, a // 2 + 1):
|
||||
if a % i == 0:
|
||||
k += 1
|
||||
|
||||
if k <= 0:
|
||||
print("Простое")
|
||||
else:
|
||||
print("Не простое")
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```python
|
||||
a = int(input())
|
||||
n = int(input())
|
||||
|
||||
new = ""
|
||||
while a > 0:
|
||||
r = a % n
|
||||
new += str(r)
|
||||
a //= n
|
||||
|
||||
print(new[::-1])
|
||||
```
|
||||
150
First term/Informatics/IT-3.md
Executable file
150
First term/Informatics/IT-3.md
Executable file
@ -0,0 +1,150 @@
|
||||
# Рабочая тетрадь № 3
|
||||
|
||||
## Задачи № 1
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
132 dec / 2 = 66 0
|
||||
66 / 2 = 33 0
|
||||
33 / 2 = 17 1
|
||||
17 / 2 = 8 1
|
||||
8 / 2 = 4 0
|
||||
4 / 2 = 2 0
|
||||
2 / 2 = 1 0
|
||||
1 / 2 = 0 1
|
||||
|
||||
136 dec = 10001100 bin
|
||||
|
||||
0000000010001100
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
0000000000000000 bin = 0 dec
|
||||
|
||||
1111111111111111 bin = 65535 dec
|
||||
```
|
||||
|
||||
## Задачи № 2
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
12 dec = 1100 bin
|
||||
|
||||
0.0001100
|
||||
0.0001100
|
||||
0.0001100
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
35 dec = 100011 bin
|
||||
|
||||
1.00100011
|
||||
1.11011100
|
||||
1.11011101
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
1.1011100
|
||||
1.1111011
|
||||
|
||||
1111011 bin = 123 dec
|
||||
|
||||
-123
|
||||
```
|
||||
|
||||
## Задачи № 3
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
A dec = 78 B dec = 56
|
||||
|
||||
A bin = +1001110
|
||||
B bin = +0111000
|
||||
|
||||
[A]п = [A]ок = [A]дк = 0.1001110
|
||||
[B]п = [B]ок = [B]дк = 0.0111000
|
||||
|
||||
|
||||
0.1001110
|
||||
0.0111000
|
||||
---------
|
||||
0.10000110
|
||||
|
||||
10000110 bin = 134 dec
|
||||
```
|
||||
|
||||
## Тест № 3
|
||||
|
||||
1. B (прямой, обратный или дополнительный код)
|
||||
2. C (выглядит одинаково в прямом, обратном и дополнительном кодах)
|
||||
3. A (обратный код)
|
||||
4. A (из обратного кода прибавлением единицы к младшему разряду без переноса в знаковый разряд)
|
||||
5. B (прямой код)
|
||||
6. A (00001110)
|
||||
7. D (–118)
|
||||
8. B (+39)
|
||||
9. A (10111111)
|
||||
10. 10011001
|
||||
|
||||
## Задачи № 4
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
from math import *
|
||||
|
||||
def f(x, y: float) -> float:
|
||||
return log(abs(sin(x+y)))
|
||||
|
||||
x = float(input())
|
||||
y = float(input())
|
||||
|
||||
print(f(x, y))
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
from math import *
|
||||
|
||||
def (x, y: float) -> float:
|
||||
if sin(x + y) <= -0.5:
|
||||
return arctg(abs(x * y) ** (1/3) * (x * e ** y))
|
||||
|
||||
if -0.5 < sin(x + y) < 0.5:
|
||||
return 3 * log(abs(x * y), 3)
|
||||
|
||||
if sin(x + y) >= 0.5:
|
||||
return x ** 3 + y ** 1.5
|
||||
|
||||
x = float(input())
|
||||
y = float(input())
|
||||
|
||||
print(f(x, y))
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```python
|
||||
from math import *
|
||||
|
||||
def f(x: float) -> float:
|
||||
return cos(e * x) ** 3 + sin(abs(x))
|
||||
|
||||
a = float(input())
|
||||
b = float(input())
|
||||
|
||||
hx = float(input())
|
||||
|
||||
for x in range(a, b+1, hx):
|
||||
print(f(x))
|
||||
```
|
||||
127
First term/Informatics/IT-4.md
Executable file
127
First term/Informatics/IT-4.md
Executable file
@ -0,0 +1,127 @@
|
||||
# Рабочая тетрадь № 4
|
||||
|
||||
## Задачи № 1
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
AvB⇒A~B
|
||||
|
||||
a b f
|
||||
0 0 0
|
||||
1 1 1
|
||||
0 1 0
|
||||
1 0 0
|
||||
|
||||
A̅v¬(B~A)⊕B
|
||||
|
||||
a b f
|
||||
0 0 1
|
||||
1 1 1
|
||||
1 0 0
|
||||
0 1 1
|
||||
|
||||
AvB⇒C
|
||||
|
||||
a b c f
|
||||
0 0 0 1
|
||||
0 0 1 1
|
||||
0 1 1 1
|
||||
1 0 1 1
|
||||
1 1 1 1
|
||||
0 1 0 0
|
||||
1 0 0 0
|
||||
1 1 0 0
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
(4)
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
(2)
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```math
|
||||
(4)
|
||||
```
|
||||
|
||||
### № 5
|
||||
|
||||
```math
|
||||
4
|
||||
```
|
||||
|
||||
### № 6
|
||||
|
||||
```math
|
||||
1 0 0 0
|
||||
```
|
||||
|
||||
### № 7
|
||||
|
||||
```math
|
||||
C, 2
|
||||
```
|
||||
|
||||
## Тест № 3
|
||||
|
||||
1. 2 (Таблица истинности)
|
||||
2. 1 (¬А&¬В)
|
||||
3. 2 (Сергей)
|
||||
4. 1 (¬A ∨ ¬B ∨ ¬C)
|
||||
5. 4 (X ∨ Y ∨ Z)
|
||||
6. 4 (2)
|
||||
7. 3 (3)
|
||||
8. 30
|
||||
9. 10
|
||||
10. M, B
|
||||
|
||||
## Задачи № 4
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
k = int(input())
|
||||
n = int(input())
|
||||
|
||||
print(2 << k-1 + 2 << n-1)
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
n = int(input())
|
||||
|
||||
if (n > 0 and (n & (n - 1))) == 0:
|
||||
print("Yes")
|
||||
else:
|
||||
print("No")
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```python
|
||||
a = int(input())
|
||||
k = int(input())
|
||||
|
||||
print(a | (1 << k))
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```python
|
||||
n = int(input())
|
||||
k = int(input())
|
||||
|
||||
ans = n & ~((1 << k) - 1)
|
||||
|
||||
print(ans)
|
||||
print(bin(n & ~((1 << k) - 1)))
|
||||
```
|
||||
212
First term/Informatics/IT-5.md
Executable file
212
First term/Informatics/IT-5.md
Executable file
@ -0,0 +1,212 @@
|
||||
# Рабочая тетрадь № 5
|
||||
|
||||
## Задачи № 1
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
¬( ( x ∧ y ) ∨ ̅z ) ≡ ¬( z → x ) ∨ ¬( z → y )
|
||||
¬( x ∧ y ) ∧ z ≡ ¬( ̅z ∨ x ) ∨ ¬( ̅z ∨ y )
|
||||
( ̅x ∨ ̅y ) ∧ z ≡ ( z ∧ ̅x ) ∨ ( z ∧ ̅y )
|
||||
( ̅x ∨ ̅y ) ∧ z ≡ z ∧ ( ̅x ∨ ̅y )
|
||||
( ̅x ∨ ̅y ) ∧ z ≡ ( ̅x ∨ ̅y ) ∧ z
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
¬( ( x ∧ y ) ∨ ̅z) ≡ ¬( z → x ) ∨ ¬( z → y )
|
||||
|
||||
x y z f1 f2
|
||||
0 0 0 0 0
|
||||
0 0 1 1 1
|
||||
0 1 1 1 1
|
||||
0 1 0 0 0
|
||||
1 0 0 0 0
|
||||
1 0 1 1 1
|
||||
1 1 0 0 0
|
||||
1 1 1 0 0
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
F(x,y,z) = ( ̅z → x ) ↔ ( ̅x │ y )
|
||||
|
||||
x y z f
|
||||
0 0 0 0
|
||||
0 0 1 1
|
||||
0 1 1 0
|
||||
0 1 0 1
|
||||
1 0 0 1
|
||||
1 0 1 1
|
||||
1 1 0 1
|
||||
1 1 1 1
|
||||
|
||||
ДНФ: ( y ∧ ̅z ) ∨ ( ̅y ∧ z ) ∨ x
|
||||
КНФ: ( x ∨ ̅y ∨ z ) ∧ ( x ∨ y ∨ z )
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```math
|
||||
A = ( x → y ) ∧ ( x → ̅y ) ∧ x
|
||||
A = ( ̅x ∨ y ) ∧ ( ̅x ∨ ̅y ) ∧ x
|
||||
A = ( ̅x ∨ ( y ∧ ̅y ) ) ∧ x
|
||||
A = ( ̅x ∨ 0 ) ∧ x
|
||||
A = ̅x ∧ x
|
||||
A = 0
|
||||
```
|
||||
|
||||
## Задачи № 2
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
1) x ∧ y ∨ x ∧ y ∨ ̅x ∧ ̅y
|
||||
( x ∧ y ) ∨ ( ̅x ∧ ̅y )
|
||||
( x ∧ y ) ∨ ( ̅x ∧ ̅y )
|
||||
x ↔ y
|
||||
2) ( x ∨ ̅y ) ∧ ( ̅x ∨ y ) ∧ ( ̅x ∨ ̅y )
|
||||
( x ∨ ̅y ) ∧ ̅x
|
||||
( x ∧ ̅x ) ∨ ( ̅y ∧ ̅x )
|
||||
0 ∨ ¬( y ∧ x )
|
||||
y | x
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
( x1 ∨ x2 ∨ x3 ) ∧ ( ̅x1 ∨ ̅x2 ∨ x3 ) ∧ ( x1 ∨ x2 ∨ ̅x3 ) ∧ ( ̅x1 ∨ ̅x2 ∨ ̅x3 )
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
1) ( x ∨ ̅x )
|
||||
2) ( ̅x ∧ ̅y ) ∨ ( x ∧ y ) ∨ ( ̅x ∧ y ) ∨ ( x ∧ ̅y )
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```math
|
||||
1) ( x ∧ ̅x )
|
||||
2) ( ̅x ∨ ̅y ) ∧ ( x ∨ y ) ∧ ( ̅x ∨ y ) ∧ ( x ∨ ̅y )
|
||||
```
|
||||
|
||||
### № 5
|
||||
|
||||
```math
|
||||
CДНФ: ( x ∧ y ∧ z ) ∨ ( ̅x ∧ y ∧ z ) ∨ ( ̅x ∧ ̅y ∧ z )
|
||||
CКНФ: ( x ∨ y ∨ z ) ∧ ( x ∨ ̅y ∨ z ) ∧ ( ̅x ∨ y ∨ z ) ∧ ( ̅x ∨ y ∨ ̅z ) ∧ ( ̅x ∨ ̅y ∨ z )
|
||||
```
|
||||
|
||||
## Тест № 5
|
||||
|
||||
1. 4
|
||||
2. 1
|
||||
3. 1
|
||||
4. 2
|
||||
5. 1
|
||||
6. 3
|
||||
7. 4
|
||||
8. 2
|
||||
9. 2
|
||||
10. 4
|
||||
|
||||
## Задачи № 3
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
a = int(input())
|
||||
if 100 <= a < 1000 and a % 5 == 0:
|
||||
print("Является")
|
||||
else:
|
||||
print("Не является")
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
a = int(input())
|
||||
b = int(input())
|
||||
c = int(input())
|
||||
|
||||
if (a % 2) + (b % 2) + (c % 2) <= 1:
|
||||
print("2 и более")
|
||||
else:
|
||||
print("Меньше 2")
|
||||
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```python
|
||||
x, y = float(input()), float(input())
|
||||
|
||||
if (x >= 0 and x**2 + y**2 <= 1) or (y <= 1 and x >= 0 and y >= x - 1):
|
||||
print("Yes")
|
||||
else:
|
||||
print("No")
|
||||
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```python
|
||||
import math as m
|
||||
|
||||
|
||||
x, y = float(input()), float(input())
|
||||
|
||||
if (y <= m.sin(x) and 0 <= y <= 0.5 and 0 <= x <= m.pi):
|
||||
print("Yes")
|
||||
else:
|
||||
print("No")
|
||||
```
|
||||
|
||||
### № 5
|
||||
|
||||
```python
|
||||
x, y = float(input()), float(input())
|
||||
if (x <= 0 and x**2 + y**2 <= 1) or (x**2 + y**2 <= 1 and y >= x):
|
||||
print("Yes")
|
||||
else:
|
||||
print("No")
|
||||
|
||||
```
|
||||
|
||||
## Задачи № 4
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
# 3
|
||||
x, y = float(input()), float(input())
|
||||
|
||||
if (x >= 0 and x**2 + y**2 <= 1) or (y <= 1 and x >= 0 and y >=// x - 1):
|
||||
print("Yes")
|
||||
else:
|
||||
print("No")
|
||||
|
||||
# 4
|
||||
import math as m
|
||||
|
||||
|
||||
x, y = float(input()), float(input())
|
||||
|
||||
if (y <= m.sin(x) and 0 <= y <= 0.5 and 0 <= x <= m.pi):
|
||||
print("Yes")
|
||||
else:
|
||||
print("No")
|
||||
|
||||
# 5
|
||||
x, y = float(input()), float(input())
|
||||
|
||||
if (x <= 0 and x**2 + y**2 <= 1) or (x**2 + y**2 <= 1 and y >= x):
|
||||
print("Yes")
|
||||
else:
|
||||
print("No")
|
||||
|
||||
```
|
||||
92
First term/Informatics/IT-6.md
Executable file
92
First term/Informatics/IT-6.md
Executable file
@ -0,0 +1,92 @@
|
||||
# Рабочая тетрадь № 6
|
||||
|
||||
## Задачи № 3
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
word = intput()
|
||||
|
||||
if word[::-1] == word:
|
||||
print("Палиндром")
|
||||
else:
|
||||
print("Не палиндром")
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
word = intput()
|
||||
|
||||
print(word.lower())
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```python
|
||||
word = intput()
|
||||
|
||||
print(word.upper())
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```python
|
||||
word = intput()
|
||||
|
||||
for num in 0,1,2,3,4,5,6,7,8,9:
|
||||
if str(num) in word:
|
||||
print("Есть")
|
||||
break
|
||||
else:
|
||||
print("Нет")
|
||||
```
|
||||
|
||||
### № 5
|
||||
|
||||
```python
|
||||
word = intput()
|
||||
|
||||
print(" ".join(list(word)))
|
||||
```
|
||||
|
||||
### № 6
|
||||
|
||||
```python
|
||||
c = "C"
|
||||
|
||||
print(ord(c))
|
||||
```
|
||||
|
||||
## Задачи № 4
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
print(list(range(0, 101, 17)))
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
w = []
|
||||
c = []
|
||||
for _ in range(5):
|
||||
w.appen(input())
|
||||
c.append(w[-1])
|
||||
|
||||
print(w, c)
|
||||
```
|
||||
|
||||
## Задачи № 5
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
a = set([1,2,3,4])
|
||||
b = set([4,34,2,6])
|
||||
|
||||
print(a | b)
|
||||
print(a & b)
|
||||
print(a - b)
|
||||
```
|
||||
107
First term/Informatics/IT-7.md
Executable file
107
First term/Informatics/IT-7.md
Executable file
@ -0,0 +1,107 @@
|
||||
# Рабочая тетрадь № 7
|
||||
|
||||
## Задачи № 1
|
||||
|
||||
### № 1
|
||||
|
||||
```math
|
||||
А) 0, 0, 0, 5
|
||||
Б) 0, 0, 5, 0
|
||||
В) 10, 10, 20, 6
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```math
|
||||
1) s1 = 1, n = 1, n = 2, s = 1,5
|
||||
2) s1 = 1, n = 2, n = 3, s1 = 1,8
|
||||
3) 1,8 3 4 2,08
|
||||
4) 2,08 4 5 2,8
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```math
|
||||
5
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```math
|
||||
А) z = 1
|
||||
Б) z = 1,9375
|
||||
```
|
||||
|
||||
## Задачи № 2
|
||||
|
||||
### № 1
|
||||
|
||||
|
||||
|
||||
### № 2
|
||||
|
||||
|
||||
|
||||
### № 3
|
||||
|
||||
|
||||
|
||||
## Задачи № 3
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
n = 10
|
||||
b = 2
|
||||
k = a // b
|
||||
l = n % b
|
||||
print("Остаток:", k)
|
||||
print("Целая часть:", l)
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
def Sign(x):
|
||||
if x < 0:
|
||||
return -1
|
||||
elif x > 0:
|
||||
return 1
|
||||
return 0
|
||||
```
|
||||
|
||||
### № 3
|
||||
|
||||
```python
|
||||
word = str(input())
|
||||
|
||||
if word == word[::-1]:
|
||||
print("yes")
|
||||
else:
|
||||
print("no")
|
||||
```
|
||||
|
||||
### № 4
|
||||
|
||||
```python
|
||||
sec = int(input())
|
||||
|
||||
day = 86400
|
||||
hour = 3600
|
||||
minute = 60
|
||||
second = 1
|
||||
|
||||
print(sec // day, (sec % day) // hour, ((sec % day) % hour) // minute, ((sec % day) % hour) % minute, sep=':')
|
||||
```
|
||||
|
||||
### № 5
|
||||
|
||||
```python
|
||||
def fibonacci_of(n):
|
||||
if n in {0, 1}:
|
||||
return n
|
||||
return fibonacci_of(n - 1) + fibonacci_of(n - 2)
|
||||
|
||||
|
||||
print(fibonacci_of(int(input())))
|
||||
```
|
||||
73
First term/Informatics/IT-8.md
Executable file
73
First term/Informatics/IT-8.md
Executable file
@ -0,0 +1,73 @@
|
||||
# Рабочая тетрадь № 6
|
||||
|
||||
## Задачи № 1
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
def function(string: str) -> str:
|
||||
half_length = len(string) // 2
|
||||
return string[:half_length][::-1] + string[half_length:][::-1]
|
||||
|
||||
some_string = "привет"
|
||||
print(function(some_string))
|
||||
```
|
||||
|
||||
### № 2
|
||||
|
||||
```python
|
||||
def is_valid_bracket_structure(expression: str) -> bool:
|
||||
stack = []
|
||||
bracket_pairs = {')': '(', '}': '{', ']': '['}
|
||||
|
||||
for char in expression:
|
||||
if char in bracket_pairs.values():
|
||||
stack.append(char)
|
||||
elif char in bracket_pairs.keys():
|
||||
if not stack or bracket_pairs[char] != stack.pop():
|
||||
return False
|
||||
|
||||
return not stack
|
||||
|
||||
|
||||
expression = ")(, ())((), (, )))), ((())" # "(), (())(), ()(), ((()))"
|
||||
if is_valid_bracket_structure(expression):
|
||||
print("Скобочная структура правильная.")
|
||||
else:
|
||||
print("Скобочная структура неправильная.")
|
||||
```
|
||||
|
||||
## Задачи № 2
|
||||
|
||||
### № 1
|
||||
|
||||
```python
|
||||
import random
|
||||
|
||||
class Warrior:
|
||||
def __init__(self, name: str, health: int = 100):
|
||||
self.name = name
|
||||
self.health = health
|
||||
|
||||
def attack(self, enemy: Warrior):
|
||||
print(f"{self.name} атакует {enemy.name}")
|
||||
enemy.health -= 20
|
||||
print(f"У {enemy.name} осталось {enemy.health} единиц здоровья")
|
||||
|
||||
|
||||
warrior1 = Warrior("Воин 1")
|
||||
warrior2 = Warrior("Воин 2")
|
||||
|
||||
while warrior1.health > 0 and warrior2.health > 0:
|
||||
attacker = random.choice([warrior1, warrior2])
|
||||
defender = warrior2 if attacker == warrior1 else warrior1
|
||||
|
||||
attacker.attack(defender)
|
||||
|
||||
if warrior1.health <= 0:
|
||||
print(f"{warrior2.name} одержал победу!")
|
||||
elif warrior2.health <= 0:
|
||||
print(f"{warrior1.name} одержал победу!")
|
||||
else:
|
||||
print("Бой окончен в ничью.")
|
||||
```
|
||||
14
First term/Informatics/README.md
Executable file
14
First term/Informatics/README.md
Executable file
@ -0,0 +1,14 @@
|
||||
# Algorithms
|
||||
|
||||
number | name | grade
|
||||
:----: | --------------------------------------------------------------------- | :---:
|
||||
1 | Работа с размером информации | ✅
|
||||
2 | Системы счисления | ✅
|
||||
3 | Прямой, обратный, дополненный коды | ✅
|
||||
4 | Алгебра логики (часть 1) | ✅
|
||||
5 | Алгебра логики (часть 2) | ✅
|
||||
6 | Алгебра логики (python) | ✅
|
||||
7 | Машина Тьюринга | ✅
|
||||
8 | ООП | ✅
|
||||
|
||||
[Back](/NKTKLN/mirea-projects)
|
||||
BIN
First term/Informatics/src/Screenshot 2023-12-02 094710.png
Executable file
BIN
First term/Informatics/src/Screenshot 2023-12-02 094710.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 82 KiB |
BIN
First term/Informatics/src/Screenshot 2023-12-02 094736.png
Executable file
BIN
First term/Informatics/src/Screenshot 2023-12-02 094736.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 26 KiB |
BIN
First term/Informatics/src/Screenshot 2023-12-02 094750.png
Executable file
BIN
First term/Informatics/src/Screenshot 2023-12-02 094750.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 36 KiB |
26
README.md
Executable file
26
README.md
Executable file
@ -0,0 +1,26 @@
|
||||
# Mirea projects
|
||||
|
||||
***project codename:*** Lucy
|
||||
|
||||
This repository was created for saving and transferring MIREA Institute assignment solutions.
|
||||
|
||||
## First term
|
||||
|
||||
* [Algorithms](/NKTKLN/mirea-projects/src/branch/main/First%20term/Algorithms)
|
||||
* [Informatics](/NKTKLN/mirea-projects/src/branch/main/First%20term/Informatics)
|
||||
|
||||
## Second term
|
||||
|
||||
* [Algorithms](/NKTKLN/mirea-projects/src/branch/main/Second%20term/Algorithms)
|
||||
* [Discrete math](/NKTKLN/mirea-projects/src/branch/main/Second%20term/Discrete%20math)
|
||||
* [Familiarization practice](/NKTKLN/mirea-projects/src/branch/main/Second%20term/Familiarization%20practice)
|
||||
* [Industrial programming technologies](/NKTKLN/mirea-projects/src/branch/main/Second%20term/Industrial%20programming%20technologies)
|
||||
* [Term papper](/NKTKLN/mirea-projects/src/branch/main/Term%20papers/%D0%AD%D0%A4%D0%91%D0%9E-09-23%20%D0%9A%D0%B0%D0%BB%D0%B8%D0%BD%D0%B8%D0%BD%20%D0%9D%D0%B8%D0%BA%D0%B8%D1%82%D0%B0%20%D0%92%D0%B8%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2%D0%B8%D1%87%20%D0%9A%D1%83%D1%80%D1%81%D0%BE%D0%B2%D0%B0%D1%8F%20%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%20%D0%BF%D0%BE%20%D0%B8%D0%BD%D0%B4%D1%83%D1%81%D1%82%D1%80%D0%B5%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%BC%D1%83%20%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8E%20%D0%BF%D1%80%D0%BE%D0%B4%D0%B2%D0%B8%D0%BD%D1%83%D1%82%D1%8B%D0%B9%20%D1%83%D1%80%D0%BE%D0%B2%D0%B5%D0%BD%D1%8C%202%20%D1%81%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D1%80)
|
||||
|
||||
## Third term
|
||||
|
||||
* [Discrete math](/NKTKLN/mirea-projects/src/branch/main/Third%20term/Discrete%20math)
|
||||
* [Industrial programming technologies](/NKTKLN/mirea-projects/src/branch/main/Third%20term/Industrial%20programming%20technologies)
|
||||
* [Frontend and backend development](/NKTKLN/mirea-projects/src/branch/main/Third%20term/Frontend%20and%20backend%20development)
|
||||
* [Programming of corporate systems](/NKTKLN/mirea-projects/src/branch/main/Third%20term/Programming%20of%20corporate%20systems)
|
||||
* [Artificial intelligence systems and big data](/NKTKLN/mirea-projects/src/branch/main/Third%20term/Artificial%20intelligence%20systems%20and%20big%20data)
|
||||
66
Second term/Algorithms/1.1/1.cpp
Executable file
66
Second term/Algorithms/1.1/1.cpp
Executable file
@ -0,0 +1,66 @@
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int minNum;
|
||||
int maxNum;
|
||||
Node *left;
|
||||
Node *right;
|
||||
Node(int minValue, int maxValue) : minNum(minValue), maxNum(maxValue), left(nullptr), right(nullptr) {}
|
||||
};
|
||||
|
||||
Node *buildTree(int minValue, int maxValue) {
|
||||
if (minValue >= maxValue) return nullptr;
|
||||
Node *root = new Node(minValue, maxValue);
|
||||
if (maxValue - minValue > 1) {
|
||||
int middleValue = (minValue + maxValue) / 2;
|
||||
root->left = buildTree(minValue, middleValue);
|
||||
root->right = buildTree(middleValue, maxValue);
|
||||
}
|
||||
return root;
|
||||
}
|
||||
|
||||
int searchX(Node *&node, int value) {
|
||||
if(node == nullptr) return 0;
|
||||
int count = 0;
|
||||
if(node->minNum <= value && node->maxNum >= value) count++;
|
||||
return count + searchX(node->left, value) + searchX(node->right, value);
|
||||
}
|
||||
|
||||
void printTree(Node *node) {
|
||||
if (node == nullptr) return;
|
||||
printTree(node->left);
|
||||
cout << "(" << node->minNum << ", " << node->maxNum << ") ";
|
||||
printTree(node->right);
|
||||
}
|
||||
|
||||
int searchSum(Node *&node, int minValue, int maxValue) {
|
||||
if (node == nullptr || minValue >= maxValue) return 0;
|
||||
if(node->left != nullptr || node->right != nullptr) return searchSum(node->left, minValue, maxValue) + searchSum(node->right, minValue, maxValue);
|
||||
int sum = 0;
|
||||
if (node->maxNum <= maxValue && node->maxNum > minValue) sum += node->maxNum;
|
||||
if (node->minNum == minValue) sum += node->minNum;
|
||||
return sum;
|
||||
}
|
||||
|
||||
int main() {
|
||||
int a, b;
|
||||
cout << "> ";
|
||||
cin >> a;
|
||||
cout << "> ";
|
||||
cin >> b;
|
||||
Node *root = buildTree(a, b);
|
||||
printTree(root);
|
||||
cout << endl;
|
||||
cout << "> ";
|
||||
cin >> a;
|
||||
cout << "Number of elements containing the number : " << searchX(root, a) << endl;
|
||||
cout << "> ";
|
||||
cin >> a;
|
||||
cout << "> ";
|
||||
cin >> b;
|
||||
cout << "Counting the sum of elements on the segment : " << searchSum(root, a, b) << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
Binary file not shown.
BIN
Second term/Algorithms/1.1/Рабочая_тетрадь_1_1_Дерево_отрезков (2).docx
Executable file
BIN
Second term/Algorithms/1.1/Рабочая_тетрадь_1_1_Дерево_отрезков (2).docx
Executable file
Binary file not shown.
106
Second term/Algorithms/1/1.cpp
Executable file
106
Second term/Algorithms/1/1.cpp
Executable file
@ -0,0 +1,106 @@
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int key;
|
||||
int count;
|
||||
Node *left;
|
||||
Node *right;
|
||||
int height;
|
||||
Node(int value) : key(value), left(nullptr), right(nullptr), height(0), count(1) {}
|
||||
};
|
||||
|
||||
int getHeight(Node *node) {
|
||||
return (node == nullptr) ? -1 : node->height;
|
||||
}
|
||||
|
||||
void updateHeight(Node *&node) {
|
||||
node->height = max(getHeight(node->left), getHeight(node->right)) + 1;
|
||||
}
|
||||
|
||||
void insert(Node *&node, int key) {
|
||||
if (node->key > key) {
|
||||
if (node->left == nullptr) node->left = new Node(key);
|
||||
else insert(node->left, key);
|
||||
}
|
||||
else if (node->key < key) {
|
||||
if (node->right == nullptr) node->right = new Node(key);
|
||||
else insert(node->right, key);
|
||||
}
|
||||
else node->count++;
|
||||
|
||||
updateHeight(node);
|
||||
}
|
||||
|
||||
Node *search(Node *&node, int key) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->key == key) return node;
|
||||
return search((node->key > key) ? node->left : node->right, key);
|
||||
}
|
||||
|
||||
Node *getMin(Node *&node) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->left == nullptr) return node;
|
||||
return getMin(node->left);
|
||||
}
|
||||
|
||||
Node *getMax(Node *&node) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->right == nullptr) return node;
|
||||
return getMax(node->right);
|
||||
}
|
||||
|
||||
Node *deleteNode(Node *&node, int key) {
|
||||
if (node == nullptr) return nullptr;
|
||||
else if (node->key > key) node->left = deleteNode(node->left, key);
|
||||
else if (node->key < key) node->right = deleteNode(node->right, key);
|
||||
else if (node->key == key && node->count != 1) node->count--;
|
||||
else {
|
||||
if (node->left == nullptr || node->right == nullptr)
|
||||
node = (node->left == nullptr) ? node->right : node->left;
|
||||
else {
|
||||
Node *maxLeft = getMax(node->left);
|
||||
node->key = maxLeft->key;
|
||||
node->left = deleteNode(node->left, maxLeft->key);
|
||||
}
|
||||
}
|
||||
if (node != nullptr) updateHeight(node);
|
||||
return node;
|
||||
}
|
||||
|
||||
void printTree(Node *node) {
|
||||
if (node == nullptr) return;
|
||||
printTree(node->left);
|
||||
cout << node->key << " (" << node->count << ") ";
|
||||
printTree(node->right);
|
||||
}
|
||||
|
||||
Node *generateRandomTree(int countOfNodes) {
|
||||
Node *root = new Node(rand() % 100);
|
||||
for (; countOfNodes > 0; countOfNodes--) insert(root, rand() % 100);
|
||||
return root;
|
||||
}
|
||||
|
||||
int main() {
|
||||
srand(time(0));
|
||||
|
||||
Node *root = generateRandomTree(10);
|
||||
cout << "root: " << root->key << endl;
|
||||
printTree(root);
|
||||
cout << endl;
|
||||
insert(root, 9);
|
||||
cout << "root: " << root->key << endl;
|
||||
printTree(root);
|
||||
cout << endl;
|
||||
cout << "height: " << root->height + 1 << endl;
|
||||
Node *buffer = search(root, 9);
|
||||
cout << buffer << endl;
|
||||
cout << "root: " << root->key << endl;
|
||||
root = deleteNode(root, 9);
|
||||
printTree(root);
|
||||
cout << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
155
Second term/Algorithms/1/2.cpp
Executable file
155
Second term/Algorithms/1/2.cpp
Executable file
@ -0,0 +1,155 @@
|
||||
#include <ctime>
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
string name;
|
||||
vector<string> numbers;
|
||||
Node *left;
|
||||
Node *right;
|
||||
Node(string nameValue, string numberValue) {
|
||||
name = nameValue;
|
||||
numbers.push_back(numberValue);
|
||||
right = nullptr;
|
||||
left = nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
Node *insert(Node *&node, string name, string number) {
|
||||
if (node == nullptr) return new Node(name, number);
|
||||
if (node->name > name) {
|
||||
if (node->left == nullptr) node->left = new Node(name, number);
|
||||
else insert(node->left, name, number);
|
||||
}
|
||||
else if (node->name < name) {
|
||||
if (node->right == nullptr) node->right = new Node(name, number);
|
||||
else insert(node->right, name, number);
|
||||
}
|
||||
else node->numbers.push_back(number);
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
Node *search(Node *&node, string name) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->name == name) return node;
|
||||
return search((node->name > name) ? node->left : node->right, name);
|
||||
}
|
||||
|
||||
Node *getMax(Node *&node) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->right == nullptr) return node;
|
||||
return getMax(node->right);
|
||||
}
|
||||
|
||||
Node *deleteNode(Node *&node, string name) {
|
||||
if (node == nullptr) return nullptr;
|
||||
else if (node->name > name) node->left = deleteNode(node->left, name);
|
||||
else if (node->name < name) node->right = deleteNode(node->right, name);
|
||||
else {
|
||||
if (node->left == nullptr || node->right == nullptr)
|
||||
node = (node->left == nullptr) ? node->right : node->left;
|
||||
else {
|
||||
Node *maxLeft = getMax(node->left);
|
||||
node->name = maxLeft->name;
|
||||
node->left = deleteNode(node->left, maxLeft->name);
|
||||
}
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
void printTree(Node *node) {
|
||||
if (node == nullptr) return;
|
||||
printTree(node->left);
|
||||
cout << node->name << ":" << endl;
|
||||
for (vector<string>::const_iterator number = node->numbers.begin(); number != node->numbers.end(); number++)
|
||||
cout << " * " << *number << endl;
|
||||
printTree(node->right);
|
||||
}
|
||||
|
||||
int main() {
|
||||
srand(time(0));
|
||||
|
||||
Node *root = nullptr;
|
||||
|
||||
cout << "Phone book" << endl
|
||||
<< "Use 'help' to output all available commands." << endl;
|
||||
while (true) {
|
||||
string inputCommand;
|
||||
cout << "> ";
|
||||
cin >> inputCommand;
|
||||
if (inputCommand == "help")
|
||||
cout << "Commands:" << endl
|
||||
<< " * help - output all available commands" << endl
|
||||
<< " * add - add a new record" << endl
|
||||
<< " * del-person - delete person" << endl
|
||||
<< " * del-number - delete phone number from a person" << endl
|
||||
<< " * search - output phone numbers for a particular person" << endl
|
||||
<< " * list - output all names and phone numbers for each person" << endl
|
||||
<< " * exit - exit the program" << endl;
|
||||
else if (inputCommand == "add") {
|
||||
string name, phoneNumber;
|
||||
cout << "Enter the person's name: ";
|
||||
cin >> name;
|
||||
cout << "Enter the person's phone number: ";
|
||||
cin >> phoneNumber;
|
||||
root = insert(root, name, phoneNumber);
|
||||
cout << "The phone number '" << phoneNumber << "' was successfully added to the person named '" << name << "'." << endl;
|
||||
}
|
||||
else if (inputCommand == "del-person") {
|
||||
string name;
|
||||
cout << "Enter the person's name: ";
|
||||
cin >> name;
|
||||
root = deleteNode(root, name);
|
||||
cout << "Person named '" << name << "' has been deleted." << endl;
|
||||
}
|
||||
else if (inputCommand == "del-number") {
|
||||
string name;
|
||||
cout << "Enter the person's name: ";
|
||||
cin >> name;
|
||||
Node *personNode = search(root, name);
|
||||
if (personNode == nullptr) {
|
||||
cout << "Person named '" << name << "' not found." << endl;
|
||||
continue;
|
||||
}
|
||||
string phoneNumber;
|
||||
cout << "Enter the person's phone number: ";
|
||||
cin >> phoneNumber;
|
||||
vector<string>::iterator position = find(personNode->numbers.begin(), personNode->numbers.end(), phoneNumber);
|
||||
if (position == personNode->numbers.end()) {
|
||||
cout << "The phone number '" << phoneNumber << "' of a person named '" << name << "' was not found." << endl;
|
||||
continue;
|
||||
}
|
||||
personNode->numbers.erase(position);
|
||||
cout << "The phone number '" << phoneNumber << "' of a person named '" << name << "' has been deleted." << endl;
|
||||
}
|
||||
else if (inputCommand == "search") {
|
||||
string name;
|
||||
cout << "Enter the person's name: ";
|
||||
cin >> name;
|
||||
Node *personNode = search(root, name);
|
||||
if (personNode == nullptr) {
|
||||
cout << "Person named '" << name << "' not found." << endl;
|
||||
continue;
|
||||
}
|
||||
cout << "The phone numbers of a person named '" << name << "':" << endl;
|
||||
for (vector<string>::const_iterator number = personNode->numbers.begin(); number != personNode->numbers.end(); number++)
|
||||
cout << " * " << *number << endl;
|
||||
}
|
||||
else if (inputCommand == "list") {
|
||||
cout << "List of all users and their phone numbers:" << endl;
|
||||
printTree(root);
|
||||
}
|
||||
else if (inputCommand == "exit") {
|
||||
cout << "Goodbye!" << endl;
|
||||
break;
|
||||
}
|
||||
else cout << "Unknown command." << endl;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
5
Second term/Algorithms/1/Makefile
Executable file
5
Second term/Algorithms/1/Makefile
Executable file
@ -0,0 +1,5 @@
|
||||
.SILENT:
|
||||
run:
|
||||
g++ -o main "$(name).cpp"
|
||||
./main
|
||||
rm main
|
||||
BIN
Second term/Algorithms/1/Алгоритмы - Рабочая тетрадь 1.docx
Executable file
BIN
Second term/Algorithms/1/Алгоритмы - Рабочая тетрадь 1.docx
Executable file
Binary file not shown.
BIN
Second term/Algorithms/1/Алгоритмы - Рабочая тетрадь 1.pdf
Executable file
BIN
Second term/Algorithms/1/Алгоритмы - Рабочая тетрадь 1.pdf
Executable file
Binary file not shown.
65
Second term/Algorithms/2/1.cpp
Executable file
65
Second term/Algorithms/2/1.cpp
Executable file
@ -0,0 +1,65 @@
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int key;
|
||||
int count;
|
||||
Node *left;
|
||||
Node *right;
|
||||
int height;
|
||||
Node(int value) : key(value), left(nullptr), right(nullptr), height(0), count(1) {}
|
||||
};
|
||||
|
||||
int getHeight(Node *node) {
|
||||
return (node == nullptr) ? -1 : node->height;
|
||||
}
|
||||
|
||||
void updateHeight(Node *&node) {
|
||||
node->height = max(getHeight(node->left), getHeight(node->right)) + 1;
|
||||
}
|
||||
|
||||
int getBalance(Node *node) {
|
||||
return (node == nullptr) ? 0 : getHeight(node->right) - getHeight(node->left);
|
||||
}
|
||||
|
||||
void insert(Node *&node, int key) {
|
||||
if (node->key > key) {
|
||||
if (node->left == nullptr) node->left = new Node(key);
|
||||
else insert(node->left, key);
|
||||
}
|
||||
else if (node->key < key) {
|
||||
if (node->right == nullptr) node->right = new Node(key);
|
||||
else insert(node->right, key);
|
||||
}
|
||||
else node->count++;
|
||||
|
||||
updateHeight(node);
|
||||
}
|
||||
|
||||
void printTree(Node *node) {
|
||||
if (node == nullptr) return;
|
||||
printTree(node->left);
|
||||
cout << node->key << " (" << node->count << ") " << "[" << getBalance(node) << "] | ";
|
||||
printTree(node->right);
|
||||
}
|
||||
|
||||
Node *generateRandomTree(int countOfNodes) {
|
||||
Node *root = new Node(rand() % 100);
|
||||
for (; countOfNodes > 0; countOfNodes--)
|
||||
insert(root, rand() % 100);
|
||||
return root;
|
||||
}
|
||||
|
||||
int main() {
|
||||
srand(time(0));
|
||||
|
||||
cout << "[] - balance | () - count" << endl << endl;
|
||||
|
||||
Node *root = generateRandomTree(10);
|
||||
printTree(root);
|
||||
cout << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
108
Second term/Algorithms/2/2.cpp
Executable file
108
Second term/Algorithms/2/2.cpp
Executable file
@ -0,0 +1,108 @@
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int key;
|
||||
int count;
|
||||
Node *left;
|
||||
Node *right;
|
||||
int height;
|
||||
Node(int value) : key(value), left(nullptr), right(nullptr), height(0), count(1) {}
|
||||
};
|
||||
|
||||
int getHeight(Node *node) {
|
||||
return (node == nullptr) ? -1 : node->height;
|
||||
}
|
||||
|
||||
void updateHeight(Node *&node) {
|
||||
node->height = max(getHeight(node->left), getHeight(node->right)) + 1;
|
||||
}
|
||||
|
||||
int getBalance(Node *node) {
|
||||
return (node == nullptr) ? 0 : getHeight(node->right) - getHeight(node->left);
|
||||
}
|
||||
|
||||
void swap(Node *&first, Node *&second) {
|
||||
int firstKey = first->key;
|
||||
first->key = second->key;
|
||||
second->key = firstKey;
|
||||
}
|
||||
|
||||
void rightRotate(Node *&node) {
|
||||
swap(node, node->left);
|
||||
Node *buffer = node->right;
|
||||
node->right = node->left;
|
||||
node->left = node->right->left;
|
||||
node->right->left = node->right->right;
|
||||
node->right->right = buffer;
|
||||
updateHeight(node->right);
|
||||
updateHeight(node);
|
||||
}
|
||||
|
||||
void leftRotate(Node *&node) {
|
||||
swap(node, node->right);
|
||||
Node *buffer = node->left;
|
||||
node->left = node->right;
|
||||
node->right = node->left->right;
|
||||
node->left->right = node->left->left;
|
||||
node->left->left = buffer;
|
||||
updateHeight(node->left);
|
||||
updateHeight(node);
|
||||
}
|
||||
|
||||
void balanceTree(Node *&node) {
|
||||
int balance = getBalance(node);
|
||||
if (balance == -2) {
|
||||
if (getBalance(node->left) == 1) leftRotate(node->left);
|
||||
rightRotate(node);
|
||||
}
|
||||
else if (balance == 2) {
|
||||
if (getBalance(node->right) == -1) rightRotate(node->right);
|
||||
leftRotate(node);
|
||||
}
|
||||
}
|
||||
|
||||
void insert(Node *&node, int key) {
|
||||
if (node->key > key) {
|
||||
if (node->left == nullptr) node->left = new Node(key);
|
||||
else insert(node->left, key);
|
||||
}
|
||||
else if (node->key < key) {
|
||||
if (node->right == nullptr) node->right = new Node(key);
|
||||
else insert(node->right, key);
|
||||
}
|
||||
else node->count++;
|
||||
|
||||
updateHeight(node);
|
||||
balanceTree(node);
|
||||
}
|
||||
|
||||
void printTree(Node *node) {
|
||||
if (node == nullptr) return;
|
||||
printTree(node->left);
|
||||
cout << node->key << " (" << node->count << ") " << "[" << getBalance(node) << "] | ";
|
||||
printTree(node->right);
|
||||
}
|
||||
|
||||
Node *generateRandomTree(int countOfNodes) {
|
||||
Node *root = new Node(rand() % 100);
|
||||
for (; countOfNodes > 0; countOfNodes--)
|
||||
insert(root, rand() % 100);
|
||||
return root;
|
||||
}
|
||||
|
||||
int main() {
|
||||
srand(time(0));
|
||||
|
||||
cout << "[] - balance | () - count" << endl << endl;
|
||||
|
||||
Node *root = generateRandomTree(10);
|
||||
printTree(root);
|
||||
cout << endl;
|
||||
cout << "root height: " << root->height << endl;
|
||||
cout << "root key: " << root->key << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
151
Second term/Algorithms/2/3.cpp
Executable file
151
Second term/Algorithms/2/3.cpp
Executable file
@ -0,0 +1,151 @@
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int key;
|
||||
int count;
|
||||
Node *left;
|
||||
Node *right;
|
||||
int height;
|
||||
Node(int value) : key(value), left(nullptr), right(nullptr), height(0), count(1) {}
|
||||
};
|
||||
|
||||
int getHeight(Node *node) {
|
||||
return (node == nullptr) ? -1 : node->height;
|
||||
}
|
||||
|
||||
void updateHeight(Node *&node) {
|
||||
node->height = max(getHeight(node->left), getHeight(node->right)) + 1;
|
||||
}
|
||||
|
||||
int getBalance(Node *node) {
|
||||
return (node == nullptr) ? 0 : getHeight(node->right) - getHeight(node->left);
|
||||
}
|
||||
|
||||
void swap(Node *&first, Node *&second) {
|
||||
int firstKey = first->key;
|
||||
first->key = second->key;
|
||||
second->key = firstKey;
|
||||
}
|
||||
|
||||
void rightRotate(Node *&node) {
|
||||
swap(node, node->left);
|
||||
Node *buffer = node->right;
|
||||
node->right = node->left;
|
||||
node->left = node->right->left;
|
||||
node->right->left = node->right->right;
|
||||
node->right->right = buffer;
|
||||
updateHeight(node->right);
|
||||
updateHeight(node);
|
||||
}
|
||||
|
||||
void leftRotate(Node *&node) {
|
||||
swap(node, node->right);
|
||||
Node *buffer = node->left;
|
||||
node->left = node->right;
|
||||
node->right = node->left->right;
|
||||
node->left->right = node->left->left;
|
||||
node->left->left = buffer;
|
||||
updateHeight(node->left);
|
||||
updateHeight(node);
|
||||
}
|
||||
|
||||
void balanceTree(Node *&node) {
|
||||
int balance = getBalance(node);
|
||||
if (balance == -2) {
|
||||
if (getBalance(node->left) == 1) leftRotate(node->left);
|
||||
rightRotate(node);
|
||||
}
|
||||
else if (balance == 2) {
|
||||
if (getBalance(node->right) == -1) rightRotate(node->right);
|
||||
leftRotate(node);
|
||||
}
|
||||
}
|
||||
|
||||
void insert(Node *&node, int key) {
|
||||
if (node->key > key) {
|
||||
if (node->left == nullptr) node->left = new Node(key);
|
||||
else insert(node->left, key);
|
||||
}
|
||||
else if (node->key < key) {
|
||||
if (node->right == nullptr) node->right = new Node(key);
|
||||
else insert(node->right, key);
|
||||
}
|
||||
else node->count++;
|
||||
|
||||
updateHeight(node);
|
||||
balanceTree(node);
|
||||
}
|
||||
|
||||
Node *search(Node *&node, int key) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->key == key) return node;
|
||||
return search((node->key > key) ? node->left : node->right, key);
|
||||
}
|
||||
|
||||
Node *getMin(Node *&node) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->left == nullptr) return node;
|
||||
return getMin(node->left);
|
||||
}
|
||||
|
||||
Node *getMax(Node *&node) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->right == nullptr) return node;
|
||||
return getMax(node->right);
|
||||
}
|
||||
|
||||
Node *deleteNode(Node *&node, int key) {
|
||||
if (node == nullptr) return nullptr;
|
||||
else if (node->key > key) node->left = deleteNode(node->left, key);
|
||||
else if (node->key < key) node->right = deleteNode(node->right, key);
|
||||
else {
|
||||
if (node->left == nullptr || node->right == nullptr)
|
||||
node = (node->left == nullptr) ? node->right : node->left;
|
||||
else {
|
||||
Node *maxLeft = getMax(node->left);
|
||||
node->key = maxLeft->key;
|
||||
node->left = deleteNode(node->left, maxLeft->key);
|
||||
}
|
||||
}
|
||||
if (node != nullptr) {
|
||||
updateHeight(node);
|
||||
balanceTree(node);
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
void printTree(Node *node) {
|
||||
if (node == nullptr) return;
|
||||
printTree(node->left);
|
||||
cout << node->key << " (" << node->count << ") " << "[" << getBalance(node) << "] | ";
|
||||
printTree(node->right);
|
||||
}
|
||||
|
||||
Node *generateRandomTree(int countOfNodes, int head) {
|
||||
Node *root = new Node(head);
|
||||
for (; countOfNodes > 0; countOfNodes--)
|
||||
insert(root, rand() % 100);
|
||||
return root;
|
||||
}
|
||||
|
||||
int main() {
|
||||
srand(time(0));
|
||||
|
||||
cout << "[] - balance | () - count" << endl << endl;
|
||||
|
||||
Node *root = generateRandomTree(10, 8);
|
||||
printTree(root);
|
||||
cout << endl;
|
||||
cout << "root height: " << root->height << endl;
|
||||
cout << "root key: " << root->key << endl;
|
||||
root = deleteNode(root, root->key);
|
||||
cout << "root height: " << root->height << endl;
|
||||
cout << "root key: " << root->key << endl;
|
||||
printTree(root);
|
||||
cout << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
102
Second term/Algorithms/2/4.cpp
Executable file
102
Second term/Algorithms/2/4.cpp
Executable file
@ -0,0 +1,102 @@
|
||||
#include <iostream>
|
||||
#define RED true
|
||||
#define BLACK false
|
||||
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int key;
|
||||
Node *left;
|
||||
Node *right;
|
||||
Node *parent;
|
||||
bool color;
|
||||
Node(int value) : key(value), left(nullptr), right(nullptr), color(RED) {}
|
||||
};
|
||||
|
||||
bool getColor(Node *node) {
|
||||
if (node == nullptr) return BLACK;
|
||||
return node->color;
|
||||
}
|
||||
|
||||
void setColor(Node *node, bool color) {
|
||||
if (node == nullptr) return;
|
||||
node->color = color;
|
||||
}
|
||||
|
||||
void insert(Node *&root, Node *&node, int key) {
|
||||
if (root == nullptr) {
|
||||
root = new Node(key);
|
||||
setColor(root, BLACK);
|
||||
return;
|
||||
}
|
||||
|
||||
if (node->key > key) {
|
||||
if (node->left == nullptr) {
|
||||
node->left = new Node(key);
|
||||
setColor(node->left, !getColor(node));
|
||||
}
|
||||
else insert(root, node->left, key);
|
||||
}
|
||||
else if (node->key <= key) {
|
||||
if (node->right == nullptr) {
|
||||
node->right = new Node(key);
|
||||
setColor(node->right, !getColor(node));
|
||||
}
|
||||
else insert(root, node->right, key);
|
||||
}
|
||||
|
||||
setColor(root, BLACK);
|
||||
}
|
||||
|
||||
void printTree(Node *node) {
|
||||
if (node == nullptr) return;
|
||||
printTree(node->left);
|
||||
cout << node->key << " (" << ((node->color == RED) ? "RED" : "BLACK") << ") " << endl;
|
||||
printTree(node->right);
|
||||
}
|
||||
|
||||
int blackHeight(Node* node) {
|
||||
if (node == nullptr) return 1;
|
||||
int leftHeight = blackHeight(node->left);
|
||||
int rightHeight = blackHeight(node->right);
|
||||
|
||||
if (leftHeight != rightHeight) return 0;
|
||||
if (leftHeight == 0 || rightHeight == 0) return 0;
|
||||
if (getColor(node) == BLACK) leftHeight++;
|
||||
|
||||
return leftHeight;
|
||||
}
|
||||
|
||||
void checkRedBlackTreeProperties(Node* root) {
|
||||
if (blackHeight(root) != 0)
|
||||
cout << "Correct" << endl;
|
||||
else
|
||||
cout << "Incorrect" << endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
Node *root = nullptr;
|
||||
insert(root, root, 13);
|
||||
insert(root, root, 8);
|
||||
insert(root, root, 17);
|
||||
insert(root, root, 15);
|
||||
insert(root, root, 25);
|
||||
insert(root, root, 22);
|
||||
insert(root, root, 27);
|
||||
insert(root, root, 1);
|
||||
insert(root, root, 11);
|
||||
insert(root, root, 6);
|
||||
|
||||
printTree(root);
|
||||
cout << endl;
|
||||
cout << "Checking for rules: ";
|
||||
checkRedBlackTreeProperties(root);
|
||||
|
||||
cout << "Add 7" << endl;
|
||||
|
||||
insert(root, root, 7);
|
||||
cout << "Checking for rules: ";
|
||||
checkRedBlackTreeProperties(root);
|
||||
|
||||
return 0;
|
||||
}
|
||||
319
Second term/Algorithms/2/5.cpp
Executable file
319
Second term/Algorithms/2/5.cpp
Executable file
@ -0,0 +1,319 @@
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
#define RED true
|
||||
#define BLACK false
|
||||
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int key;
|
||||
Node *left;
|
||||
Node *right;
|
||||
Node *parent;
|
||||
bool color;
|
||||
Node(int value) : key(value), left(nullptr), right(nullptr), color(RED) {}
|
||||
};
|
||||
|
||||
bool getColor(Node *node) {
|
||||
if (node == nullptr) return BLACK;
|
||||
return node->color;
|
||||
}
|
||||
|
||||
void setColor(Node *node, bool color) {
|
||||
if (node == nullptr) return;
|
||||
node->color = color;
|
||||
}
|
||||
|
||||
void rightRotate(Node *&root, Node *&node) {
|
||||
Node *leftChild = node->left;
|
||||
node->left = leftChild->right;
|
||||
|
||||
if(node->left != nullptr) node->left->parent = node;
|
||||
|
||||
leftChild->parent = node->parent;
|
||||
|
||||
if(node->parent == nullptr) root = leftChild;
|
||||
else if(node == node->parent->left) node->parent->left = leftChild;
|
||||
else node->parent->right = leftChild;
|
||||
|
||||
leftChild->right = node;
|
||||
node->parent = leftChild;
|
||||
}
|
||||
|
||||
void leftRotate(Node *&root, Node *&node) {
|
||||
Node *rightChild = node->right;
|
||||
node->right = rightChild->left;
|
||||
|
||||
if(node->right != nullptr) node->right->parent = node;
|
||||
|
||||
rightChild->parent = node->parent;
|
||||
|
||||
if(node->parent == nullptr) root = rightChild;
|
||||
else if(node == node->parent->left) node->parent->left = rightChild;
|
||||
else node->parent->right = rightChild;
|
||||
|
||||
rightChild->left = node;
|
||||
node->parent = rightChild;
|
||||
}
|
||||
|
||||
void fixRulesAfterInsertion(Node *&root, Node*& node) {
|
||||
Node* parent = nullptr;
|
||||
Node* grandParent = nullptr;
|
||||
while (node != root && getColor(node) == RED && getColor(node->parent) == RED) {
|
||||
parent = node->parent;
|
||||
grandParent = parent->parent;
|
||||
if(parent == grandParent->left) {
|
||||
Node* uncle = grandParent->right;
|
||||
if(getColor(uncle) == RED) {
|
||||
setColor(uncle, BLACK);
|
||||
setColor(parent, BLACK);
|
||||
setColor(grandParent, RED);
|
||||
node = grandParent;
|
||||
}
|
||||
else {
|
||||
if(node == parent->right) {
|
||||
leftRotate(root, parent);
|
||||
node = parent;
|
||||
parent = node->parent;
|
||||
}
|
||||
rightRotate(root, grandParent);
|
||||
const bool color = grandParent->color;
|
||||
grandParent->color = parent->color;
|
||||
parent->color = color;
|
||||
node = parent;
|
||||
}
|
||||
}
|
||||
else {
|
||||
Node* uncle = grandParent->left;
|
||||
if(getColor(uncle) == RED) {
|
||||
setColor(uncle, BLACK);
|
||||
setColor(parent, BLACK);
|
||||
setColor(grandParent, RED);
|
||||
node = grandParent;
|
||||
}
|
||||
else {
|
||||
if(node == parent->left) {
|
||||
rightRotate(root, parent);
|
||||
node = parent;
|
||||
parent = node->parent;
|
||||
}
|
||||
leftRotate(root, grandParent);
|
||||
const bool color = grandParent->color;
|
||||
grandParent->color = parent->color;
|
||||
parent->color = color;
|
||||
node = parent;
|
||||
}
|
||||
}
|
||||
}
|
||||
setColor(root, BLACK);
|
||||
}
|
||||
|
||||
void insertNode(Node *&root, Node *&node) {
|
||||
if (root == nullptr) {
|
||||
root = node;
|
||||
return;
|
||||
}
|
||||
|
||||
if (node->key < root->key) {
|
||||
insertNode(root->left, node);
|
||||
root->left->parent = root;
|
||||
}
|
||||
else if (node->key >= root->key) {
|
||||
insertNode(root->right, node);
|
||||
root->right->parent = root;
|
||||
}
|
||||
}
|
||||
|
||||
void insertNodeValue(Node *&root, const int key) {
|
||||
Node *node = new Node(key);
|
||||
insertNode(root, node);
|
||||
fixRulesAfterInsertion(root, node);
|
||||
}
|
||||
|
||||
Node *search(Node *&node, int key) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->key == key) return node;
|
||||
return search((node->key > key) ? node->left : node->right, key);
|
||||
}
|
||||
|
||||
Node *getMin(Node *&node) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->left == nullptr) return node;
|
||||
return getMin(node->left);
|
||||
}
|
||||
|
||||
Node *getMax(Node *&node) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->right == nullptr) return node;
|
||||
return getMax(node->right);
|
||||
}
|
||||
|
||||
int getChildrenCount(Node *&node) {
|
||||
int count = 0;
|
||||
if (node->left != nullptr) count++;
|
||||
if (node->right != nullptr) count++;
|
||||
return count;
|
||||
}
|
||||
|
||||
Node *getChildOrMock(Node*& node) {
|
||||
return node->left != nullptr ? node->left : node->right;
|
||||
}
|
||||
|
||||
void transplantNode(Node *&root, Node *&toNode, Node *&fromNode) {
|
||||
if (toNode == root) root = toNode;
|
||||
else if (toNode == toNode->parent->left) toNode->parent->left = fromNode;
|
||||
else toNode->parent->right = fromNode;
|
||||
fromNode->parent = toNode->parent;
|
||||
}
|
||||
|
||||
void fixRulesAfterRemoval(Node *&root, Node *&node) {
|
||||
if (node == nullptr) return;
|
||||
|
||||
if (node == root) {
|
||||
root = nullptr;
|
||||
return;
|
||||
}
|
||||
|
||||
if (getColor(node) == RED || getColor(node->left) == RED || getColor(node->right) == RED) {
|
||||
Node *child = node->left != nullptr ? node->left : node->right;
|
||||
if (node == node->parent->left) {
|
||||
node->parent->left = child;
|
||||
if (child != nullptr) child->parent = node->parent;
|
||||
setColor(child, BLACK);
|
||||
delete (node);
|
||||
} else {
|
||||
node->parent->right = child;
|
||||
if (child != nullptr) child->parent = node->parent;
|
||||
setColor(child, BLACK);
|
||||
delete (node);
|
||||
}
|
||||
} else {
|
||||
Node *sibling = nullptr;
|
||||
Node *parent = nullptr;
|
||||
Node *ptr = node;
|
||||
setColor(ptr, BLACK);
|
||||
while (ptr != root && getColor(ptr) == BLACK) {
|
||||
parent = ptr->parent;
|
||||
if (ptr == parent->left) {
|
||||
sibling = parent->right;
|
||||
if (getColor(sibling) == RED) {
|
||||
setColor(sibling, BLACK);
|
||||
setColor(parent, RED);
|
||||
leftRotate(root, parent);
|
||||
} else {
|
||||
if (getColor(sibling->left) == BLACK && getColor(sibling->right) == BLACK) {
|
||||
setColor(sibling, RED);
|
||||
if(getColor(parent) == RED) setColor(parent, BLACK);
|
||||
else setColor(parent, BLACK);
|
||||
ptr = parent;
|
||||
} else {
|
||||
if (getColor(sibling->right) == BLACK) {
|
||||
setColor(sibling->left, BLACK);
|
||||
setColor(sibling, RED);
|
||||
rightRotate(root, sibling);
|
||||
sibling = parent->right;
|
||||
}
|
||||
setColor(sibling, parent->color);
|
||||
setColor(parent, BLACK);
|
||||
setColor(sibling->right, BLACK);
|
||||
leftRotate(root, parent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
sibling = parent->left;
|
||||
if (getColor(sibling) == RED) {
|
||||
setColor(sibling, BLACK);
|
||||
setColor(parent, RED);
|
||||
rightRotate(root, parent);
|
||||
} else {
|
||||
if (getColor(sibling->left) == BLACK && getColor(sibling->right) == BLACK) {
|
||||
setColor(sibling, RED);
|
||||
if (getColor(parent) == RED) setColor(parent, BLACK);
|
||||
else setColor(parent, BLACK);
|
||||
ptr = parent;
|
||||
} else {
|
||||
if (getColor(sibling->left) == BLACK) {
|
||||
setColor(sibling->right, BLACK);
|
||||
setColor(sibling, RED);
|
||||
leftRotate(root, sibling);
|
||||
sibling = parent->left;
|
||||
}
|
||||
setColor(sibling, parent->color);
|
||||
setColor(parent, BLACK);
|
||||
setColor(sibling->left, BLACK);
|
||||
rightRotate(root, parent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (node == node->parent->left) node->parent->left = nullptr;
|
||||
else node->parent->right = nullptr;
|
||||
delete(node);
|
||||
setColor(root, BLACK);
|
||||
}
|
||||
}
|
||||
|
||||
Node *deleteNode(Node *&node, int key) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->key > key) return deleteNode(node->left, key);
|
||||
if (node->key < key) return deleteNode(node->right, key);
|
||||
if (node->left == nullptr || node->right == nullptr) return node;
|
||||
|
||||
Node *minRight = getMin(node->right);
|
||||
node->key = minRight->key;
|
||||
return deleteNode(node->right, minRight->key);
|
||||
}
|
||||
|
||||
void deleteNodeValue(Node *&root, const int key) {
|
||||
Node* node = deleteNode(root, key);
|
||||
fixRulesAfterRemoval(root, node);
|
||||
}
|
||||
|
||||
void printTree(Node *node) {
|
||||
if (node == nullptr) return;
|
||||
printTree(node->left);
|
||||
cout << node->key << " (" << ((node->color == RED) ? "RED" : "BLACK") << ")"<< endl;
|
||||
printTree(node->right);
|
||||
}
|
||||
|
||||
Node *generateRandomTree(int countOfNodes) {
|
||||
Node *root = nullptr;
|
||||
for (; countOfNodes > 0; countOfNodes--) insertNodeValue(root, rand() % 100);
|
||||
return root;
|
||||
}
|
||||
|
||||
int blackHeight(Node* node) {
|
||||
if (node == nullptr) return 1;
|
||||
int leftHeight = blackHeight(node->left);
|
||||
int rightHeight = blackHeight(node->right);
|
||||
|
||||
if (leftHeight != rightHeight) return 0;
|
||||
if (leftHeight == 0 || rightHeight == 0) return 0;
|
||||
if (getColor(node) == BLACK) leftHeight++;
|
||||
|
||||
return leftHeight;
|
||||
}
|
||||
|
||||
void checkRedBlackTreeProperties(Node* root) {
|
||||
cout << "Checking for rules: ";
|
||||
if (blackHeight(root) != 0)
|
||||
cout << "Correct" << endl;
|
||||
else
|
||||
cout << "Incorrect" << endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
srand(time(0));
|
||||
|
||||
Node *root = generateRandomTree(10);
|
||||
printTree(root);
|
||||
checkRedBlackTreeProperties(root);
|
||||
cout << "rm " << root->key << endl;
|
||||
deleteNodeValue(root, root->key);
|
||||
printTree(root);
|
||||
checkRedBlackTreeProperties(root);
|
||||
|
||||
return 0;
|
||||
}
|
||||
151
Second term/Algorithms/2/6.cpp
Executable file
151
Second term/Algorithms/2/6.cpp
Executable file
@ -0,0 +1,151 @@
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int key;
|
||||
int count;
|
||||
Node *left;
|
||||
Node *right;
|
||||
Node(int value) : key(value), left(nullptr), right(nullptr), count(1) {}
|
||||
};
|
||||
|
||||
Node *getMax(Node *&node) {
|
||||
if (node == nullptr) return nullptr;
|
||||
if (node->right == nullptr) return node;
|
||||
return getMax(node->right);
|
||||
}
|
||||
|
||||
Node *rightRotate(Node *node) {
|
||||
Node *buffer = node->left;
|
||||
node->left = buffer->right;
|
||||
buffer->right = node;
|
||||
return buffer;
|
||||
}
|
||||
|
||||
Node *leftRotate(Node *node) {
|
||||
Node *buffer = node->right;
|
||||
node->right = buffer->left;
|
||||
buffer->left = node;
|
||||
return buffer;
|
||||
}
|
||||
|
||||
void insertNode(Node *node, int key) {
|
||||
if (node->key > key) {
|
||||
if (node->left == nullptr) node->left = new Node(key);
|
||||
else insertNode(node->left, key);
|
||||
}
|
||||
else if (node->key < key) {
|
||||
if (node->right == nullptr) node->right = new Node(key);
|
||||
else insertNode(node->right, key);
|
||||
}
|
||||
else node->count++;
|
||||
}
|
||||
|
||||
Node *deleteNode(Node *&node, int key) {
|
||||
if (node == nullptr) return nullptr;
|
||||
else if (node->key > key) node->left = deleteNode(node->left, key);
|
||||
else if (node->key < key) node->right = deleteNode(node->right, key);
|
||||
else if (node->key == key && node->count != 1) node->count--;
|
||||
else {
|
||||
if (node->left == nullptr || node->right == nullptr)
|
||||
node = (node->left == nullptr) ? node->right : node->left;
|
||||
else {
|
||||
Node *maxLeft = getMax(node->left);
|
||||
node->key = maxLeft->key;
|
||||
node->left = deleteNode(node->left, maxLeft->key);
|
||||
}
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
Node *splay(Node *root, int key) {
|
||||
if (root == nullptr || root->key == key) return root;
|
||||
|
||||
if (root->key > key) {
|
||||
if (root->left == nullptr) return root;
|
||||
if (root->left->key > key) {
|
||||
root->left->left = splay(root->left->left, key);
|
||||
root = rightRotate(root);
|
||||
}
|
||||
else if (root->left->key < key) {
|
||||
root->left->right = splay(root->left->right, key);
|
||||
if (root->left->right != nullptr) root->left = leftRotate(root->left);
|
||||
}
|
||||
|
||||
return (root->left == nullptr) ? root : rightRotate(root);
|
||||
}
|
||||
|
||||
if (root->right == nullptr) return root;
|
||||
if (root->right->key > key) {
|
||||
root->right->left = splay(root->right->left, key);
|
||||
if (root->right->left != nullptr) root->right = rightRotate(root->right);
|
||||
}
|
||||
else if (root->right->key < key) {
|
||||
root->right->right = splay(root->right->right, key);
|
||||
root = leftRotate(root);
|
||||
}
|
||||
|
||||
return (root->right == nullptr) ? root : leftRotate(root);
|
||||
}
|
||||
|
||||
void searchNodeValue(Node *&root, const int key) {
|
||||
root = splay(root, key);
|
||||
}
|
||||
|
||||
void insertNodeValue(Node *&root, const int key) {
|
||||
insertNode(root, key);
|
||||
root = splay(root, key);
|
||||
}
|
||||
|
||||
void deleteNodeValue(Node *&root, const int key) {
|
||||
root = splay(deleteNode(root, key), key);
|
||||
}
|
||||
|
||||
// ============================================= //
|
||||
|
||||
int getKey(Node *&node) {
|
||||
if (node == nullptr) return -1;
|
||||
return node->key;
|
||||
}
|
||||
|
||||
void printTree(Node *&node) {
|
||||
if (node == nullptr) return;
|
||||
printTree(node->left);
|
||||
cout << node->key << " (" << node->count << ") [" << getKey(node->left)
|
||||
<< ", " << getKey(node->right) << "]" << endl;
|
||||
printTree(node->right);
|
||||
}
|
||||
|
||||
Node *generateRandomTree(int countOfNodes) {
|
||||
Node *root = new Node(rand() % 100);
|
||||
for (; countOfNodes > 0; countOfNodes--) insertNodeValue(root, rand() % 100);
|
||||
return root;
|
||||
}
|
||||
|
||||
// ============================================= //
|
||||
|
||||
int main() {
|
||||
srand(13);
|
||||
|
||||
Node *root = generateRandomTree(10);
|
||||
printTree(root);
|
||||
cout << "root: " << root->key << endl;
|
||||
|
||||
cout << endl << "Search (8)" << endl;
|
||||
searchNodeValue(root, 8);
|
||||
printTree(root);
|
||||
cout << "root: " << root->key << endl;
|
||||
|
||||
cout << endl << "Insert (73)" << endl;
|
||||
insertNodeValue(root, 73);
|
||||
printTree(root);
|
||||
cout << "root: " << root->key << endl;
|
||||
|
||||
cout << endl << "Delete (38)"<< endl;
|
||||
deleteNodeValue(root, 38);
|
||||
printTree(root);
|
||||
cout << "root: " << root->key << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
BIN
Second term/Algorithms/2/Практические занятия Алгоритмы - Рабочая тетрадь 2.pdf
Executable file
BIN
Second term/Algorithms/2/Практические занятия Алгоритмы - Рабочая тетрадь 2.pdf
Executable file
Binary file not shown.
BIN
Second term/Algorithms/2/Текущий контроль - Рабочая тетрадь 2.docx
Executable file
BIN
Second term/Algorithms/2/Текущий контроль - Рабочая тетрадь 2.docx
Executable file
Binary file not shown.
82
Second term/Algorithms/3/1.cpp
Executable file
82
Second term/Algorithms/3/1.cpp
Executable file
@ -0,0 +1,82 @@
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class Heap {
|
||||
private:
|
||||
int *data;
|
||||
int length;
|
||||
int lastIndex;
|
||||
|
||||
void swap(int firstIndex, int secondIndex);
|
||||
void heapify(int index);
|
||||
public:
|
||||
Heap(int maxHeapLength);
|
||||
Heap(int* array, int arrayLength, int maxHeapLength);
|
||||
~Heap();
|
||||
void print();
|
||||
};
|
||||
|
||||
Heap::Heap(int maxHeapLength) {
|
||||
this->data = new int[maxHeapLength];
|
||||
this->length = maxHeapLength;
|
||||
this->lastIndex = 0;
|
||||
}
|
||||
|
||||
Heap::Heap(int* array, int arrayLength, int maxHeapLength) {
|
||||
this->data = new int[maxHeapLength];
|
||||
this->length = maxHeapLength;
|
||||
this->lastIndex = arrayLength - 1;
|
||||
copy(array, array+arrayLength, this->data);
|
||||
|
||||
for (int index = this->lastIndex / 2; index >= 0; index--)
|
||||
heapify(index);
|
||||
}
|
||||
|
||||
Heap::~Heap() { delete[] this->data; }
|
||||
|
||||
void Heap::swap(int firstIndex, int secondIndex) {
|
||||
int tempElement = this->data[firstIndex];
|
||||
this->data[firstIndex] = this->data[secondIndex];
|
||||
this->data[secondIndex] = tempElement;
|
||||
}
|
||||
|
||||
void Heap::heapify(int index) {
|
||||
int largestIndex = index;
|
||||
int leftIndex = 2 * index + 1;
|
||||
int rightIndex = 2 * index + 2;
|
||||
|
||||
if (leftIndex <= this->lastIndex && this->data[leftIndex] > this->data[largestIndex])
|
||||
largestIndex = leftIndex;
|
||||
if (rightIndex <= this->lastIndex && this->data[rightIndex] > this->data[largestIndex])
|
||||
largestIndex = rightIndex;
|
||||
if (largestIndex == index)
|
||||
return;
|
||||
|
||||
swap(index, largestIndex);
|
||||
heapify(largestIndex);
|
||||
}
|
||||
|
||||
void Heap::print() {
|
||||
for (int index = 0; index <= this->lastIndex; index++)
|
||||
cout << this->data[index] << " ";
|
||||
cout << endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
int length;
|
||||
cout << "Enter array length: ";
|
||||
cin >> length;
|
||||
|
||||
int* arr = new int[length];
|
||||
cout << "Enter elements: ";
|
||||
for (int index = 0; index < length; index++)
|
||||
cin >> arr[index];
|
||||
|
||||
Heap* heap = new Heap(arr, length, 100);
|
||||
heap->print();
|
||||
|
||||
delete heap;
|
||||
|
||||
return 0;
|
||||
}
|
||||
136
Second term/Algorithms/3/2.cpp
Executable file
136
Second term/Algorithms/3/2.cpp
Executable file
@ -0,0 +1,136 @@
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class Heap {
|
||||
private:
|
||||
int *data;
|
||||
int length;
|
||||
int lastIndex;
|
||||
|
||||
void heapify(int index);
|
||||
void insertFix(int index);
|
||||
void swap(int firstIndex, int secondIndex);
|
||||
public:
|
||||
Heap(int maxHeapLength);
|
||||
Heap(int* array, int arrayLength, int maxHeapLength);
|
||||
~Heap();
|
||||
void print();
|
||||
int getMax();
|
||||
void deleteMax();
|
||||
void insert(int element);
|
||||
void merge(Heap *heap);
|
||||
};
|
||||
|
||||
Heap::Heap(int maxHeapLength) {
|
||||
this->data = new int[maxHeapLength];
|
||||
this->length = maxHeapLength;
|
||||
this->lastIndex = -1;
|
||||
}
|
||||
|
||||
Heap::Heap(int* array, int arrayLength, int maxHeapLength) {
|
||||
this->data = new int[maxHeapLength];
|
||||
this->length = maxHeapLength;
|
||||
this->lastIndex = arrayLength - 1;
|
||||
copy(array, array+arrayLength, this->data);
|
||||
|
||||
for (int index = arrayLength / 2 - 1; index >= 0; index--)
|
||||
heapify(index);
|
||||
}
|
||||
|
||||
Heap::~Heap() { delete[] this->data; }
|
||||
|
||||
void Heap::heapify(int index) {
|
||||
int largestIndex = index;
|
||||
int leftIndex = 2 * index + 1;
|
||||
int rightIndex = 2 * index + 2;
|
||||
|
||||
if (leftIndex <= this->lastIndex && this->data[leftIndex] > this->data[largestIndex])
|
||||
largestIndex = leftIndex;
|
||||
if (rightIndex <= this->lastIndex && this->data[rightIndex] > this->data[largestIndex])
|
||||
largestIndex = rightIndex;
|
||||
if (largestIndex == index)
|
||||
return;
|
||||
|
||||
swap(index, largestIndex);
|
||||
heapify(largestIndex);
|
||||
}
|
||||
|
||||
void Heap::insertFix(int index) {
|
||||
int parentIndex = (index - 1) / 2;
|
||||
if (index <= parentIndex || this->data[parentIndex] >= this->data[index])
|
||||
return;
|
||||
|
||||
swap(index, parentIndex);
|
||||
insertFix(parentIndex);
|
||||
}
|
||||
|
||||
void Heap::swap(int firstIndex, int secondIndex) {
|
||||
int tempElement = this->data[firstIndex];
|
||||
this->data[firstIndex] = this->data[secondIndex];
|
||||
this->data[secondIndex] = tempElement;
|
||||
}
|
||||
|
||||
void Heap::print() {
|
||||
for (int index = 0; index <= this->lastIndex; index++)
|
||||
cout << this->data[index] << " ";
|
||||
cout << endl;
|
||||
}
|
||||
|
||||
int Heap::getMax() {
|
||||
if (this->lastIndex == -1)
|
||||
return -1;
|
||||
return this->data[0];
|
||||
}
|
||||
|
||||
void Heap::deleteMax() {
|
||||
if (this->lastIndex == -1)
|
||||
return;
|
||||
|
||||
this->lastIndex--;
|
||||
this->data[0] = this->data[this->lastIndex+1];
|
||||
heapify(0);
|
||||
}
|
||||
|
||||
void Heap::insert(int element) {
|
||||
this->lastIndex++;
|
||||
this->data[this->lastIndex] = element;
|
||||
insertFix(this->lastIndex);
|
||||
}
|
||||
|
||||
void Heap::merge(Heap *heap) {
|
||||
copy(heap->data, heap->data+heap->lastIndex+1, this->data + this->lastIndex + 1);
|
||||
this->lastIndex += heap->lastIndex + 1;
|
||||
|
||||
for (int index = (this->lastIndex + 1) / 2 - 1; index >= 0; index--)
|
||||
heapify(index);
|
||||
}
|
||||
|
||||
int main() {
|
||||
int length = 10;
|
||||
int arr[] = {1, 3, 2, 4, 8, 7, 10, 14, 9, 16};
|
||||
int length2 = 9;
|
||||
int arr2[] = {6, 5, 11, 16, 17, 18, 20, 24, 29};
|
||||
|
||||
Heap* heap = new Heap(arr, length, 100);
|
||||
Heap* heap2 = new Heap(arr2, length2, 100);
|
||||
|
||||
heap->print();
|
||||
cout << "Max element: " << heap->getMax() << endl;
|
||||
cout << "Remove the max element." << endl;
|
||||
heap->deleteMax();
|
||||
heap->print();
|
||||
cout << "Insert element (19)." << endl;
|
||||
heap->insert(19);
|
||||
heap->print();
|
||||
cout << "Print heap №2." << endl;
|
||||
heap2->print();
|
||||
cout << "Merge heap and heap2." << endl;
|
||||
heap->merge(heap2);
|
||||
heap->print();
|
||||
|
||||
delete heap;
|
||||
delete heap2;
|
||||
|
||||
return 0;
|
||||
}
|
||||
113
Second term/Algorithms/3/3.cpp
Executable file
113
Second term/Algorithms/3/3.cpp
Executable file
@ -0,0 +1,113 @@
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class Heap {
|
||||
private:
|
||||
int *data;
|
||||
int length;
|
||||
int lastIndex;
|
||||
|
||||
void heapify(int index);
|
||||
void insertFix(int index);
|
||||
void swap(int firstIndex, int secondIndex);
|
||||
public:
|
||||
Heap(int maxHeapLength);
|
||||
Heap(int* array, int arrayLength, int maxHeapLength);
|
||||
~Heap();
|
||||
int getLength();
|
||||
int deleteMin();
|
||||
void insert(int element);
|
||||
};
|
||||
|
||||
Heap::Heap(int maxHeapLength) {
|
||||
this->data = new int[maxHeapLength];
|
||||
this->length = maxHeapLength;
|
||||
this->lastIndex = -1;
|
||||
}
|
||||
|
||||
Heap::Heap(int* array, int arrayLength, int maxHeapLength) {
|
||||
this->data = new int[maxHeapLength];
|
||||
this->length = maxHeapLength;
|
||||
this->lastIndex = arrayLength - 1;
|
||||
copy(array, array+arrayLength, this->data);
|
||||
|
||||
for (int index = arrayLength / 2 - 1; index >= 0; index--)
|
||||
heapify(index);
|
||||
}
|
||||
|
||||
Heap::~Heap() { delete[] this->data; }
|
||||
|
||||
void Heap::heapify(int index) {
|
||||
int largestIndex = index;
|
||||
int leftIndex = 2 * index + 1;
|
||||
int rightIndex = 2 * index + 2;
|
||||
|
||||
if (leftIndex <= this->lastIndex && this->data[leftIndex] < this->data[largestIndex])
|
||||
largestIndex = leftIndex;
|
||||
if (rightIndex <= this->lastIndex && this->data[rightIndex] < this->data[largestIndex])
|
||||
largestIndex = rightIndex;
|
||||
if (largestIndex == index)
|
||||
return;
|
||||
|
||||
swap(index, largestIndex);
|
||||
heapify(largestIndex);
|
||||
}
|
||||
|
||||
void Heap::insertFix(int index) {
|
||||
int parentIndex = (index - 1) / 2;
|
||||
if (index <= parentIndex || this->data[parentIndex] <= this->data[index])
|
||||
return;
|
||||
|
||||
swap(index, parentIndex);
|
||||
insertFix(parentIndex);
|
||||
}
|
||||
|
||||
void Heap::swap(int firstIndex, int secondIndex) {
|
||||
int tempElement = this->data[firstIndex];
|
||||
this->data[firstIndex] = this->data[secondIndex];
|
||||
this->data[secondIndex] = tempElement;
|
||||
}
|
||||
|
||||
int Heap::getLength() { return this->lastIndex + 1; }
|
||||
|
||||
int Heap::deleteMin() {
|
||||
if (this->lastIndex == -1)
|
||||
return -1;
|
||||
|
||||
int minElement = this->data[0];
|
||||
this->lastIndex--;
|
||||
this->data[0] = this->data[this->lastIndex+1];
|
||||
heapify(0);
|
||||
return minElement;
|
||||
}
|
||||
|
||||
void Heap::insert(int element) {
|
||||
this->lastIndex++;
|
||||
this->data[this->lastIndex] = element;
|
||||
insertFix(this->lastIndex);
|
||||
}
|
||||
|
||||
int main() {
|
||||
cout << "Array: [5, 4, 2, 8]" << endl;
|
||||
|
||||
int length = 4;
|
||||
int arr[] = {5, 4, 2, 8};
|
||||
Heap* heap = new Heap(arr, length, 10);
|
||||
|
||||
int spending = 0;
|
||||
int sumOfMinElements, firstMin, secondMin;
|
||||
while (heap->getLength() > 1) {
|
||||
firstMin = heap->deleteMin();
|
||||
secondMin = heap->deleteMin();
|
||||
sumOfMinElements = firstMin + secondMin;
|
||||
cout << firstMin << " + " << secondMin << " = " << sumOfMinElements << endl;
|
||||
spending += sumOfMinElements;
|
||||
heap->insert(sumOfMinElements);
|
||||
}
|
||||
cout << spending << endl;
|
||||
|
||||
delete heap;
|
||||
|
||||
return 0;
|
||||
}
|
||||
89
Second term/Algorithms/3/4.cpp
Executable file
89
Second term/Algorithms/3/4.cpp
Executable file
@ -0,0 +1,89 @@
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
struct Node {
|
||||
int key;
|
||||
Node *left;
|
||||
Node *right;
|
||||
Node(int value) : key(value), left(nullptr), right(nullptr) {}
|
||||
};
|
||||
|
||||
bool leftOrRight(Node *&node, int* depth = 0) {
|
||||
if (node == nullptr) return -1;
|
||||
|
||||
int leftDepth = 0;
|
||||
int rightDepth = 0;
|
||||
leftOrRight(node->left, &leftDepth);
|
||||
leftOrRight(node->right, &rightDepth);
|
||||
|
||||
*depth += 1 + min(leftDepth, rightDepth);
|
||||
return leftDepth > rightDepth;
|
||||
}
|
||||
|
||||
void insert(Node *&node, int key) {
|
||||
if (node->left == nullptr) {
|
||||
node->left = new Node(key);
|
||||
return;
|
||||
}
|
||||
else if (node->right == nullptr) {
|
||||
node->right = new Node(key);
|
||||
return;
|
||||
}
|
||||
|
||||
int temp = 0;
|
||||
insert((leftOrRight(node, &temp)) ? node->right : node->left, key);
|
||||
}
|
||||
|
||||
int getKey(Node *&node) { return (node == nullptr) ? -1 : node->key; }
|
||||
|
||||
void printTree(Node *node) {
|
||||
if (node == nullptr) return;
|
||||
printTree(node->left);
|
||||
cout << node->key << " [" << getKey(node->left) << ", " << getKey(node->right) << "]" << endl;
|
||||
printTree(node->right);
|
||||
}
|
||||
|
||||
bool isMinBinaryHeap(Node *&node) {
|
||||
if (node == nullptr) return true;
|
||||
|
||||
if (node->left != nullptr && node->left->key < node->key) return false;
|
||||
if (node->right != nullptr && node->right->key < node->key) return false;
|
||||
|
||||
return isMinBinaryHeap(node->left) && isMinBinaryHeap(node->right);
|
||||
}
|
||||
|
||||
bool isMaxBinaryHeap(Node *&node) {
|
||||
if (node == nullptr) return true;
|
||||
|
||||
if (node->left != nullptr && node->left->key > node->key) return false;
|
||||
if (node->right != nullptr && node->right->key > node->key) return false;
|
||||
|
||||
return isMaxBinaryHeap(node->left) && isMaxBinaryHeap(node->right);
|
||||
}
|
||||
|
||||
void checkForBinaryHeap(Node*& root) {
|
||||
if (isMaxBinaryHeap(root)) cout << "Max binary heap" << endl;
|
||||
else if (isMinBinaryHeap(root)) cout << "Min binary heap" << endl;
|
||||
else cout << "Not a binary heap" << endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
int value;
|
||||
int length;
|
||||
cout << "Enter array length: ";
|
||||
cin >> length;
|
||||
int* arr = new int[length];
|
||||
cout << "Enter elements: ";
|
||||
cin >> value;
|
||||
Node *root = new Node(value);
|
||||
for (int index = 1; index < length; index++) {
|
||||
cin >> value;
|
||||
insert(root, value);
|
||||
}
|
||||
|
||||
printTree(root);
|
||||
checkForBinaryHeap(root);
|
||||
|
||||
return 0;
|
||||
}
|
||||
88
Second term/Algorithms/3/5.cpp
Executable file
88
Second term/Algorithms/3/5.cpp
Executable file
@ -0,0 +1,88 @@
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class Heap {
|
||||
private:
|
||||
int *data;
|
||||
int length;
|
||||
int lastIndex;
|
||||
|
||||
void heapify(int index);
|
||||
void swap(int firstIndex, int secondIndex);
|
||||
public:
|
||||
Heap(int* array, int arrayLength);
|
||||
int* getArray();
|
||||
void heapSort();
|
||||
};
|
||||
|
||||
Heap::Heap(int* array, int arrayLength) {
|
||||
this->data = array;
|
||||
this->length = arrayLength - 1;
|
||||
this->lastIndex = arrayLength - 1;
|
||||
|
||||
for (int index = arrayLength / 2 - 1; index >= 0; index--)
|
||||
heapify(index);
|
||||
}
|
||||
|
||||
void Heap::heapify(int index) {
|
||||
int largestIndex = index;
|
||||
int leftIndex = 2 * index + 1;
|
||||
int rightIndex = 2 * index + 2;
|
||||
|
||||
if (leftIndex <= this->lastIndex && this->data[leftIndex] > this->data[largestIndex])
|
||||
largestIndex = leftIndex;
|
||||
if (rightIndex <= this->lastIndex && this->data[rightIndex] > this->data[largestIndex])
|
||||
largestIndex = rightIndex;
|
||||
if (largestIndex == index)
|
||||
return;
|
||||
|
||||
swap(index, largestIndex);
|
||||
heapify(largestIndex);
|
||||
}
|
||||
|
||||
void Heap::swap(int firstIndex, int secondIndex) {
|
||||
int tempElement = this->data[firstIndex];
|
||||
this->data[firstIndex] = this->data[secondIndex];
|
||||
this->data[secondIndex] = tempElement;
|
||||
}
|
||||
|
||||
int* Heap::getArray() { return this->data; }
|
||||
|
||||
void Heap::heapSort() {
|
||||
if (this->lastIndex == 0) return;
|
||||
swap(0, this->lastIndex--);
|
||||
heapify(0);
|
||||
heapSort();
|
||||
}
|
||||
|
||||
void pyramidalSorting(int *array, int length) {
|
||||
Heap* heap = new Heap(array, length);
|
||||
heap->heapSort();
|
||||
array = heap->getArray();
|
||||
}
|
||||
|
||||
void printArray(int *array, int length) {
|
||||
for (int index = 0; index < length; index++)
|
||||
cout << array[index] << " ";
|
||||
cout << endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
int length;
|
||||
cout << "Enter array length: ";
|
||||
cin >> length;
|
||||
|
||||
int* array = new int[length];
|
||||
cout << "Enter elements: ";
|
||||
for (int index = 0; index < length; index++)
|
||||
cin >> array[index];
|
||||
|
||||
printArray(array, length);
|
||||
pyramidalSorting(array, length);
|
||||
printArray(array, length);
|
||||
|
||||
delete[] array;
|
||||
|
||||
return 0;
|
||||
}
|
||||
164
Second term/Algorithms/3/6.cpp
Executable file
164
Second term/Algorithms/3/6.cpp
Executable file
@ -0,0 +1,164 @@
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
struct heapnode {
|
||||
int key;
|
||||
string data;
|
||||
};
|
||||
|
||||
class Heap {
|
||||
private:
|
||||
struct heapnode *data;
|
||||
int length;
|
||||
int lastIndex;
|
||||
|
||||
void heapify(int index);
|
||||
void insertFix(int index);
|
||||
void swap(int firstIndex, int secondIndex);
|
||||
public:
|
||||
Heap(int maxHeapLength);
|
||||
~Heap();
|
||||
void print();
|
||||
struct heapnode *deleteMax();
|
||||
void insert(int priority, string name);
|
||||
struct heapnode *search(int priority, string name);
|
||||
void edit(struct heapnode *node, int newPriority, string newName);
|
||||
};
|
||||
|
||||
Heap::Heap(int maxHeapLength) {
|
||||
this->data = new struct heapnode[maxHeapLength];
|
||||
this->length = maxHeapLength;
|
||||
this->lastIndex = -1;
|
||||
}
|
||||
|
||||
Heap::~Heap() { delete[] this->data; }
|
||||
|
||||
void Heap::heapify(int index) {
|
||||
int largestIndex = index;
|
||||
int leftIndex = 2 * index + 1;
|
||||
int rightIndex = 2 * index + 2;
|
||||
|
||||
if (leftIndex <= this->lastIndex && this->data[leftIndex].key > this->data[largestIndex].key)
|
||||
largestIndex = leftIndex;
|
||||
if (rightIndex <= this->lastIndex && this->data[rightIndex].key > this->data[largestIndex].key)
|
||||
largestIndex = rightIndex;
|
||||
if (largestIndex == index)
|
||||
return;
|
||||
|
||||
swap(index, largestIndex);
|
||||
heapify(largestIndex);
|
||||
}
|
||||
|
||||
void Heap::insertFix(int index) {
|
||||
int parentIndex = (index - 1) / 2;
|
||||
if (index <= parentIndex || this->data[parentIndex].key >= this->data[index].key)
|
||||
return;
|
||||
|
||||
swap(index, parentIndex);
|
||||
insertFix(parentIndex);
|
||||
}
|
||||
|
||||
void Heap::swap(int firstIndex, int secondIndex) {
|
||||
struct heapnode tempElement = this->data[firstIndex];
|
||||
this->data[firstIndex] = this->data[secondIndex];
|
||||
this->data[secondIndex] = tempElement;
|
||||
}
|
||||
|
||||
struct heapnode *Heap::search(int priority, string name) {
|
||||
for (int index = 0; index <= this->lastIndex; index++)
|
||||
if (this->data[index].data == name && this->data[index].key == priority)
|
||||
return &this->data[index];
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
struct heapnode *Heap::deleteMax() {
|
||||
if (this->lastIndex == -1) return nullptr;
|
||||
|
||||
this->lastIndex--;
|
||||
swap(0, this->lastIndex+1);
|
||||
heapify(0);
|
||||
return &this->data[this->lastIndex+1];
|
||||
}
|
||||
|
||||
void Heap::insert(int priority, string name) {
|
||||
this->lastIndex++;
|
||||
this->data[this->lastIndex].key = priority;
|
||||
this->data[this->lastIndex].data = name;
|
||||
insertFix(this->lastIndex);
|
||||
}
|
||||
|
||||
void Heap::edit(struct heapnode *node, int newPriority, string newName) {
|
||||
node->data = newName;
|
||||
node->key = newPriority;
|
||||
heapify(0);
|
||||
}
|
||||
|
||||
void Heap::print() {
|
||||
for (int index = 0; index <= this->lastIndex; index++)
|
||||
cout << "[" << this->data[index].key << "] " << this->data[index].data << endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
Heap* heap = new Heap(100);
|
||||
struct heapnode* trash = new heapnode[100];
|
||||
struct heapnode *node;
|
||||
int lastTrashIndex = -1;
|
||||
string command;
|
||||
string name;
|
||||
int priority;
|
||||
|
||||
while (true) {
|
||||
cout << "> ";
|
||||
cin >> command;
|
||||
|
||||
if (command == "add") {
|
||||
cout << "Enter task name: ";
|
||||
getline(cin >> ws, name);
|
||||
cout << "Enter task priority: ";
|
||||
cin >> priority;
|
||||
heap->insert(priority, name);
|
||||
}
|
||||
else if (command == "execute") {
|
||||
node = heap->deleteMax();
|
||||
if (node == nullptr) {
|
||||
cout << "No tasks." << endl;
|
||||
continue;
|
||||
}
|
||||
trash[++lastTrashIndex] = *node;
|
||||
cout << trash[lastTrashIndex].data << endl;
|
||||
}
|
||||
else if (command == "list") {
|
||||
cout << "Tasks:" << endl;
|
||||
heap->print();
|
||||
for (int index = 0; index <= lastTrashIndex; index++)
|
||||
cout << "[" << trash[index].key << "] " << trash[index].data << " (completed)" << endl;
|
||||
}
|
||||
else if (command == "edit") {
|
||||
cout << "Enter task name: ";
|
||||
getline(cin >> ws, name);
|
||||
cout << "Enter task priority: ";
|
||||
cin >> priority;
|
||||
|
||||
node = heap->search(priority, name);
|
||||
if (node == nullptr) {
|
||||
cout << "Task not found." << endl;
|
||||
continue;
|
||||
}
|
||||
|
||||
cout << "Enter new task name: ";
|
||||
getline(cin >> ws, name);
|
||||
cout << "Enter new task priority: ";
|
||||
cin >> priority;
|
||||
heap->edit(node, priority, name);
|
||||
}
|
||||
else if (command == "exit") break;
|
||||
}
|
||||
|
||||
delete heap;
|
||||
delete[] trash;
|
||||
delete node;
|
||||
|
||||
return 0;
|
||||
}
|
||||
5
Second term/Algorithms/3/Makefile
Executable file
5
Second term/Algorithms/3/Makefile
Executable file
@ -0,0 +1,5 @@
|
||||
.SILENT:
|
||||
run:
|
||||
g++ -o main "$(name).cpp"
|
||||
./main
|
||||
rm main
|
||||
BIN
Second term/Algorithms/3/Алгоритмы - Рабочая тетрадь 3.docx
Executable file
BIN
Second term/Algorithms/3/Алгоритмы - Рабочая тетрадь 3.docx
Executable file
Binary file not shown.
BIN
Second term/Algorithms/3/Алгоритмы - Рабочая тетрадь 3.pdf
Executable file
BIN
Second term/Algorithms/3/Алгоритмы - Рабочая тетрадь 3.pdf
Executable file
Binary file not shown.
106
Second term/Algorithms/5.1/1.py
Executable file
106
Second term/Algorithms/5.1/1.py
Executable file
@ -0,0 +1,106 @@
|
||||
class Node():
|
||||
def __init__(self, count, data, left=None, right=None) -> None:
|
||||
self.count = count
|
||||
self.data = data
|
||||
self.left = left
|
||||
self.right = right
|
||||
|
||||
|
||||
def create_coding_formats(node: Node, encoding_format: dict[str, str], decoding_format: dict[str, str], bits="") -> None:
|
||||
if node is None:
|
||||
return
|
||||
|
||||
if node.data is not None:
|
||||
encoding_format[node.data] = bits
|
||||
decoding_format[bits] = node.data
|
||||
|
||||
create_coding_formats(node.left, encoding_format, decoding_format, bits + "0")
|
||||
create_coding_formats(node.right, encoding_format, decoding_format, bits + "1")
|
||||
|
||||
|
||||
def get_unique_letters(message: str) -> list[Node]:
|
||||
nodes = []
|
||||
for letter in set(message):
|
||||
node = Node(message.count(letter), letter)
|
||||
nodes.append(node)
|
||||
|
||||
nodes.sort(key=lambda node: node.count, reverse=True)
|
||||
|
||||
return nodes
|
||||
|
||||
|
||||
def huffman_algorithm(nodes: list[Node]) -> tuple[dict[str, str], dict[str, str], Node]:
|
||||
while len(nodes) > 1:
|
||||
first_node = nodes.pop()
|
||||
second_node = nodes.pop()
|
||||
new_node = Node(first_node.count + second_node.count,
|
||||
None, first_node, second_node)
|
||||
nodes.append(new_node)
|
||||
nodes.sort(key=lambda node: node.count, reverse=True)
|
||||
|
||||
encoding_format = {}
|
||||
decoding_format = {}
|
||||
create_coding_formats(nodes[0], encoding_format, decoding_format)
|
||||
|
||||
return encoding_format, decoding_format, nodes[0]
|
||||
|
||||
|
||||
def encode(message: str, encoding_format: dict[str, str]) -> str:
|
||||
encoded_message = ""
|
||||
for letter in message:
|
||||
encoded_message += encoding_format[letter]
|
||||
|
||||
return encoded_message
|
||||
|
||||
|
||||
def decode(encoded_message: int, decoding_format: dict[str, str]) -> str:
|
||||
decoded_message = ""
|
||||
bits = ""
|
||||
for bit in encoded_message:
|
||||
bits += bit
|
||||
if decoding_format.get(bits) is not None:
|
||||
decoded_message += decoding_format[bits]
|
||||
bits = ""
|
||||
|
||||
return decoded_message
|
||||
|
||||
|
||||
def print_tree(node: Node, message: str, depth: int = 0) -> None:
|
||||
if node is None:
|
||||
return
|
||||
|
||||
print_tree(node.right, message, depth + 1)
|
||||
print(" " * depth * 5, f"{node.data or '*'} ({node.count / len(message) :.7f})", sep="")
|
||||
print_tree(node.left, message, depth + 1)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
print("Введите текст, содержащий не менее двух символов...")
|
||||
|
||||
message = input()
|
||||
unique_letters = get_unique_letters(message)
|
||||
|
||||
print("Полученный список:")
|
||||
for node in unique_letters:
|
||||
print(f"{node.data} ({node.count / len(message) :.7f})", end=" ---> ")
|
||||
print("\nПостроим дерево...")
|
||||
|
||||
new_encoding_fromat, new_decoding_format, huffman_tree = huffman_algorithm(unique_letters)
|
||||
|
||||
print_tree(huffman_tree, message)
|
||||
print("---------------------------------------------")
|
||||
print("Приступим к кодировке введенного текста...")
|
||||
|
||||
encoded_message = encode(message, new_encoding_fromat)
|
||||
|
||||
print("Код перед Вами...", encoded_message)
|
||||
print(f"Коэффициент сжатия: {len(encoded_message) / (len(message) * 8) * 100 :.4f}%")
|
||||
|
||||
decoded_message = decode(encoded_message, new_decoding_format)
|
||||
|
||||
print("Ранее было зашифровано...", message)
|
||||
print("Расшифровано...", decoded_message)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
BIN
Second term/Algorithms/5.1/Рабочая тетрадь 5.1 - Дерево Хаффмана.docx
Executable file
BIN
Second term/Algorithms/5.1/Рабочая тетрадь 5.1 - Дерево Хаффмана.docx
Executable file
Binary file not shown.
BIN
Second term/Algorithms/5.1/Рабочая тетрадь 5.1 - Дерево Хаффмана.pdf
Executable file
BIN
Second term/Algorithms/5.1/Рабочая тетрадь 5.1 - Дерево Хаффмана.pdf
Executable file
Binary file not shown.
34
Second term/Algorithms/5/1.py
Executable file
34
Second term/Algorithms/5/1.py
Executable file
@ -0,0 +1,34 @@
|
||||
from string import ascii_lowercase
|
||||
|
||||
|
||||
def caesar_cipher(alphabet: str, key: int, message: str) -> str:
|
||||
new_message = ""
|
||||
for char in message:
|
||||
is_upper = char.isupper()
|
||||
char = char.lower()
|
||||
|
||||
if char not in alphabet:
|
||||
new_message += char
|
||||
continue
|
||||
|
||||
index_of_new_char = (alphabet.find(char) + key) % len(alphabet)
|
||||
new_char = alphabet[index_of_new_char]
|
||||
new_message += new_char.upper() if is_upper else new_char
|
||||
|
||||
return new_message
|
||||
|
||||
|
||||
def main() -> None:
|
||||
input_message = input("Please enter text: ")
|
||||
key = int(input("Please enter key: "))
|
||||
alphabet = ascii_lowercase
|
||||
|
||||
encrypted_message = caesar_cipher(alphabet, key, input_message)
|
||||
print("Encrypted message:", encrypted_message)
|
||||
|
||||
decrypted_message = caesar_cipher(alphabet, -key, encrypted_message)
|
||||
print("Decrypted message:", decrypted_message)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
48
Second term/Algorithms/5/2.py
Executable file
48
Second term/Algorithms/5/2.py
Executable file
@ -0,0 +1,48 @@
|
||||
from operator import itemgetter
|
||||
|
||||
|
||||
def caesar_cipher(alphabet: str, key: int, message: str) -> str:
|
||||
new_message = ""
|
||||
for char in message:
|
||||
is_upper = char.isupper()
|
||||
char = char.lower()
|
||||
|
||||
if char not in alphabet:
|
||||
new_message += char
|
||||
continue
|
||||
|
||||
index_of_new_char = (alphabet.find(char) + key) % len(alphabet)
|
||||
new_char = alphabet[index_of_new_char]
|
||||
new_message += new_char.upper() if is_upper else new_char
|
||||
|
||||
return new_message
|
||||
|
||||
|
||||
def hack(alphabet: str, delta: dict[str, float], message: str) -> int:
|
||||
delta_arr = []
|
||||
for key in delta.keys():
|
||||
for char in alphabet:
|
||||
shift = abs(alphabet.find(key) - alphabet.find(char))
|
||||
delta_arr.append((abs(delta[key] - message.count(char) / len(message)), shift))
|
||||
|
||||
return min(delta_arr, key=itemgetter(0))[1]
|
||||
|
||||
|
||||
def main() -> None:
|
||||
encrypted_message = "Елжзо фср, дцжхс Лсфлч Гознфзлъ е псзп жспз флжлх, л в угж съзря л йзогб зёс цёсфхлхя. Дцжхс в ф тсфхсусррлпл рзцпсоърс дсохгб л ежуцё ефтспрло, ъхс ахс зпц рз псйзх ругелхяфв, л йзогб н рзпц тулдолклхяфв л зёс сдрвхя. Рс хсоянс ъхс тулдолклофв, елйц, ъхс олщс зёс тузсдугклосфя, фхгос псосжсз, л ср прз хлшс, хлшс ъхс-хс ёсесулх лк цъзряв сужзрг, хгн хлшс, ъхс в рз псёц угффоюыгхя. Тсхсп дцжхс еюыол пю ефз лк нспргхю, л ъхс-хс хцх фоцълосфя пцжузрсз. Пю флжзол лол озйгол рг тсоц. Ср прз ъхс-хс ёсесуло. Г прз дцжхс кгшсхзосфя тснгкгхя зпц фесб ъцефхелхзоярсфхя, л в, рз ефоцылегвфя е зёс узъл, фхго фздз ессдугйгхя фсфхсврлз фесзёс ерцхузррзёс ъзосезнг л сфзрлеыцб пзрв плосфхя Дсйлб. Л тсвелолфя ц пзрв фозкю рг ёогкгш, л в дюо жсесозр, ъхс ср ахс тулпзхло. Рс ср екёоврцо рг пзрв ф жсфгжсм л ефнсъло, тузфзныл фесм угкёсесу. В сусдзо л фтусфло, рз нс прз ол фнгкгррсз схрсфлосфя; рс ср рлъзёс рз схезъго, тснгкго прз огфнсеюм елж, л тсфоз ежуцё съцхлолфя пю е фтгоярз псзм, ёжз фхслх жесмргв нусегхя. Ср озё рг рзз рг нугм, л в, дцжхс тюогв н рзпц йзогрлзп огфнгхяфв, тулозё хцх йз. Л ср дцжхс ц пзрв фтугылегзх: „Фнгйлхз тс тугежз, нгнсз ею лпззхз ёогерсз тулфхугфхлз? Цкргол ол ею зёс? В жцпгб, ъхс ею цйз зёс цкргол“. В, фпцхлеылфя флп естусфсп, схезъго, ъхс озря псз ёогерсз тулфхугфхлз. Ср рзжсезуълес тснгъго ёсосесм. Л в, зьз дсозз фпцхлеылфя, схезъго, ъхс в шсхв л йлец ф йзрсб, тс зёс фсезхц, рс рз нгн пцй йзрю фесзм. Рг ахс ср ескугкло, ъхс рз жсойрс йзрц олыгхя фесзм огфнл, жго ъцефхесегхя, ъхс е ахсп дюог псв сдвкгррсфхя. Рс в схезъго, ъхс в фхюйцфя ахсёс; л ежуцё ефз фснуюосфя. Л в тусфрцофв л ргызо е пюфовш феслш хзнфх фе. Тлфгрлв: Йлесх дз фезх ъзосезнсп, г фезх ес хяпз фезхлх л хяпг зёс рз сдэвх. Олщс ц Лсфлчг Гознфззелъг дюос псосйгесз л фезхосз. Е ахсх жзря тсоцъло тлфяпс сх догёсжзхзов, е нсхсусп ср тлызх сд сдвкгррсфхл фцтуцйзфхег»."
|
||||
alphabet = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
|
||||
delta = {
|
||||
"о": 0.10983,
|
||||
"е": 0.08483,
|
||||
"а": 0.07998,
|
||||
}
|
||||
|
||||
key = hack(alphabet, delta, encrypted_message)
|
||||
print("Key:", key)
|
||||
|
||||
decrypted_message = caesar_cipher(alphabet, -key, encrypted_message)
|
||||
print("Decrypted message:", decrypted_message)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
33
Second term/Algorithms/5/3.py
Executable file
33
Second term/Algorithms/5/3.py
Executable file
@ -0,0 +1,33 @@
|
||||
from string import ascii_lowercase
|
||||
|
||||
|
||||
def substitution_cipher(alphabet: str, replacement_alphabet: str, message: str) -> str:
|
||||
new_message = ""
|
||||
for char in message:
|
||||
is_upper = char.isupper()
|
||||
char = char.lower()
|
||||
|
||||
if char not in alphabet:
|
||||
new_message += char
|
||||
continue
|
||||
|
||||
new_char = replacement_alphabet[alphabet.find(char)]
|
||||
new_message += new_char.upper() if is_upper else new_char
|
||||
|
||||
return new_message
|
||||
|
||||
|
||||
def main() -> None:
|
||||
input_message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
|
||||
alphabet = ascii_lowercase
|
||||
replacement_alphabet = "goydsipeluavcrjwxznhbqftmk"
|
||||
|
||||
encrypted_message = substitution_cipher(alphabet, replacement_alphabet, input_message)
|
||||
print("Encrypted message:", encrypted_message)
|
||||
|
||||
decrypted_message = substitution_cipher(replacement_alphabet, alphabet, encrypted_message)
|
||||
print("Decrypted message:", decrypted_message)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
103
Second term/Algorithms/5/4.py
Executable file
103
Second term/Algorithms/5/4.py
Executable file
@ -0,0 +1,103 @@
|
||||
class Gost(object):
|
||||
def __init__(self, key, sbox):
|
||||
self._key = 0
|
||||
self._subkeys = None
|
||||
self.key = key
|
||||
self.sbox = sbox
|
||||
|
||||
@property
|
||||
def key(self) -> int:
|
||||
return self._key
|
||||
|
||||
@key.setter
|
||||
def key(self, key: str) -> None:
|
||||
assert len(key) <= 32
|
||||
|
||||
encoded_key = key.encode("ascii")
|
||||
for index in range(31, -1, -1):
|
||||
self._key |= encoded_key[index] << (index * 8)
|
||||
|
||||
self._subkeys = [(self._key >> (32 * index)) & 0xFFFFFFFF for index in range(8)]
|
||||
|
||||
def _function(self, part: int, key: int) -> int:
|
||||
part = (part + key) % (1 << 32)
|
||||
temp = 0
|
||||
for index in range(8):
|
||||
temp |= ((self.sbox[index][(part >> (4 * index)) & 0b1111]) << (4 * index))
|
||||
|
||||
return ((temp >> 11) | (temp << 21)) & 0xFFFFFFFF
|
||||
|
||||
def encrypt_part(self, message_part: int) -> int:
|
||||
left = message_part >> 32
|
||||
right = message_part & 0xFFFFFFFF
|
||||
|
||||
for index in range(24):
|
||||
left, right = right, left ^ self._function(right, self._subkeys[index % 8])
|
||||
|
||||
for index in range(8):
|
||||
left, right = right, left ^ self._function(right, self._subkeys[7 - index])
|
||||
|
||||
return (left << 32) | right
|
||||
|
||||
def decrypt_part(self, crypted_message_part: int) -> int:
|
||||
left = crypted_message_part >> 32
|
||||
right = crypted_message_part & 0xFFFFFFFF
|
||||
|
||||
for index in range(8):
|
||||
left, right = right ^ self._function(left, self._subkeys[index]), left
|
||||
|
||||
for index in range(24):
|
||||
left, right = right ^ self._function(left, self._subkeys[(7 - index) % 8]), left
|
||||
|
||||
return (left << 32) | right
|
||||
|
||||
def encrypt(self, message: str) -> int:
|
||||
encoded_message = message.encode("ascii")
|
||||
|
||||
encrypted_message = 0
|
||||
for part_index in range(len(message) // 8 + 1 * (len(message) % 8 != 0)):
|
||||
binary_part = 0
|
||||
for letter_index in range(8):
|
||||
letter = 0x0000
|
||||
if (letter_index + part_index * 8 < len(message)):
|
||||
letter = encoded_message[letter_index + part_index * 8]
|
||||
binary_part = (binary_part << 8) | letter
|
||||
encrypted_message = (encrypted_message << 64) | self.encrypt_part(binary_part)
|
||||
|
||||
return encrypted_message
|
||||
|
||||
def decrypt(self, encrypted_message: int) -> str:
|
||||
decrypted_message = ""
|
||||
for index in range(len(bin(encrypted_message)[2:]) // 64, -1, -1):
|
||||
binary_part = (encrypted_message >> (64 * index)) & 0xFFFFFFFFFFFFFFFF
|
||||
decrypted_binary_part = self.decrypt_part(binary_part)
|
||||
for letter_index in range(8):
|
||||
decrypted_message += chr((decrypted_binary_part >> ((7 - letter_index) * 8)) & 0xFF)
|
||||
|
||||
return decrypted_message
|
||||
|
||||
|
||||
def main():
|
||||
sbox = [
|
||||
[0x4, 0xA, 0x9, 0x2, 0xD, 0x8, 0x0, 0xE, 0x6, 0xB, 0x1, 0xC, 0x7, 0xF, 0x5, 0x3],
|
||||
[0xE, 0xB, 0x4, 0xC, 0x6, 0xD, 0xF, 0xA, 0x2, 0x3, 0x8, 0x1, 0x0, 0x7, 0x5, 0x9],
|
||||
[0x5, 0x8, 0x1, 0xD, 0xA, 0x3, 0x4, 0x2, 0xE, 0xF, 0xC, 0x7, 0x6, 0x0, 0x9, 0xB],
|
||||
[0x7, 0xD, 0xA, 0x1, 0x0, 0x8, 0x9, 0xF, 0xE, 0x4, 0x6, 0xC, 0xB, 0x2, 0x5, 0x3],
|
||||
[0x6, 0xC, 0x7, 0x1, 0x5, 0xF, 0xD, 0x8, 0x4, 0xA, 0x9, 0xE, 0x0, 0x3, 0xB, 0x2],
|
||||
[0x4, 0xB, 0xA, 0x0, 0x7, 0x2, 0x1, 0xD, 0x3, 0x6, 0x8, 0x5, 0x9, 0xC, 0xF, 0xE],
|
||||
[0xD, 0xB, 0x4, 0x1, 0x3, 0xF, 0x5, 0x9, 0x0, 0xA, 0xE, 0x7, 0x6, 0x8, 0x2, 0xC],
|
||||
[0x1, 0xF, 0xD, 0x0, 0x5, 0x7, 0xA, 0x4, 0x9, 0x2, 0x3, 0xE, 0x6, 0xB, 0x8, 0xC]
|
||||
]
|
||||
message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
|
||||
key = "zqHqtbGwB41OOsm5EeGmG0VKeJWrnhML"
|
||||
|
||||
gost = Gost(key, sbox)
|
||||
crypted_message = gost.encrypt(message)
|
||||
encrypted_message = gost.decrypt(crypted_message)
|
||||
|
||||
print("Original message: ", message)
|
||||
print("Crypted: ", crypted_message)
|
||||
print("Encrypted message: ", encrypted_message)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
BIN
Second term/Algorithms/5/Алгоритмы - Рабочая тетрадь 5.docx
Executable file
BIN
Second term/Algorithms/5/Алгоритмы - Рабочая тетрадь 5.docx
Executable file
Binary file not shown.
BIN
Second term/Algorithms/5/Алгоритмы - Рабочая тетрадь 5.pdf
Executable file
BIN
Second term/Algorithms/5/Алгоритмы - Рабочая тетрадь 5.pdf
Executable file
Binary file not shown.
47
Second term/Algorithms/6/1.py
Executable file
47
Second term/Algorithms/6/1.py
Executable file
@ -0,0 +1,47 @@
|
||||
from random import randint
|
||||
|
||||
|
||||
def main() -> None:
|
||||
inf = float("inf")
|
||||
names = [
|
||||
"Пр-т Вернадского, 78",
|
||||
"Пр-т Вернадского, 86",
|
||||
"Стромынка, 20",
|
||||
"Малая Пироговская, 1",
|
||||
"5-я улица Соколиной горы, 22",
|
||||
"Усачева, 7"
|
||||
]
|
||||
graph = [
|
||||
[inf, 1.97, 21.6, 10.7, 22.3, 10.4],
|
||||
[1.97, inf, 22.3, 11.4, 23, 11.1],
|
||||
[21.6, 22.3, inf, 11.5, 5.2, 12],
|
||||
[10.7, 1.4, 11.5, inf, 13.4, 0.68],
|
||||
[22.3, 23, 5.2, 13.4, inf, 13.8],
|
||||
[10.4, 11.1, 12, 0.68, 13.8, inf]
|
||||
]
|
||||
|
||||
node = randint(0, 5)
|
||||
indexes = [node]
|
||||
edges = []
|
||||
|
||||
while len(indexes) < len(graph):
|
||||
new_edge = (indexes[0], indexes[0])
|
||||
for node in indexes:
|
||||
for new_node in range(len(graph)):
|
||||
if new_node in indexes:
|
||||
continue
|
||||
|
||||
if graph[node][new_node] < graph[new_edge[0]][new_edge[1]]:
|
||||
new_edge = (node, new_node)
|
||||
|
||||
edges.append(new_edge)
|
||||
indexes.append(new_edge[1])
|
||||
|
||||
for edge in edges:
|
||||
print(f"{names[edge[0]] :>28} --> {names[edge[1]]}")
|
||||
|
||||
print("Length:", sum([graph[edge[1]][edge[0]] for edge in edges]))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
32
Second term/Algorithms/6/2-1.py
Executable file
32
Second term/Algorithms/6/2-1.py
Executable file
@ -0,0 +1,32 @@
|
||||
def remover(nodes: list[int], graph: list[list[int]], pnode: int) -> None:
|
||||
for node in nodes:
|
||||
if graph[pnode][node]:
|
||||
nodes.remove(node)
|
||||
remover(nodes, graph, node)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
graph = [
|
||||
[0, 0, 0, 0, 0, 1, 0, 1],
|
||||
[0, 0, 0, 0, 1, 0, 0, 0],
|
||||
[0, 0, 0, 0, 0, 1, 0, 1],
|
||||
[0, 0, 0, 0, 1, 0, 0, 0],
|
||||
[0, 1, 0, 1, 0, 0, 0, 0],
|
||||
[1, 0, 1, 0, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0],
|
||||
[1, 0, 1, 0, 0, 0, 0, 0]
|
||||
]
|
||||
|
||||
nodes = [0, 1, 2, 3, 4, 5, 6, 7]
|
||||
count = 0
|
||||
while len(nodes) != 0:
|
||||
count += 1
|
||||
index = nodes[0]
|
||||
nodes.remove(index)
|
||||
remover(nodes, graph, index)
|
||||
|
||||
print("Connectivity score:", count)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
32
Second term/Algorithms/6/2-2.py
Executable file
32
Second term/Algorithms/6/2-2.py
Executable file
@ -0,0 +1,32 @@
|
||||
def remover(nodes: list[int], graph: list[list[int]], pnode: int) -> None:
|
||||
for node in range(len(graph[pnode])):
|
||||
if node in nodes and graph[pnode][node]:
|
||||
nodes.remove(node)
|
||||
remover(nodes, graph, node)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
graph = [
|
||||
[1, 1, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 1, 0],
|
||||
[0, 0, 1, 1, 0, 0],
|
||||
[0, 0, 0, 0, 0, 1],
|
||||
[0, 0, 0, 0, 1, 1],
|
||||
[1, 0, 1, 0, 0, 0],
|
||||
[0, 0, 0, 0, 0, 0],
|
||||
[0, 1, 0, 1, 0, 0],
|
||||
]
|
||||
|
||||
nodes = [0, 1, 2, 3, 4, 5, 6, 7]
|
||||
count = 0
|
||||
while len(nodes) != 0:
|
||||
count += 1
|
||||
index = nodes[0]
|
||||
nodes.remove(index)
|
||||
remover(nodes, graph, index)
|
||||
|
||||
print("Connectivity score:", count)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
39
Second term/Algorithms/6/3.py
Executable file
39
Second term/Algorithms/6/3.py
Executable file
@ -0,0 +1,39 @@
|
||||
from random import randint
|
||||
|
||||
|
||||
def main() -> None:
|
||||
inf = float("inf")
|
||||
graph = [
|
||||
[inf, 44, 46, 32, inf, 37],
|
||||
[44, inf, 45, inf, 30, inf],
|
||||
[46, 45, inf, inf, inf, 15],
|
||||
[32, inf, inf, inf, 17, 22],
|
||||
[inf, 30, inf, 17, inf, inf],
|
||||
[37, inf, 15, 22, inf, inf],
|
||||
]
|
||||
|
||||
index = randint(0, len(graph)-1)
|
||||
indexes = [index]
|
||||
while len(indexes) < len(graph):
|
||||
min_val_index = indexes[-1]
|
||||
for index in range(len(graph)):
|
||||
if index in indexes:
|
||||
continue
|
||||
|
||||
if graph[indexes[-1]][index] <= graph[indexes[-1]][min_val_index]:
|
||||
min_val_index = index
|
||||
|
||||
indexes.append(min_val_index)
|
||||
indexes.append(indexes[0])
|
||||
length = 0
|
||||
for index in range(1, len(indexes)):
|
||||
length += graph[indexes[index-1]][indexes[index]]
|
||||
print(f" {graph[indexes[index-1]][indexes[index]] :^5}", end="")
|
||||
|
||||
print()
|
||||
print(" --> ".join(map(str, indexes)))
|
||||
print("Length:", length)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
113
Second term/Algorithms/6/4.py
Executable file
113
Second term/Algorithms/6/4.py
Executable file
@ -0,0 +1,113 @@
|
||||
class Graph:
|
||||
def __init__(self) -> None:
|
||||
self.graph = []
|
||||
|
||||
def add_edge(self, first_index: int, second_index: int, length: int) -> None:
|
||||
if len(self.graph) <= first_index and len(self.graph) <= second_index:
|
||||
return
|
||||
|
||||
self.graph[first_index][second_index] = length
|
||||
self.graph[second_index][first_index] = length
|
||||
|
||||
def remove_edge(self, first_index: int, second_index: int) -> None:
|
||||
self.add_edge(first_index, second_index, 0)
|
||||
|
||||
def print_matrix(self) -> None:
|
||||
node_count = len(self.graph)
|
||||
if node_count == 0:
|
||||
return
|
||||
|
||||
print(" |", *range(node_count))
|
||||
print("--+" + "--" * node_count)
|
||||
for index in range(node_count):
|
||||
print(index, "|", *self.graph[index])
|
||||
|
||||
def print_list(self) -> None:
|
||||
for first_index in range(len(self.graph)):
|
||||
edges = self.graph[first_index]
|
||||
print(f"{first_index :>2}: ", end="")
|
||||
for second_index in range(len(edges)):
|
||||
if edges[second_index]:
|
||||
print(f"{second_index} ({edges[second_index]}) ", end="")
|
||||
print()
|
||||
|
||||
def create_empty_graph(self, node_count: int) -> None:
|
||||
self.graph = [[0 for _ in range(node_count)] for _ in range(node_count)]
|
||||
|
||||
def save(self) -> None:
|
||||
if len(self.graph) == 0:
|
||||
return
|
||||
|
||||
with open("graph.txt", "w") as file:
|
||||
file.write(f"{len(self.graph)}\n")
|
||||
for index in range(len(self.graph)):
|
||||
file.write(" ".join(map(str, self.graph[index])) + "\n")
|
||||
file.close()
|
||||
|
||||
def first_import_type(self, file_name: str) -> None:
|
||||
with open(file_name, "r") as file:
|
||||
node_count = int(file.readline())
|
||||
self.create_empty_graph(node_count)
|
||||
while True:
|
||||
line = file.readline().split()
|
||||
if len(line) < 2:
|
||||
break
|
||||
|
||||
for second_index in line[1:]:
|
||||
self.add_edge(int(line[0]), int(second_index), 1)
|
||||
file.close()
|
||||
|
||||
def second_import_type(self, file_name: str) -> None:
|
||||
with open(file_name, "r") as file:
|
||||
node_count = int(file.readline())
|
||||
self.create_empty_graph(node_count)
|
||||
while True:
|
||||
line = file.readline().split()
|
||||
if len(line) != 3:
|
||||
break
|
||||
|
||||
self.add_edge(int(line[0]), int(line[1]), int(line[2]))
|
||||
file.close()
|
||||
|
||||
def third_import_type(self, file_name: str) -> None:
|
||||
with open(file_name, "r") as file:
|
||||
node_count = int(file.readline())
|
||||
self.create_empty_graph(node_count)
|
||||
for first_index in range(node_count):
|
||||
line = file.readline().split()
|
||||
for second_index in range(node_count):
|
||||
self.add_edge(first_index, second_index, int(line[second_index]))
|
||||
file.close()
|
||||
|
||||
|
||||
def main() -> None:
|
||||
g = Graph()
|
||||
print("Import of the first graph type (А)")
|
||||
g.first_import_type("first_type_graph.txt")
|
||||
g.print_matrix()
|
||||
|
||||
print("Import of the second graph type (Б)")
|
||||
g.second_import_type("second_type_graph.txt")
|
||||
g.print_matrix()
|
||||
|
||||
print("Import of the third graph type (В)")
|
||||
g.third_import_type("third_type_graph.txt")
|
||||
g.print_matrix()
|
||||
|
||||
print("Print the graph as a list")
|
||||
g.print_list()
|
||||
|
||||
print("Adding a new edge 1-2 with length 6")
|
||||
g.add_edge(1, 2, 6)
|
||||
g.print_matrix()
|
||||
|
||||
print("Removing the edge 3-4")
|
||||
g.remove_edge(3, 4)
|
||||
g.print_matrix()
|
||||
|
||||
print("Saving a new graph")
|
||||
g.save()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
BIN
Second term/Algorithms/6/Алгоритмы - Рабочая тетрадь 6.docx
Executable file
BIN
Second term/Algorithms/6/Алгоритмы - Рабочая тетрадь 6.docx
Executable file
Binary file not shown.
BIN
Second term/Algorithms/6/Практические занятия Алгоритмы - Рабочая тетрадь 6.pdf
Executable file
BIN
Second term/Algorithms/6/Практические занятия Алгоритмы - Рабочая тетрадь 6.pdf
Executable file
Binary file not shown.
39
Second term/Algorithms/7/1.py
Executable file
39
Second term/Algorithms/7/1.py
Executable file
@ -0,0 +1,39 @@
|
||||
def main() -> None:
|
||||
inf = float("inf")
|
||||
graph = [
|
||||
[ 0, 7, inf, inf, 4, inf],
|
||||
[ 7, 0, 5, inf, inf, 2],
|
||||
[inf, 5, 0, 11, inf, 6],
|
||||
[inf, inf, 11, 0, 8, 9],
|
||||
[ 4, inf, inf, 8, 0, 3],
|
||||
[inf, 2, 6, 9, 3, 0],
|
||||
]
|
||||
|
||||
start_node = 0
|
||||
|
||||
dist = graph[start_node].copy()
|
||||
queue = list(range(len(dist)))
|
||||
routes = [[] if dist[index] == inf else [start_node] for index in range(len(dist))]
|
||||
while len(queue) > 0:
|
||||
min_index = queue[0]
|
||||
for node in queue:
|
||||
if dist[node] < dist[min_index]:
|
||||
min_index = node
|
||||
queue.remove(min_index)
|
||||
|
||||
for node in queue:
|
||||
new_dist = dist[min_index] + graph[min_index][node]
|
||||
if dist[node] > new_dist:
|
||||
dist[node] = new_dist
|
||||
routes[node] = routes[min_index] + [min_index]
|
||||
|
||||
for index in range(len(routes)):
|
||||
if index == start_node:
|
||||
continue
|
||||
|
||||
print(f"{start_node} --> {index} ({dist[index] :>2}):", end=" ")
|
||||
print(" --> ".join(map(str, routes[index] + [index])))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
58
Second term/Algorithms/7/2.py
Executable file
58
Second term/Algorithms/7/2.py
Executable file
@ -0,0 +1,58 @@
|
||||
def dijkstra(graph: list[list[int]], start_node: int, end_node: int) -> list[int]:
|
||||
dist = graph[start_node].copy()
|
||||
queue = list(range(len(dist)))
|
||||
routes = [[] if dist[index] == float("inf") else [start_node] for index in range(len(dist))]
|
||||
while len(queue) > 0:
|
||||
min_index = queue[0]
|
||||
for node in queue:
|
||||
if dist[node] < dist[min_index]:
|
||||
min_index = node
|
||||
queue.remove(min_index)
|
||||
|
||||
for node in queue:
|
||||
new_dist = dist[min_index] + graph[min_index][node]
|
||||
if dist[node] > new_dist:
|
||||
dist[node] = new_dist
|
||||
routes[node] = routes[min_index] + [min_index]
|
||||
|
||||
return routes[end_node] + [end_node]
|
||||
|
||||
|
||||
def main() -> None:
|
||||
inf = float("inf")
|
||||
graph = [
|
||||
[ 0, 7, 4, inf, inf, inf],
|
||||
[inf, 0, 4, inf, 2, inf],
|
||||
[inf, inf, 0, 4, 8, inf],
|
||||
[inf, inf, inf, 0, inf, 12],
|
||||
[inf, inf, inf, 4, 0, 5],
|
||||
[inf, inf, inf, inf, inf, 0]
|
||||
]
|
||||
|
||||
start_node = 0
|
||||
end_node = 5
|
||||
|
||||
flow_sum = 0
|
||||
while True:
|
||||
min_flow = inf
|
||||
route = dijkstra(graph, start_node, end_node)
|
||||
if len(route) == 1:
|
||||
break
|
||||
|
||||
for index in range(len(route)-1):
|
||||
min_flow = min(min_flow, graph[route[index]][route[index+1]])
|
||||
|
||||
flow_sum += min_flow
|
||||
|
||||
for index in range(len(route)-1):
|
||||
graph[route[index]][route[index+1]] -= min_flow
|
||||
graph[route[index+1]][route[index]] = min_flow
|
||||
|
||||
if graph[route[index]][route[index+1]] == 0:
|
||||
graph[route[index]][route[index+1]] = inf
|
||||
|
||||
print("Sum:",flow_sum)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
BIN
Second term/Algorithms/7/Алгоритмы - Рабочая тетрадь 7.pdf
Executable file
BIN
Second term/Algorithms/7/Алгоритмы - Рабочая тетрадь 7.pdf
Executable file
Binary file not shown.
14
Second term/Algorithms/8/1.py
Executable file
14
Second term/Algorithms/8/1.py
Executable file
@ -0,0 +1,14 @@
|
||||
def gcd_extended(a: int, b: int) -> tuple[int, int, int]:
|
||||
if b == 0:
|
||||
return a, 1, 0
|
||||
|
||||
gcd, x, y = gcd_extended(b, a % b)
|
||||
return gcd, y, x - (a // b) * y
|
||||
|
||||
|
||||
def main() -> None:
|
||||
print(gcd_extended(240, 46))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
96
Second term/Algorithms/8/2.py
Executable file
96
Second term/Algorithms/8/2.py
Executable file
@ -0,0 +1,96 @@
|
||||
from random import choice
|
||||
|
||||
|
||||
def gcd(a: int, b: int) -> int:
|
||||
if b == 0:
|
||||
return a
|
||||
|
||||
return gcd(b, a % b)
|
||||
|
||||
|
||||
def gcd_extended(a: int, b: int) -> tuple[int, int, int]:
|
||||
if b == 0:
|
||||
return a, 1, 0
|
||||
|
||||
gcd, x, y = gcd_extended(b, a % b)
|
||||
return gcd, y, x - (a // b) * y
|
||||
|
||||
|
||||
def mod_inverse(n: int, x: int) -> int:
|
||||
inv_x = gcd_extended(n, x)[2]
|
||||
if inv_x <= 0:
|
||||
inv_x += n
|
||||
return inv_x
|
||||
|
||||
|
||||
def mod_extended(x: int, y: int, n: int) -> int:
|
||||
if y == 0:
|
||||
return 1
|
||||
|
||||
z = mod_extended(x, y // 2, n)
|
||||
|
||||
if y % 2 == 0:
|
||||
return (z * z) % n
|
||||
|
||||
return (x * z * z) % n
|
||||
|
||||
|
||||
def generate_keys(p: int, q: int) -> tuple[tuple[int, int], tuple[int, int]]:
|
||||
n = p * q
|
||||
phi = (p - 1) * (q - 1)
|
||||
|
||||
e = 3
|
||||
for ferm_number in [5, 17, 257, 65537]:
|
||||
if ferm_number < phi:
|
||||
e = ferm_number
|
||||
|
||||
d = mod_inverse(phi, e)
|
||||
|
||||
return (e, n), (d, n)
|
||||
|
||||
|
||||
def encrypt(message: str, key: tuple[int, int]):
|
||||
e, n = key
|
||||
encrypted_message = [mod_extended(ord(char), e, n) for char in message]
|
||||
return encrypted_message
|
||||
|
||||
|
||||
def decrypt(encrypted_message: str, key: tuple[int, int]):
|
||||
d, n = key
|
||||
decrypted_message = [chr(mod_extended(char, d, n))
|
||||
for char in encrypted_message]
|
||||
return "".join(decrypted_message)
|
||||
|
||||
|
||||
def get_primes(n: int):
|
||||
sieve = [True] * n
|
||||
primes = []
|
||||
for p in range(2, n):
|
||||
if sieve[p]:
|
||||
primes.append(p)
|
||||
for i in range(p * p, n, p):
|
||||
sieve[i] = False
|
||||
return primes
|
||||
|
||||
|
||||
def main() -> None:
|
||||
primes = get_primes(100000)
|
||||
p = choice(primes)
|
||||
q = choice(primes)
|
||||
while p == q:
|
||||
q = choice(primes)
|
||||
|
||||
message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
|
||||
public, private = generate_keys(p, q)
|
||||
encrypted_message = encrypt(message, public)
|
||||
decrypted_message = decrypt(encrypted_message, private)
|
||||
|
||||
print("Public key: ", public)
|
||||
print("Private key:", private)
|
||||
print("Original message: ", message)
|
||||
print("Encrypted message:", "".join(map(str, encrypted_message)))
|
||||
print("Decrypted message:", decrypted_message)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
BIN
Second term/Algorithms/8/Алгоритмы - Рабочая тетрадь 8.pdf
Executable file
BIN
Second term/Algorithms/8/Алгоритмы - Рабочая тетрадь 8.pdf
Executable file
Binary file not shown.
BIN
Second term/Algorithms/8/Алгоритмы - Рабочая тетрадь7.docx
Executable file
BIN
Second term/Algorithms/8/Алгоритмы - Рабочая тетрадь7.docx
Executable file
Binary file not shown.
15
Second term/Algorithms/README.md
Executable file
15
Second term/Algorithms/README.md
Executable file
@ -0,0 +1,15 @@
|
||||
# Algorithms
|
||||
|
||||
number | name | grade
|
||||
:----: | ----------------------------------------------------------------------------------- | :---:
|
||||
1 | Двоичное дерево поиска | ✅
|
||||
1.1 | Дерево отрезков | ✅
|
||||
2 | Сбалансированные двоичные деревья поиска | ✅
|
||||
3 | Двоичная куча. Очередь с приоритетом. Пирамидальная сортировка. | ✅
|
||||
5 | Основы криптографических алгоритмов | ✅
|
||||
5.1 | Дерево Хаффмана | ✅
|
||||
6 | Основы теории графов | ✅
|
||||
7 | Алгоритмы на графах (Удален из программы) | ❓
|
||||
8 | Шифрование с открытым ключом. Расширенный алгоритм Евклида. Алгоритм шифрования RSA | ✅
|
||||
|
||||
[Back](/NKTKLN/mirea-projects)
|
||||
BIN
Second term/Algorithms/exam/img/Расход_памяти_КЧ.png
Executable file
BIN
Second term/Algorithms/exam/img/Расход_памяти_КЧ.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 50 KiB |
BIN
Second term/Algorithms/exam/img/Решение_уравнения_методом_хорд.png
Executable file
BIN
Second term/Algorithms/exam/img/Решение_уравнения_методом_хорд.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 15 KiB |
BIN
Second term/Algorithms/exam/img/Числа_Мерсенна._Тест_Люка-Лемера.png
Executable file
BIN
Second term/Algorithms/exam/img/Числа_Мерсенна._Тест_Люка-Лемера.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 377 KiB |
BIN
Second term/Algorithms/exam/img/алгоритм_RSA_1.png
Executable file
BIN
Second term/Algorithms/exam/img/алгоритм_RSA_1.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 255 KiB |
BIN
Second term/Algorithms/exam/img/алгоритм_RSA_2.png
Executable file
BIN
Second term/Algorithms/exam/img/алгоритм_RSA_2.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 352 KiB |
BIN
Second term/Algorithms/exam/img/алгоритм_Прима.png
Executable file
BIN
Second term/Algorithms/exam/img/алгоритм_Прима.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 114 KiB |
BIN
Second term/Algorithms/exam/img/алгоритм_быстрого_возведения_в_степень.png
Executable file
BIN
Second term/Algorithms/exam/img/алгоритм_быстрого_возведения_в_степень.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 169 KiB |
BIN
Second term/Algorithms/exam/img/алгоритм_ферма.png
Executable file
BIN
Second term/Algorithms/exam/img/алгоритм_ферма.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 840 KiB |
BIN
Second term/Algorithms/exam/img/быстрая_сортировка.png
Executable file
BIN
Second term/Algorithms/exam/img/быстрая_сортировка.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 402 KiB |
BIN
Second term/Algorithms/exam/img/евклид.png
Executable file
BIN
Second term/Algorithms/exam/img/евклид.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 264 KiB |
BIN
Second term/Algorithms/exam/img/карта.png
Executable file
BIN
Second term/Algorithms/exam/img/карта.png
Executable file
Binary file not shown.
|
After Width: | Height: | Size: 95 KiB |
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user