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