Initial commit

1.1.py

@@ -0,0 +1,53 @@
+def binarySearch(array, element):
+
+    left = 0  # Левая граница
+    right = len(array) - 1  # Правая граница
+    middle = 0  # Середина
+
+    while left <= right:
+        middle = (left + right) // 2  # Шаг 1
+        if array[middle] == element:
+            return middle
+
+        if array[middle] < element:  # Шаг 2
+            left = middle + 1
+        else:
+            right = middle - 1
+
+    return -1
+
+
+def binarySearchWithInsert(array, element):
+
+    left = 0  # Левая граница
+    right = len(array) - 1  # Правая граница
+    middle = 0  # Середина
+
+    while left <= right:
+        middle = (left + right) // 2  # Шаг 1
+        if array[middle] == element:
+            return middle
+
+        if array[middle] < element:  # Шаг 2
+            left = middle + 1
+        else:
+            right = middle - 1
+
+    # Вставляем элемент на позицию, согласно сортировке
+    array.insert(left, element)
+
+    return -1
+
+
+def main():
+    array = [1, 2, 4, 6, 7, 9, 13, 15]
+
+    item = int(input("Find: "))
+
+    print(binarySearchWithInsert(array, item))
+
+    print(array)
+
+
+if __name__ == "__main__":
+    main()

main.cpp

@@ -0,0 +1,49 @@
+#include <iostream>
+
+#include "practice2.cpp"
+
+
+int main()
+{
+  // 1.1
+  // int *length = new int(10);
+  // int array[100] = {0, 2, 3, 4, 7, 8, 10, 13, 15, 20};
+
+  // int numToSearch;
+  // 
+  // std::cout << "Find: "; std::cin >> numToSearch;
+  // std::cout << binarySearchWithInsert(array, length, numToSearch) << std::endl;
+
+  // for (int i=0; i<*length; i++)
+  // {
+  //      std::printf("%d, ", array[i]);
+  // }
+  // std:: cout << std::endl;
+
+  // return 0;
+
+  // 1.2
+  // int array[] = {0, 1, 2, 3, 4, 6, 4, 3, 2, 3, 4, 2};
+  // int length = sizeof(array) / sizeof(array[0]);
+
+  // std::cout << isMountain(array, length) << std::endl;
+  
+  // 1.3
+  // int array[] = {-1, -1, -1, 3};
+  // int length = sizeof(array) / sizeof(array[0]);
+  // std::cout << whichIsMore(array, length) << std::endl;
+  
+  // 1.4
+  int array[] = {5,2,6,1};
+  int length = sizeof(array) / sizeof(array[0]);
+
+  int* counts = countsFromNums(array, length);
+
+  for (int i=0; i<length; i++)
+  {
+    std::printf("%d, ", counts[i]);
+  }
+  std:: cout << std::endl;
+  
+  return 0;
+}

practice2.cpp

@@ -0,0 +1,185 @@
+#include <iostream>
+
+int binarySearch(int array[], int length, int element)
+{
+  // Пример.
+  // Бинарный поиск элемента element в массиве чисел array.
+  // int array[] - массив чисел, отсортированный по возрастанию. (!!!)
+  // int length - длина массива.
+  // int element - число, которое необходимо найти в массиве.
+
+  int left = 0;  // Левая граница 
+  int right = length - 1;  // Правая граница
+  int middle = 0;  // Середина
+  
+  while (left <= right)
+  {
+    middle = (left + right) / 2;  // Шаг 1
+    if (array[middle] == element)
+    {
+      return middle;
+    }
+    
+    if (array[middle] < element) // Шаг 2
+    {
+      left = middle + 1;
+    }
+    else
+    {
+      right = middle - 1;
+    }
+  }
+
+  return -1;
+}
+
+
+// Задание 1.1
+// Написать программу для бинарного поиска элемента в отсортированном
+// массиве. В случае, если элемент не найден, указать позицию, в которую
+// можно выполнить вставку элемента (чтобы массив оставался
+// отсортированным) и выполнить вставку.
+int binarySearchWithInsert(int array[], int *length, int element)
+{
+  // Пример.
+  // Бинарный поиск элемента element в массиве чисел array.
+  // int array[] - массив чисел, отсортированный по возрастанию. (!!!)
+  // int length - длина массива.
+  // int element - число, которое необходимо найти в массиве.
+
+  int left = 0;  // Левая граница 
+  int right = *length - 1;  // Правая граница
+  int middle = 0;  // Середина
+  
+  while (left <= right)
+  {
+    middle = (left + right) / 2;  // Шаг 1
+    if (array[middle] == element)
+    {
+      return middle;
+    }
+    
+    if (array[middle] < element) // Шаг 2
+    {
+      left = middle + 1;
+    }
+    else
+    {
+      right = middle - 1;
+    }
+  }
+
+  int insertPosition = left;  // Позиция вставки
+
+  // От позиции вставки сдвигаем все элементы вправо
+  for (int i = *length; i > insertPosition; i--)
+  {
+    array[i] = array[i - 1];
+  }
+
+  array[insertPosition] = element;
+  *length = *length + 1;
+
+  return -1;
+}
+
+// Задание 1.2
+// Массив arr называется горным, если выполняются следующие свойства:
+// 1) В массиве не менее трех элементов
+// 2) Существуют i (0 < i < arr.length – 1) что:
+// ▪ arr[0] < arr[1] < ... < arr[i - 1] < arr[i]
+// ▪ arr[i] > arr[i + 1] > ... > arr[arr.length - 1]
+// Иными словами, в массиве есть пик (или несколько пиков) такие, что
+// остальные элементы убывают влево и вправо относительно пика.
+// Используя алгоритм бинарного поиска, проверить, является ли массив arr
+// горным. Если да – вернуть индекс первого пика.
+int isMountain(int array[], int length)
+{
+    // Проверка на минимальную длину массива
+    if (length < 3) 
+    {
+        return -1;
+    }
+
+    int left = 0;
+    int right = length - 1;
+
+    while (left < right) 
+    {
+        int middle = left + (right - left) / 2;
+
+        // Проверка, является ли mid пиком
+        if (array[middle] > array[middle + 1] && array[middle] > array[middle - 1]) 
+        {
+            return middle;
+        }
+
+        if (array[middle] < array[middle + 1]) 
+        {
+            left = middle + 1; // Ищем в правой части
+        }
+        else
+        {
+            right = middle; // Ищем в левой части
+        }
+    }
+
+    // Если не найдено ни одного пика
+    return -1;
+}
+
+
+// 1.3
+// Массив отсортирован по возрастанию (элементы могут повторяться). С
+// помощью алгоритма бинарного поиска выяснить, каких чисел в массиве
+// больше – положительных или отрицательных. Если больше
+// положительных чисел – вывести их количество, если же больше
+// отрицательных, то вывести их количество
+int whichIsMore(int array[], int length) 
+{
+    int left = 0;  // Левая граница 
+    int right = length - 1;  // Правая граница
+    int middle = 0;  // Середина
+
+    // Ищем первое положительное число
+    while (left <= right) 
+    {
+        middle = left + (right - left) / 2;
+
+        if (array[middle] > 0) 
+        {
+            right = middle - 1;
+        } 
+        else
+        {
+            left = middle + 1;
+        }
+    }
+
+    int positiveCount = length - left;  // Количество положительных чисел
+    int negativeCount = left;  // Количество отрицательных чисел
+
+    return positiveCount > negativeCount ? positiveCount : negativeCount; 
+}
+
+// 1.4
+// Дан целочисленный массив nums. Постройте целочисленный массив
+// counts, где counts[i]— количество меньших элементов справа от nums[i].
+int* countsFromNums(int nums[], int length)
+{
+  int *counts = new int[length];
+
+  for (int i = 0; i < length; i++)
+  {
+    counts[i] = 0;
+    for (int j = i + 1; j < length; j++)
+    {
+      if (nums[i] > nums[j])
+      {
+        counts[i]++;
+      }
+    }
+  }
+
+  return counts;
+}