[Условие] Leetcode #1. Two sum

Ссылка на задачу на Leetcode
Решение

У нас есть массив чисел nums и число target.
Нужно написать функцию, которая возвращает индексы двух чисел из массива nums, которые в сумме дают target. Нельзя использовать один и тот же элемент дважды.
Считаем, что у задачи всегда есть решение и оно только одно.

Отдельный пункт: постараться найти решение, у которого временная сложность меньше O(n^2).

Кейс #1: 
nums = [2,7,11,15]
target = 9
output = [0,1]

Кейс #2:
nums = [3,2,4]
target = 6
output: [1,2]

Кейс #3:
nums = [3,3]
target = 6
output = [0,1]

#easy #arrays #twopointers #hashtable

@leetcode_furrycat

[Решение] Leetcode #1. Two sum

Условие задачи

👉 Решение #1. Самое очевидное

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

Временная сложность - O(n^2), так как мы дважды перебираем массив.

👉 Решение #2. Хеш-таблица

Заводим хеш-таблицу hash.
Перебираем каждый элемент массива nums в цикле.
Вычитаем его из target - это искомая пара.
Смотрим, есть ли эта пара в hash. Если есть - решение найдено.
Если нет, записываем текущий элемент в хеш. Ключом является сам элемент, чтобы его было просто найти, а значением - его индекс в массиве.

Временная сложность - O(n), так как цикл по массиву тут всего один. Время записи и извлечения значения в/из хеш-таблицы - константа.

👉 Решение #3. Два указателя

Сортируем массив, так чтобы числа в нем шли по порядку, например, от меньше к большему.
Устанавливаем один указать в начало массива (с меньшего числа) , а второй - в конец (с большего числа).
Складываем элементы под указателями. Если полученная сумма больше target, двигаем правый указатель влево (уменьшаем число под ним).
Если полученная сумма меньше target, двигаем левый указатель вправо (увеличиваем число под ним).

Временная сложноть - O(n * log n). Это сложность алгоритма сортировки. Сам поиск пары имеет сложность O(n).

Видео с разбором всех трех решений (англ.)

#easy #arrays #twopointers #hashtable

@leetcode_furrycat

Решенные задачи

1 - Two sum
2 - Add two numbers
3 - Longest Substring Without Repeating Characters
4 - Median of Two Sorted Arrays
5 - Longest Palindromic Substring
10 - Regular Expression Matching
11 - Container With Most Water
15 - 3Sum
33 - Search in Rotated Sorted Array
53 - Maximum Subarray
121 - Best Time to Buy and Sell Stock
152 - Maximum Product Subarray
153 - Find Minimum in Rotated Sorted Array
217 - Contains Duplicate
238 - Product of Array Except Self

По сложности

#easy
#medium
#hard

По темам и методам решения

#strings
#arrays
#linkedlists
#dp
#divideandconquer
#twopointers
#hashtable
#prefixsum

#ретро

[Условие] Leetcode #2. Add two numbers

Ссылка на задачу на Leetcode
Решение

Есть два связных списка, каждый из которых представляет неотрицательное число. Цифры (разряды) при этом идут в обратном порядке.
Узел связного списка представлен классом ListNode с полями val и next.

Пример: число 307 будет выглядеть как [7, 0, 3] - соответственно каждое число - это объект ListNode.

Задача: нужно сложить два этих неотрицательных числа, представленных в виде списков, и вернуть результат тоже в виде связного списка.

Пример 1:
l1 = [2,4,3]
l2 = [5,6,4]
Output: [7,0,8] 
Объяснение: 342 + 465 = 807

Пример 2: 
l1 = [0]
l2 = [0]
Output: [0]

Пример 3:
l1 = [9,9,9,9,9,9,9]
l2 = [9,9,9,9]
output = [8,9,9,9,0,0,0,1]

Ограничения:
- ведущих нулей у чисел нет, но число вполне может быть равно нулю
- в каждом списке от 1 до 100 узлов
- каждый узел имеет значение от 0 до 9

#medium #linkedlists

@leetcode_furrycat

[Решение] Leetcode #2. Add two numbers

Условие задачи

Решение основано на правиле сложения в столбик. Так как оба числа у нас идут с конца, мы можем последовательно складывать их разряды - а результат записывать в новый связный список. Не забываем про переходящие через разряд значения ("0 пишем, 1 в уме").

Продолжаем складывать до тех пор, пока хотя бы у одного числа остаются разряды. И не забываем добавить то, что "в уме", если разряды вдруг кончились.

Видео решения

#medium #linkedlists

@leetcode_furrycat

[Условие] Leetcode #3. Longest Substring Without Repeating Characters

Ссылка на задачу на Leetcode
Решение

На вход дается строка s. Нужно найти самую длинную подстроку без повторений.

Пример #1:
s = 'abcabcbb'
output: 3 // 'abc'

Пример #2:
s = 'bbbbb'
output: 1 // 'b'

Пример #3:
s = 'pwwkew'
output: 3 // 'wke'

Ограничения:
- длина строки до 5 * 10^4
- содержать может английские буквы, цифры, символы и пробелы

#medium #strings

@leetcode_furrycat

[Решение] Leetcode #3. Longest Substring Without Repeating Characters

Условие задачи

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

Пример для s = abcbac:

- считаем подстроку с нулевого символа (currentIndex = 0)
- перебираем символы по одному и заносим их в хеш вместе с индексами: { a: 0, b: 1, c: 2 }
- текущий индекс 3 - i = 3, символ b, видим, что он уже встречался на 1-й позиции. Значит, строка без повторений кончилась. Сохраняем ее длину (с нулевого символа до 3 невключительно: max = 3)
- обновляем индекс символа b в хеше: { a: 0, b: 3, c: 2 }
- начинаем новый отсчет со следующего за повторенным символа (currentIndex = 2)
- i = 4, символ a - сохраненный индекс 0, но это меньше, чем начало нашей текущей подстроки, так что можно считать, что символа a у нас еще не было.
- i = 5, символ c - сохраненный индекс 2 - это попадает в нашу строку, поэтому заканчиваем ее. Длина полученной подстроки равна 3 (со 2-го по 5 символ невключительно). Она не больше текущего max, так что можно не перезаписывать.

Итого, ответ 3.

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

#medium #strings

@leetcode_furrycat

[Условие] Leetcode #10. Regular Expression Matching

Ссылка на задачу на Leetcode
Решение

Нужно реализовать простейшее регулярное выражение. На вход получаем строку s и паттерн p. Задача - проверить, соответствует ли строка паттерну.
Проверяется полное совпадение строки - от начала и до конца.

Строка содержит только английские буквы в нижнем регистре.

Паттерн может содержать английские буквы в нижнем регистре, а также символы . и *.
При этом символ . означает "один любой символ".
А символ * относится к предыдущему символу и означает "0 или больше". То есть паттерн "a*" соответствует строкам "a", "aa", "aaaaaa", а также пустой строке "".

В паттерне может быть комбинация ".*", которая означает "0 и более любых символов".

Пример #1:

s = "aa", p = "a"
output: false (строка совпадает не полностью)

Пример #2:

s = "aa", p = "a*"
output: true

Пример #3:

s = "ab", p = ".*"
output: true

Подсказка: следует использовать динамическое программирование

#hard #dp

@leetcode_furrycat

[Решение] Leetcode #10. Regular Expression Matching

Условие задачи

Решение получилось объемным, поэтому отдельно: https://telegra.ph/Leetcode-10-Regular-Expression-Matching-Reshenie-04-17

#hard #dp

@leetcode_furrycat

[Условие] Leetcode #4. Median of Two Sorted Arrays

Ссылка на задачу на Leetcode
Решение (часть 1 и часть 2)

Получаем два отсортированных массива: nums1 с длиной m и nums2 с длиной n. Возвращаем их медиану (серединное значение). Временная сложность должна быть O(log (m + n)).

Кейс #1:
nums1 = [1,3]
nums2 = [2]
Output: 2 
Объяснение: общий массив - [1,2,3], медиана - 2

Кейс #2:
nums1 = [1,2]
nums2 = [3,4]
Output: 2.5
Объяснение: общий массив - [1,2,3,4], медиана - (2+3)/2 = 2.5

#hard #arrays

@leetcode_furrycat