C3100_Malkov_Maksim_Lab9

3.cpp

@@ -0,0 +1,118 @@
+#include <iostream>
+#include <vector>
+
+void fillGaps(std::vector<int>& arr) {
+    int n = arr.size();  // O(1)
+
+    for (int i = 0; i < n; ++i) {  
+        if (arr[i] == -1) {  // O(1)
+            int left = i - 1;  // O(1)
+            int right = i + 1;  // O(1)
+
+            // Ищем ближайшее значение слева
+            while (left >= 0 && arr[left] == -1) {  // O(n) в худшем случае
+                left--;  // O(1)
+            }
+
+            // Ищем ближайшее значение справа
+            while (right < n && arr[right] == -1) {  // O(n) в худшем случае
+                right++;  // O(1)
+            }
+
+            // Если оба соседа найдены, вычисляем среднее
+            if (left >= 0 && right < n) {  // O(1)
+                arr[i] = (arr[left] + arr[right]) / 2;  // O(1)
+            }
+        }
+    }
+}
+// таким образом О(n^2)
+void testFillGaps() {
+    // Тест 1
+    std::vector<int> arr1;
+    arr1.push_back(1);
+    arr1.push_back(-1);
+    arr1.push_back(10);
+    arr1.push_back(4);
+    fillGaps(arr1);
+    std::cout << "Test 1: ";
+    for (int num : arr1) {
+        std::cout << num << " ";
+    }
+    std::cout << "\n"; // Ожидаемый результат: 1 5 10 4
+
+    // Тест 2: Массив без пропусков
+    std::vector<int> arr2;
+    arr2.push_back(5);
+    arr2.push_back(10);
+    arr2.push_back(15);
+    arr2.push_back(20);
+    fillGaps(arr2);
+    std::cout << "Test 2: ";
+    for (int num : arr2) {
+        std::cout << num << " ";
+    }
+    std::cout << "\n"; // Ожидаемый результат: 5 10 15 20 
+
+    // Тест 3: Массив с пропуском в начале
+    std::vector<int> arr3;
+    arr3.push_back(-1);
+    arr3.push_back(2);
+    arr3.push_back(3);
+    fillGaps(arr3);
+    std::cout << "Test 3: ";
+    for (int num : arr3) {
+        std::cout << num << " ";
+    }
+    std::cout << "\n"; // Ожидаемый результат: 2 2 3
+
+    // Тест 4: Массив с пропуском в конце
+    std::vector<int> arr4;
+    arr4.push_back(1);
+    arr4.push_back(2);
+    arr4.push_back(-1);
+    fillGaps(arr4);
+    std::cout << "Test 4: ";
+    for (int num : arr4) {
+        std::cout << num << " ";
+    }
+    std::cout << "\n"; // Ожидаемый результат: 1 2 2
+
+    // Тест 5: Массив с несколькими пропусками
+    std::vector<int> arr5;
+    arr5.push_back(1);
+    arr5.push_back(-1);
+    arr5.push_back(-1);
+    arr5.push_back(4);
+    fillGaps(arr5);
+    std::cout << "Test 5: ";
+    for (int num : arr5) {
+        std::cout << num << " ";
+    }
+    std::cout << "\n"; // Ожидаемый результат: 1 2 3 4
+
+    // Тест 6: Пустой массив
+    std::vector<int> arr6;
+    fillGaps(arr6);
+    std::cout << "Test 6: ";
+    for (int num : arr6) {
+        std::cout << num << " ";
+    }
+    std::cout << "\n"; // Ожидаемый результат: (пустой массив)
+
+    // Тест 7: Массив с одним элементом
+    std::vector<int> arr7;
+    arr7.push_back(100);
+    fillGaps(arr7);
+    std::cout << "Test 7: ";
+    for (int num : arr7) {
+        std::cout << num << " ";
+    }
+    std::cout << "\n"; // Ожидаемый результат: 100
+}
+
+int main() {
+
+    testFillGaps();
+    return 0;
+}

C3100-Malkov_Maksim_lab4

@@ -0,0 +1,44 @@
+#include <iostream>
+#include <vector>
+
+
+void Rec(std::vector<int>& arr, int k, int start, int depth, std::vector<int>& indices) {
+    int n = arr.size();
+
+    if (depth == k) {
+        int sum = 0;
+        for (int idx : indices) {
+            sum += arr[idx];
+        }
+        if (sum == 0) {
+            for (int idx : indices) {
+                std::cout << idx << " ";
+            }
+            std::cout << std::endl;
+        }
+        return;
+    }
+
+    for (int i = start; i < n; ++i) {
+        indices.push_back(i);
+        Rec(arr, k, i + 1, depth + 1, indices);
+        indices.pop_back();
+    }
+}
+
+void findSubarrays(std::vector<int>& arr, int k) {
+    std::vector<int> indices;
+    Rec(arr, k, 0, 0, indices);
+}
+
+int main() {
+    int n, k;
+    std::cin >> n;
+    std::cin >> k;
+
+    std::vector<int> arr(n);
+    for (int i = 0; i < n; ++i) {
+        std::cin >> arr[i];
+    }
+    findSubarrays(arr, k);
+}

iso.cpp

@@ -0,0 +1,66 @@
+#include <iostream> 
+#include <unordered_map> 
+#include <string> 
+#include <cassert>
+
+
+bool Iso(const std::string& a, const std::string& b) {
+    // Если длины строк не равны, они не могут быть изоморфными
+    if (a.length() != b.length()) {
+        return false; 
+    }
+
+    // Создаем двe хеш-таблицы для отслеживания соответствий символов
+    std::unordered_map<char, char> one; //O(n) 
+    std::unordered_map<char, char> reverseone;
+    // O(n) + 3 * 1 байт * 2 мапы
+
+    // Итерируемся по каждому символу строк
+    for (size_t i = 0; i < a.length(); ++i) {
+        char charA = a[i]; 
+        char charB = b[i]; 
+        // + 1 байт * 2
+
+        if (one.count(charA)) { 
+            if (one[charA] != charB) { // Проверяем, совпадает ли с charB
+                return false; 
+            }
+        } else { 
+            one[charA] = charB; // Устанавливаем новое соответствие так как его еще нет
+        }
+
+
+        if (reverseone.count(charB)) { // Если уже есть соответствие для charB
+            if (reverseone[charB] != charA) { // Проверяем, совпадает ли оно с charA
+                return false; 
+            }
+        } else { 
+            reverseone[charB] = charA; 
+        }
+    }
+
+    return true; // Если все проверки пройдены, строки изоморфны
+}
+void runTests() {
+    // Тесты с обычными значениями
+    assert(Iso("egg", "add") == true);
+    assert(Iso("foo", "bar") == false);
+    // (3 * 1 + 1 (за ноль) + 4 (за длину)) * 2
+
+    // Пограничные значения
+    assert(Iso("", "") == true); // Пустые строки
+    assert(Iso("a", "a") == true); // Одна буква, совпадающая
+    assert(Iso("a", "b") == true); // Одна буква, разные
+
+    // Проверка на разные длины строк
+    assert(Iso("abc", "defg") == false); 
+}
+
+int main() {
+    runTests();
+    return 0;
+}
+
+// в итоге память это 2 * O(4) + 3 * 1 байт * 2 мапы + 1 байт * 2 + (3 * 1 + 1 (за ноль) + 4 (за длину)) * 2 = 32 байта
+
+

main.py

@@ -0,0 +1,22 @@
+'''
+
+                            Online Python Compiler.
+                Code, Compile, Run and Debug python program online.
+Write your code in this editor and press "Run" button to execute it.
+
+'''
+
+import numpy as np
+
+def longest_sequence(arr):
+    arr = np.array(arr)  # Преобразуем входные данные в массив numpy
+    diff = np.diff(arr)  # Вычисляем разности между соседними элементами
+
+    boundaries = (diff != 0).nonzero()[0] + 1  # Определяем границы изменений
+    segment_lengths = np.diff(np.hstack(([0], boundaries, [len(arr)])))  # Вычисляем длины последовательностей
+
+    return segment_lengths.max()  # Возвращаем максимальную длину
+
+# Пример использования
+arr = [1, 1, 1, 2, 2, 2, 2, 5]
+print(longest_sequence(arr))