Два целых числа

Проблема: Дан массив целых чисел nums и целочисленный target. Необходимо реализовать алгоритм, который вернет индексы i и j такие, что nums[i] + nums[j] == target и i != j. Можно предположить, что каждый input имеет ровно одну пару индексов i и j, удовлетворяющих условию. Сначала верните ответ с меньшим индексом.

Пример 1:
Input: nums = [3,4,5,6], target = 7
Output: [0,1]


Пример 2:
Input: nums = [-3,4,3,90], target=0
Output: [0,2]

Группы анаграмм

Проблема: Дан массив строк strs. Необходимо реализовать алгоритм, который сгруппирует все анаграммы в подгруппы. Можно вернуть вывод в любом порядке.

Анаграмма — это строка, содержащая те же символы, что и другая строка, но порядок символов может быть другим.

Пример 1:
Input: strs = ["act","pots","tops","cat","stop","hat"]
Output: [["hat"],["act", "cat"],["stop", "pots", "tops"]]

Пример 2:
Input: strs = ["x"]
Output: [["x"]]

"K" элементов в списке

Проблема: Дан целочисленный массив nums и целое число k. Необходимо реализовать алгоритм, который вернет k наиболее часто встречающихся элементов массива. Можно вернуть вывод в любом порядке.

Пример 1:
Input: nums = [1,2,2,3,3,3], k = 2
Output: [2,3]

Пример 2:
Input: nums = [7,7], k = 1
Output: [7]

Произведения всех элементов массива, кроме текущего

Проблема: Дан целочисленный массив nums. Необходимо реализовать алгоритм, который вернет массив, где iый элемент является произведением всех элементов nums, кроме nums[i] (каждое произведение гарантированно умещается в 32-битное целое число).

Для решения задачи без использования операции деления и за O(n) времени, можно использовать метод предварительного вычисления произведений. Идея заключается в том, чтобы использовать два прохода по массиву: один для вычисления произведений слева от текущего элемента и другой для вычисления произведений справа от текущего элемента.

Пример:
Input: nums = [-1,0,1,2,3]
Output: [0,-6,0,0,0]

Допустимая доска Sudoku

Проблема: Дана доска для судоку размером 9 x 9. Доска судоку действительна, если соблюдаются следующие правила:
- Каждая строка должна содержать цифры от 1 до 9 без дубликатов.
- Каждый столбец должен содержать цифры 1–9 без дубликатов.
- Каждый из девяти подполей сетки размером 3х3 должен содержать цифры от 1 до 9 без дубликатов.

Необходимо реализовать алгоритм, который вернет true, если доска судоку действительна, в противном случае вернет false (чтобы считаться допустимой, доска не обязательно должна быть заполненной или разрешимой).

Пример:
Input:

board = [["1","2",".",".","3",".",".",".","."],
["4",".",".","5",".",".",".",".","."],
[".","9","1",".",".",".",".",".","3"],
["5",".",".",".","6",".",".",".","4"],
[".",".",".","8",".","3",".",".","5"],
["7",".",".",".","2",".",".",".","6"],
[".",".",".",".",".",".","2",".","."],
[".",".",".","4","1","9",".",".","8"],
[".",".",".",".","8",".",".","7","9"]]

Output: false

Самая длинная последовательность

Проблема: Дан массив целых чисел nums. Необходимо реализовать алгоритм, который вернет длину самой длинной последовательности элементов.

Самая длинная последовательность — это последовательность элементов, в которой каждый элемент ровно на 1 больше предыдущего элемента.

Пример 1:
Input: nums = [2,20,4,10,3,4,5]
Output: 4

Пример 2:
Input: nums = [0,3,2,5,4,6,1,1]
Output: 7

Сумма трёх целых чисел

Проблема: Дан целочисленный массив nums. Необходимо реализовать алгоритм, который вернет все тройки [nums[i], nums[j], nums[k]], где nums[i] + nums[j] + nums[k] == 0, и индексы i, j и k различны.

Вывод не должен содержать повторяющихся троек. Можно вернуть результат и тройки в любом порядке.

Пример 1:
Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]
Объяснение:
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0.
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0.
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0.

Пример 2:
Input: nums = [0,0,0]
Output: [[0,0,0]]

Контейнер для воды

Проблема: Дан целочисленный массив heights, где heights[i] представляет высоту i-ой колонки.

Можно выбрать любые две колонки, чтобы сформировать контейнер. В результате должно вернуться максимальное количество воды, которое может хранить контейнер.

function maxArea(heights) {
    left = 0
    right = length(heights) - 1
    max_area = 0

    while left < right {
        height = min(heights[left], heights[right])
        width = right - left
        current_area = height * width
        max_area = max(max_area, current_area)

        if heights[left] < heights[right] { 
            left += 1 
        }
        else { right -= 1 }
    }
    return max_area
}

Улавливание дождевой воды

Проблема: Дан массив высот неотрицательных целых чисел, которые представляют карту высот. Каждое значение heights[i] представляет высоту полосы, ширина которой равна 1.

В результате должно вернуться максимальная площадь воды, которая может задерживаться между решетками.

Покупка и продажа крипты

Проблема: Дан целочисленный массив цен, где prices[i] — цена AlgoCoin на i-й день. Можно выбрать один день для покупки одного AlgoCoin и выбрать другой день в будущем для его продажи.

В результате надо вывести максимальную прибыль, которую можно получить. Кроме того, есть возможность отказаться от совершения каких-либо транзакций, и в этом случае прибыль будет равна 0.

Пример 1:
Input: prices = [10,1,5,6,7,1]
Output: 6
Пояснение: купить за prices[1] и продать по prices[4]. В итоге, прибыль = 7 – 1 = 6.

Пример 2:
Input: prices = [10,8,7,5,2]
Output: 0
Пояснение: Невозможно совершить прибыльные сделки, поэтому максимальная прибыль равна 0.

Проверка скобок

Проблема: Дана строка s, состоящая из следующих символов: '(', ')', '{', '}', '[' и ']'. Входная строка s действительна тогда и только тогда, когда:
- Каждая открытая скобка закрывается закрывающей скобкой одного и того же типа.
- Открытые скобки закрываются в правильном порядке.
- Каждой закрывающей скобке соответствует открытая скобка того же типа.

В результате надо вывести true, если s — допустимая строка, и false в противном случае.

Пример 1:
Input: s = "([{}])"
Output: true

Пример 2:
Input: s = "[(])"
Output: false

Обратная польская запись

Проблема: Дан массив строковых токенов, который представляет допустимое арифметическое выражение в обратной польской нотации. В результате возвращает целое число, представляющее оценку выражения.

Операнды могут быть целыми числами или результатами других операций. К операторам относятся «+», «-», «*» и «/». Предположим, что деление целых чисел всегда сокращается до нуля.

Пример:
Input: tokens = ["1","2","+","3","*","4","-"]
Output: 5
Объяснение: ((1 + 2) * 3) - 4 = 5

Температура воздуха

Проблема: Дан массив целых чисел, где температура[i] представляет собой дневную температуру в i-й день.

Необходимо реализовать алгоритм, который возвращает результат массива, где result[i] — это количество дней после i-го дня до появления более высокой температуры в будущий день. Если в будущем не будет дня, когда в i-й день будет более высокая температура, вместо этого установите result[i] в ​​0.

Пример 1:
Input: temperatures = [30,38,30,36,35,40,28]
Output: [1,4,1,2,1,0,0]

Пример 2:
Input: temperatures = [22,21,20]
Output: [0,0,0]

Самый большой прямоугольник в гистограмме

Проблема: Дан массив целых чисел heights, где heights[i] представляет высоту столбца. Ширина каждого столбца равна 1.

Необходимо реализовать алгоритм, который возвращает площадь наибольшего прямоугольника, который может быть сформирован среди столбцов.

function largestRectangleArea(heights) {
    heights.append(0) 
    stack = empty stack
    max_area = 0

    for i from 0 to length(heights) - 1 {
        while stack is not empty and 
        heights[i] < heights[stack.top()] {
            height = heights[stack.pop()]
            width = if stack is empty ? i : i - stack.top() - 1
            max_area = max(max_area, height * width)
        }
        stack.push(i)
    }
    return max_area
}

Поиск в 2D-матрице

Проблема: Дана двумерная целочисленная матрица (matrix) размера m x n и число (target), которое надо найти в матрице. Каждая строка матрицы сортируется в порядке неубывания. Первое целое число каждой строки больше последнего целого числа предыдущей строки. Необходимо реализовать алгоритм, который возвращает true, если число найдено в матрице, или false в противном случае.

Пример:
Input: matrix = [[1,2,4,8],[10,11,12,13],[14,20,30,40]], target = 10
Output: true

Поедание бананов

Проблема: Дан целочисленный массив piles, где piles[i] — количество бананов в i-й стопке. Вам также дано целое число h, которое представляет собой количество часов, в течение которых вам нужно съесть все бананы.

Необходимо установить норму потребления бананов в час, равную k. Каждый час вы можете выбрать стопку бананов и съесть k бананов из этой стопки. Если в кучке меньше k бананов, вы можете съесть эту кучу, но не сможете съесть другую кучу в тот же час.

Реализуемый алгоритм должен возвращать минимальное целое число k такое, что вы сможете съесть все бананы за h часов.

Пример 1:
Input: piles = [1,4,3,2], h = 9
Output: 2

Пример 2:
Input: piles = [25,10,23,4], h = 4
Output: 25

Найти минимум в повернутом отсортированном массиве

Проблема: Дан массив длины n, который изначально был отсортирован по возрастанию. Далее его поворачивали от 1 до n раз. Например, массив nums = [1,2,3,4,5,6] может выглядеть следующим образом:
[3,4,5,6,1,2], если его повернули 4 раза.
[1,2,3,4,5,6], если он был повернут 6 раз.

Обратим внимание, что поворот массива 4 раза перемещает последние четыре элемента массива в начало. Вращение массива 6 раз дает исходный массив.

Предполагая, что все элементы в повернутом отсортированном массиве уникальны, реализуемый алгоритм должен возвращать минимальный элемент этого массива. Решение, работающее за время O(n), тривиально, поэтому реализацию должна быть за время O(log n).

Пример 1: Input: nums = [3,4,5,6,1,2]
Output: 1

Пример 2: Input: nums = [4,5,0,1,2,3]
Output: 0

Поиск в повернутом отсортированном массиве

Проблема: Дан массив длины n, который изначально был отсортирован по возрастанию. Далее его поворачивали от 1 до n раз. Например, массив nums = [1,2,3,4,5,6] может выглядеть следующим образом:
[3,4,5,6,1,2], если его повернули 4 раза.
[1,2,3,4,5,6], если он был повернут 6 раз.

Учитывая повернутый отсортированный массив nums и число (target), которое надо найти, алгоритм должен возвращать индекс target в пределах nums или -1, если он отсутствует. Предполагается, что все элементы в отсортированном повернутом массиве уникальны.

Решение, работающее за время O(n), тривиально, поэтому реализацию должна быть за время O(log n).

Пример 1: Input: nums = [3,4,5,6,1,2], target = 1
Output: 4

Пример 2: Input: nums = [3,5,6,0,1,2], target = 4
Output: -1

Медиана двух отсортированных массивов

Проблема: Даны два целочисленных массива nums1 и nums2 размера m и n соответственно, каждый из которых отсортирован в порядке возрастания. Необходимо реализовать алгоритм, который возвращает медианное значение среди всех элементов двух массивов.

Медиана набора чисел — это значение, отделяющее верхнюю половину от нижней половины данных.

Решение работает за O(log(m+n)) времени.

Пример 1: Input: nums1 = [1,2], nums2 = [3]
Output: 2.0

Пример 2: Input: nums1 = [1,3], nums2 = [2,4]
Output: 2.5

Найти повторяющееся число

Проблема: Дан массив целых чисел nums, содержащий n + 1 целое число. Каждое целое число в nums находится в диапазоне [1, n] включительно.

Каждое целое число встречается ровно один раз, за ​​исключением одного целого числа, которое встречается два или более раз. Необходимо реализовать алгоритм, который возвращает число, которое встречается более одного раза.

Решение не изменяет числа массива и использует O(1) дополнительное пространство.

Один из наиболее эффективных методов использует идею цикла (tortoise and hare), аналогичную той, которая используется в проблеме обнаружения цикла в связном списке.

Пример 1: Input: nums = [1,2,3,2,2]
Output: 2

Пример 2: Input: nums = [1,2,3,4,4]
Output: 4