#medium
Задача: 393. UTF-8 Validation

Дан целочисленный массив data, представляющий данные, верните, является ли это допустимой UTF-8 кодировкой (т.е. переводится в последовательность допустимых UTF-8 закодированных символов).

Символ в UTF-8 может быть от 1 до 4 байтов в длину, при этом соблюдаются следующие правила:

Для 1-байтового символа первый бит — 0, за которым следует его Unicode код.
Для n-байтового символа первые n битов — все единицы, (n + 1)-й бит — 0, за которыми следуют n - 1 байт с наиболее значимыми 2 битами, равными 10.
Это работает следующим образом:

     Количество байтов  |        UTF-8 Октетная последовательность
                       |              (бинарная)
   --------------------+-----------------------------------------
            1          |   0xxxxxxx
            2          |   110xxxxx 10xxxxxx
            3          |   1110xxxx 10xxxxxx 10xxxxxx
            4          |   11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

x обозначает бит в бинарной форме байта, который может быть как 0, так и 1.

Примечание: Вход представляет собой массив целых чисел. Используются только 8 младших значимых битов каждого целого числа. Это означает, что каждое целое число представляет только 1 байт данных.

Пример:

Input: data = [197,130,1]
Output: true
Explanation: data represents the octet sequence: 11000101 10000010 00000001.
It is a valid utf-8 encoding for a 2-bytes character followed by a 1-byte character.

👨‍💻 Алгоритм:

1⃣Начните обработку целых чисел в данном массиве одно за другим. Для каждого целого числа получите его двоичное представление в виде строки. Поскольку целые числа могут быть очень большими, следует учитывать только 8 младших значимых битов данных и отбросить остальные, как указано в условии задачи. После этого шага у вас должно быть 8-битное или 1-байтовое строковое представление целого числа. Назовем эту строку bin_rep.

2⃣Далее нужно рассмотреть два сценария. Первый — мы находимся в процессе обработки некоторого UTF-8 закодированного символа. В этом случае нужно просто проверить первые два бита строки и посмотреть, равны ли они "10", т.е. наиболее значимые два бита целого числа равны 1 и 0. bin_rep[:2] == "10". Второй сценарий — мы уже обработали несколько допустимых UTF-8 символов и должны начать обработку нового UTF-8 символа. В этом случае нужно посмотреть на префикс строкового представления и посчитать количество единиц, которые мы встречаем до первой нули. Это скажет нам, каков размер следующего UTF-8 символа.

3⃣Продолжайте обрабатывать целые числа массива таким образом, пока не обработаете их все или не обнаружите недопустимый сценарий.

Теперь давайте перейдем к реализации этого алгоритма.

😎 Решение:

class Solution {
    func validUtf8(_ data: [Int]) -> Bool {
        var nBytes = 0
        
        for num in data {
            let binRep = String(num, radix: 2).suffix(8).padLeft(toLength: 8, withPad: "0")
            
            if nBytes == 0 {
                for bit in binRep {
                    if bit == "0" { break }
                    nBytes += 1
                }
                
                if nBytes == 0 {
                    continue
                }
                
                if nBytes == 1 || nBytes > 4 {
                    return false
                }
            } else {
                if !(binRep.prefix(2) == "10") {
                    return false
                }
            }
            
            nBytes -= 1
        }
        
        return nBytes == 0
    }
}

extension String {
    func padLeft(toLength: Int, withPad: String) -> String {
        let newLength = self.count
        if newLength < toLength {
            return String(repeatElement(withPad, count: toLength - newLength)) + self
        } else {
            return String(self.suffix(toLength))
        }
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 294. Flip Game II

Вы играете в игру Flip со своим другом.

Вам дана строка currentState, которая содержит только символы '+' и '-'. Вы и ваш друг по очереди переворачиваете две последовательные "++" в "--". Игра заканчивается, когда игрок больше не может сделать ход, и, следовательно, другой игрок становится победителем.

Верните true, если начальный игрок может гарантировать победу, и false в противном случае.

Пример:

Input: currentState = "++++"
Output: true
Explanation: The starting player can guarantee a win by flipping the middle "++" to become "+--+".

👨‍💻 Алгоритм:

1⃣Генерация всех возможных следующих ходов:
Для текущего состояния currentState, создайте все возможные новые состояния, заменяя каждую пару "++" на "--".

2⃣Рекурсивная проверка выигрыша:
Для каждого нового состояния вызовите функцию рекурсивно, чтобы проверить, может ли противник проиграть в этом новом состоянии.
Если противник не может сделать ход, верните true, так как начальный игрок гарантирует победу.

3⃣Проверка всех возможных ходов:
Если для всех возможных ходов начальный игрок не может гарантировать победу, верните false.
Иначе, если есть хотя бы один ход, при котором противник проигрывает, верните true.

😎 Решение:

class Solution {
    func canWin(_ currentState: String) -> Bool {
        var stateArray = Array(currentState)
        
        for i in 0..<(stateArray.count - 1) {
            if stateArray[i] == "+" && stateArray[i + 1] == "+" {
                stateArray[i] = "-"
                stateArray[i + 1] = "-"
                let newState = String(stateArray)
                
                if !canWin(newState) {
                    stateArray[i] = "+"
                    stateArray[i + 1] = "+"
                    return true
                }
                
                stateArray[i] = "+"
                stateArray[i + 1] = "+"
            }
        }
        
        return false
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#hard
Задача: 295. Find Median from Data Stream

Медиана — это среднее значение в упорядоченном списке целых чисел. Если размер списка четный, то медианы нет, и медиана — это среднее арифметическое двух средних значений.

Например, для arr = [2, 3, 4] медиана равна 3.
Например, для arr = [2, 3] медиана равна (2 + 3) / 2 = 2.5.

Реализуйте класс MedianFinder:

MedianFinder() инициализирует объект MedianFinder.
void addNum(int num) добавляет целое число num из потока данных в структуру данных.
double findMedian() возвращает медиану всех элементов на данный момент. Ответы с точностью до 10^-5 от фактического ответа будут приниматься.

Пример:

Input
["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
[[], [1], [2], [], [3], []]
Output
[null, null, null, 1.5, null, 2.0]

Explanation
MedianFinder medianFinder = new MedianFinder();
medianFinder.addNum(1);    // arr = [1]
medianFinder.addNum(2);    // arr = [1, 2]
medianFinder.findMedian(); // return 1.5 (i.e., (1 + 2) / 2)
medianFinder.addNum(3);    // arr[1, 2, 3]
medianFinder.findMedian(); // return 2.0

👨‍💻 Алгоритм:

1⃣Храните числа в контейнере с возможностью изменения размера:
Создайте массив для хранения чисел.

2⃣Добавление нового числа:
Добавьте новое число в массив.

3⃣Вычисление и вывод медианы:
Отсортируйте массив.
Если размер массива нечетный, верните среднее значение массива.
Если размер массива четный, верните среднее арифметическое двух средних значений массива.

😎 Решение:

class MedianFinder {
    private var numbers: [Int] = []

    func addNum(_ num: Int) {
        numbers.append(num)
    }

    func findMedian() -> Double {
        numbers.sort()
        let n = numbers.count
        if n % 2 == 0 {
            return Double(numbers[n / 2 - 1] + numbers[n / 2]) / 2.0
        } else {
            return Double(numbers[n / 2])
        }
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#hard
Задача: 296. Best Meeting Point

Дан бинарный сетка размером m x n, где каждая 1 обозначает дом одного друга. Верните минимальное общее расстояние путешествия.

Общее расстояние путешествия — это сумма расстояний между домами друзей и точкой встречи.

Расстояние рассчитывается по Манхэттенскому расстоянию, где distance(p1, p2) = |p2.x - p1.x| + |p2.y - p1.y|.

Пример:

Input: grid = [[1,0,0,0,1],[0,0,0,0,0],[0,0,1,0,0]]
Output: 6
Explanation: Given three friends living at (0,0), (0,4), and (2,2).
The point (0,2) is an ideal meeting point, as the total travel distance of 2 + 2 + 2 = 6 is minimal.
So return 6.

👨‍💻 Алгоритм:

1⃣Определение координат домов:
Пройдите по сетке и соберите координаты всех домов (ячейки с значением 1) в два списка: один для координат x и один для координат y.

2⃣Нахождение медианы:
Отсортируйте списки координат x и y.
Найдите медианы в обоих списках. Медианы координат x и y укажут оптимальную точку встречи.

3⃣Вычисление минимального общего расстояния:
Вычислите сумму Манхэттенских расстояний от каждого дома до точки встречи, используя найденные медианы в качестве координат точки встречи.
Верните это значение как минимальное общее расстояние путешествия.

😎 Решение:

import Foundation

class Solution {
    func minTotalDistance(_ grid: [[Int]]) -> Int {
        var minDistance = Int.max
        for row in 0..<grid.count {
            for col in 0..<grid[0].count {
                let distance = search(grid, row, col)
                minDistance = min(distance, minDistance)
            }
        }
        return minDistance
    }

    private func search(_ grid: [[Int]], _ row: Int, _ col: Int) -> Int {
        var q: [(Int, Int, Int)] = [(row, col, 0)]
        let m = grid.count
        let n = grid[0].count
        var visited = Array(repeating: Array(repeating: false, count: n), count: m)
        var totalDistance = 0
        
        while !q.isEmpty {
            let point = q.removeFirst()
            let r = point.0
            let c = point.1
            let d = point.2
            
            if r < 0 || c < 0 || r >= m || c >= n || visited[r][c] {
                continue
            }
            
            if grid[r][c] == 1 {
                totalDistance += d
            }
            
            visited[r][c] = true
            
            q.append((r + 1, c, d + 1))
            q.append((r - 1, c, d + 1))
            q.append((r, c + 1, d + 1))
            q.append((r, c - 1, d + 1))
        }
        
        return totalDistance
    }

    public class Point {
        var row: Int
        var col: Int
        var distance: Int
        
        public init(_ row: Int, _ col: Int, _ distance: Int) {
            self.row = row
            self.col = col
            self.distance = distance
        }
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#hard
Задача: 297. Serialize and Deserialize Binary Tree

Сериализация — это процесс преобразования структуры данных или объекта в последовательность битов, чтобы их можно было сохранить в файле или буфере памяти или передать по сетевому соединению для последующего восстановления в той же или другой компьютерной среде.

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

Уточнение: формат ввода/вывода такой же, как в LeetCode для сериализации бинарного дерева. Вам не обязательно придерживаться этого формата, так что будьте креативны и придумайте свои подходы.

Пример:

Input: root = [1,2,3,null,null,4,5]
Output: [1,2,3,null,null,4,5]

👨‍💻 Алгоритм:

1⃣Сериализация дерева:
Используйте рекурсивный обход дерева в порядке root -> left subtree -> right subtree.
Для каждого узла добавляйте его значение в строку сериализации. Если узел пустой, добавляйте "None".

2⃣Пример:
Начните с корня, узел 1, строка сериализации становится "1,".
Переходите к левому поддереву с корнем 2, строка сериализации становится "1,2,".
Для узла 2, посетите его левый узел 3 ("1,2,3,None,None,") и правый узел 4 ("1,2,3,None,None,4,None,None").
Возвращайтесь к корню 1 и посетите его правое поддерево, узел 5 ("1,2,3,None,None,4,None,None,5,None,None,").

3⃣Десериализация строки:
Разделите строку на список значений.
Используйте рекурсивную функцию для создания узлов дерева, извлекая значения из списка и восстанавливая структуру дерева. Если значение "None", узел пустой.

😎 Решение:

public class TreeNode {
    public var val: Int
    public var left: TreeNode?
    public var right: TreeNode?
    public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
}

public class Codec {
    func rserialize(_ root: TreeNode?, _ str: inout String) {
        if root == nil {
            str += "null,"
        } else {
            str += "\(root!.val),"
            rserialize(root!.left, &str)
            rserialize(root!.right, &str)
        }
    }

    public func serialize(_ root: TreeNode?) -> String {
        var str = ""
        rserialize(root, &str)
        return str
    }

    func rdeserialize(_ data: inout [String]) -> TreeNode? {
        if data[0] == "null" {
            data.remove(at: 0)
            return nil
        }

        let root = TreeNode(Int(data.remove(at: 0))!)
        root.left = rdeserialize(&data)
        root.right = rdeserialize(&data)

        return root
    }

    public func deserialize(_ data: String) -> TreeNode? {
        var dataArray = data.split(separator: ",").map { String($0) }
        return rdeserialize(&dataArray)
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 394. Decode String

Дана закодированная строка, вернуть её декодированную версию.

Правило кодирования следующее: k[закодированная_строка], где закодированная_строка внутри квадратных скобок повторяется ровно k раз. Обратите внимание, что k гарантированно является положительным целым числом.

Можно предположить, что входная строка всегда допустима; нет лишних пробелов, квадратные скобки корректно сформированы и т.д. Более того, можно предположить, что исходные данные не содержат никаких цифр, и что цифры используются только для обозначения количества повторений, k. Например, не будет таких входных данных, как 3a или 2[4].

Тестовые случаи сгенерированы так, что длина выходной строки никогда не превысит 105.

Пример:

Input: s = "3[a]2[bc]"
Output: "aaabcbc"

👨‍💻 Алгоритм:

1⃣Проходите по строке s и обрабатывайте каждый символ. Если текущий символ не является закрывающей скобкой ], поместите его в стек.

2⃣Если текущий символ является закрывающей скобкой ], начните декодировать последнюю пройденную строку. Извлекайте из стека символы, пока следующий символ не станет открывающей скобкой [, и добавляйте каждый символ (a-z) к decodedString. Затем извлеките открывающую скобку [ из стека и извлекайте символы, пока следующий символ является цифрой (0-9), чтобы собрать число k.

3⃣Декодируйте шаблон k[decodedString], помещая decodedString в стек k раз. После того как вся строка будет пройдена, извлеките результат из стека и верните его.

😎 Решение:

class Solution {
    func decodeString(_ s: String) -> String {
        var stack = [Character]()
        
        for char in s {
            if char == "]" {
                var decodedString = ""
                while let last = stack.last, last != "[" {
                    decodedString = String(stack.removeLast()) + decodedString
                }
                stack.removeLast()
                
                var k = 0
                var base = 1
                while let last = stack.last, let digit = last.wholeNumberValue {
                    k += digit * base
                    base *= 10
                    stack.removeLast()
                }
                
                for _ in 0..<k {
                    for c in decodedString {
                        stack.append(c)
                    }
                }
            } else {
                stack.append(char)
            }
        }
        
        return String(stack)
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 298. Binary Tree Longest Consecutive Sequence

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

Путь последовательных значений — это путь, где значения увеличиваются на единицу вдоль пути.

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

Пример:

Input: root = [1,null,3,2,4,null,null,null,5]
Output: 3
Explanation: Longest consecutive sequence path is 3-4-5, so return 3.

👨‍💻 Алгоритм:

1⃣Инициализация и начало обхода:
Начните обход дерева с корневого узла.
Инициализируйте переменную length, чтобы хранить текущую длину последовательного пути, и передавайте её вниз по дереву.

2⃣Сравнение текущего узла с родительским узлом:
Для каждого узла сравните его значение со значением родительского узла.
Если значение текущего узла на единицу больше значения родительского узла, увеличьте length.
Если значение текущего узла не является последовательным (не больше на единицу), сбросьте length на 1.

3⃣Обход дерева:
Рекурсивно обходите левое и правое поддерево, передавая обновлённое значение length.
В каждом узле обновляйте максимальную длину последовательного пути, если текущая длина больше.

😎 Решение:

class Solution {
    private var maxLength = 0

    func longestConsecutive(_ root: TreeNode?) -> Int {
        dfs(root, nil, 0)
        return maxLength
    }

    private func dfs(_ node: TreeNode?, _ parent: TreeNode?, _ length: Int) {
        guard let node = node else { return }
        var currentLength = length
        if let parent = parent, node.val == parent.val + 1 {
            currentLength += 1
        } else {
            currentLength = 1
        }
        maxLength = max(maxLength, currentLength)
        dfs(node.left, node, currentLength)
        dfs(node.right, node, currentLength)
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 299. Bulls and Cows

Вы играете в игру "Быки и коровы" со своим другом.

Вы записываете секретное число и просите своего друга угадать, что это за число. Когда ваш друг делает предположение, вы даете ему подсказку со следующей информацией:

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

Подсказка должна быть в формате "xAyB", где x — количество быков, а y — количество коров. Обратите внимание, что и secret, и guess могут содержать повторяющиеся цифры.

Пример:

Input: secret = "1807", guess = "7810"
Output: "1A3B"
Explanation: Bulls are connected with a '|' and cows are underlined:
"1807"
  |
"7810"

👨‍💻 Алгоритм:

1⃣Инициализация счетчиков:
Инициализируйте количество быков и коров значениями ноль.
Создайте хеш-таблицу для хранения символов строки secret и их частот.


2⃣Обход строки guess:
Для каждого символа ch в строке guess:
Если ch присутствует в строке secret:
Если текущий символ ch совпадает с символом на той же позиции в secret (ch == secret[idx]):
Увеличьте количество быков: bulls += 1.
Обновите количество коров, если количество текущего символа в хеш-таблице отрицательное или равно нулю (то есть этот символ уже использовался для коров): cows -= int(h[ch] <= 0).
Если текущий символ ch не совпадает с символом на той же позиции в secret (ch != secret[idx]):
Увеличьте количество коров, если количество текущего символа в хеш-таблице больше нуля: cows += int(h[ch] > 0).
Обновите хеш-таблицу, помечая текущий символ как использованный: h[ch] -= 1.


3⃣Возврат результата:
Верните количество быков и коров в формате "xAyB".

😎 Решение:

class Solution {
    func getHint(_ secret: String, _ guess: String) -> String {
        var h = [Character: Int]()
        for ch in secret {
            h[ch, default: 0] += 1
        }

        var bulls = 0
        var cows = 0
        let n = guess.count
        let secretArray = Array(secret)
        let guessArray = Array(guess)

        for idx in 0..<n {
            let ch = guessArray[idx]
            if h[ch] != nil {
                if ch == secretArray[idx] {
                    bulls += 1
                    if h[ch]! <= 0 {
                        cows -= 1
                    }
                } else {
                    if h[ch]! > 0 {
                        cows += 1
                    }
                }
                h[ch]! -= 1
            }
        }

        return "\(bulls)A\(cows)B"
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 300. Longest Increasing Subsequence

Дан массив целых чисел nums, верните длину самой длинной строго возрастающей подпоследовательности.

Пример:

Input: nums = [10,9,2,5,3,7,101,18]
Output: 4
Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.

👨‍💻 Алгоритм:

1⃣Инициализируйте массив dp длиной nums.length, все элементы которого равны 1. dp[i] представляет длину самой длинной возрастающей подпоследовательности, которая заканчивается элементом с индексом i.


2⃣Итерируйтесь от i = 1 до i = nums.length - 1. В каждой итерации используйте второй цикл for для итерации от j = 0 до j = i - 1 (все элементы перед i). Для каждого элемента перед i, проверьте, меньше ли этот элемент, чем nums[i]. Если да, установите dp[i] = max(dp[i], dp[j] + 1).


3⃣Верните максимальное значение из dp.

😎 Решение:

class Solution {
    func lengthOfLIS(_ nums: [Int]) -> Int {
        var dp = [Int](repeating: 1, count: nums.count)
        
        for i in 1..<nums.count {
            for j in 0..<i {
                if nums[i] > nums[j] {
                    dp[i] = max(dp[i], dp[j] + 1)
                }
            }
        }
        
        return dp.max() ?? 0
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#hard
Задача: 301. Remove Invalid Parentheses

Дана строка s, содержащая скобки и буквы. Удалите минимальное количество неверных скобок, чтобы сделать строку допустимой.

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

Пример:

Input: s = "()())()"
Output: ["(())()","()()()"]

👨‍💻 Алгоритм:

1⃣Инициализация:
Инициализируйте массив, который будет хранить все допустимые выражения.
Начните рекурсию с самой левой скобки в последовательности и двигайтесь вправо.
Определите состояние рекурсии переменной index, представляющей текущий обрабатываемый индекс в исходном выражении. Также используйте переменные left_count и right_count для отслеживания количества добавленных левых и правых скобок соответственно.

2⃣Обработка текущего символа:
Если текущий символ (S[i]) не является скобкой, добавьте его к окончательному решению для текущей рекурсии.
Если текущий символ является скобкой (S[i] == '(' или S[i] == ')'), у вас есть два варианта: либо отбросить этот символ как недопустимый, либо рассмотреть эту скобку как часть окончательного выражения.

3⃣Завершение рекурсии и проверка:
Когда все скобки в исходном выражении обработаны, проверьте, является ли текущее выражение допустимым, проверяя значения left_count и right_count (должны быть равны).
Если выражение допустимо, проверьте количество удалений (rem_count) и сравните его с минимальным количеством удалений, необходимых для получения допустимого выражения до сих пор.
Если текущее значение rem_count меньше, обновите глобальный минимум и добавьте новое выражение в массив допустимых выражений.

😎 Решение:

class Solution {
    private var validExpressions = Set<String>()
    private var minimumRemoved: Int = Int.max

    private func reset() {
        self.validExpressions.removeAll()
        self.minimumRemoved = Int.max
    }

    private func recurse(_ s: String, _ index: Int, _ leftCount: Int, _ rightCount: Int, _ expression: inout String, _ removedCount: Int) {
        if index == s.count {
            if leftCount == rightCount {
                if removedCount <= self.minimumRemoved {
                    let possibleAnswer = expression
                    if removedCount < self.minimumRemoved {
                        self.validExpressions.removeAll()
                        self.minimumRemoved = removedCount
                    }
                    self.validExpressions.insert(possibleAnswer)
                }
            }
            return
        }

        let currentCharacter = Array(s)[index]
        let length = expression.count

        if currentCharacter != "(" && currentCharacter != ")" {
            expression.append(currentCharacter)
            recurse(s, index + 1, leftCount, rightCount, &expression, removedCount)
            expression.removeLast()
        } else {
            recurse(s, index + 1, leftCount, rightCount, &expression, removedCount + 1)
            expression.append(currentCharacter)

            if currentCharacter == "(" {
                recurse(s, index + 1, leftCount + 1, rightCount, &expression, removedCount)
            } else if rightCount < leftCount {
                recurse(s, index + 1, leftCount, rightCount + 1, &expression, removedCount)
            }

            expression.removeLast()
        }
    }

    func removeInvalidParentheses(_ s: String) -> [String] {
        self.reset()
        var expression = ""
        self.recurse(s, 0, 0, 0, &expression, 0)
        return Array(self.validExpressions)
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 280. Wiggle Sort

Дан целочисленный массив nums, упорядочьте его так, чтобы nums[0] <= nums[1] >= nums[2] <= nums[3]....

Вы можете считать, что входной массив всегда имеет допустимый ответ.

Пример:

Input: nums = [3,5,2,1,6,4]
Output: [3,5,1,6,2,4]
Explanation: [1,6,2,5,3,4] is also accepted.

👨‍💻 Алгоритм:

1⃣Итерируйтесь по каждому элементу с индексом i в массиве nums, начиная с 0 и до nums.length - 2, так как последний элемент не имеет следующего элемента для обмена.

2⃣Проверьте, является ли i четным и nums[i] > nums[i + 1]. Если это так, поменяйте местами nums[i] и nums[i + 1].

3⃣Проверьте, является ли i нечетным и nums[i] < nums[i + 1]. Если это так, поменяйте местами nums[i] и nums[i + 1].

😎 Решение:

class Solution {
    func swap(_ nums: inout [Int], _ i: Int, _ j: Int) {
        let temp = nums[i]
        nums[i] = nums[j]
        nums[j] = temp
    }

    func wiggleSort(_ nums: inout [Int]) {
        for i in 0..<nums.count - 1 {
            if (i % 2 == 0 && nums[i] > nums[i + 1]) || (i % 2 == 1 && nums[i] < nums[i + 1]) {
                swap(&nums, i, i + 1)
            }
        }
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 395. Longest Substring with At Least K Repeating Characters


Дана строка s и целое число k, верните длину самой длинной подстроки строки s, такая что частота каждого символа в этой подстроке больше или равна k.

Если такой подстроки не существует, верните 0.

Пример:

Input: s = "aaabb", k = 3
Output: 3
Explanation: The longest substring is "aaa", as 'a' is repeated 3 times.

👨‍💻 Алгоритм:

1⃣Генерируйте подстроки из строки s, начиная с индекса start и заканчивая индексом end. Используйте массив countMap для хранения частоты каждого символа в подстроке.

2⃣Метод isValid использует countMap для проверки, что каждый символ в подстроке встречается как минимум k раз. Если условие выполняется, текущая подстрока считается допустимой.

3⃣Отслеживайте максимальную длину допустимой подстроки, обновляя её, когда найдена более длинная подстрока, удовлетворяющая условиям. В конце возвращайте длину самой длинной подстроки.

😎 Решение:

class Solution {
    func longestSubstring(_ s: String, _ k: Int) -> Int {
        let n = s.count
        if n == 0 || k > n {
            return 0
        }
        var countMap = [Int](repeating: 0, count: 26)
        var result = 0
        let sArray = Array(s)
        
        for start in 0..<n {
            countMap = [Int](repeating: 0, count: 26)
            for end in start..<n {
                countMap[Int(sArray[end].asciiValue! - Character("a").asciiValue!)] += 1
                if isValid(countMap, k) {
                    result = max(result, end - start + 1)
                }
            }
        }
        return result
    }
    
    func isValid(_ countMap: [Int], _ k: Int) -> Bool {
        var countLetters = 0, countAtLeastK = 0
        for count in countMap {
            if count > 0 { countLetters += 1 }
            if count >= k { countAtLeastK += 1 }
        }
        return countAtLeastK == countLetters
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 433. Minimum Genetic Mutation

Генетическая строка может быть представлена строкой длиной 8 символов, содержащей символы 'A', 'C', 'G' и 'T'.

Предположим, нам нужно исследовать мутацию от генетической строки startGene до генетической строки endGene, где одна мутация определяется как изменение одного символа в генетической строке.

Например, "AACCGGTT" --> "AACCGGTA" является одной мутацией.
Также существует генетический банк bank, который содержит все допустимые генетические мутации. Генетическая строка должна быть в банке, чтобы считаться допустимой.

Даны две генетические строки startGene и endGene и генетический банк bank, верните минимальное количество мутаций, необходимых для мутации от startGene до endGene. Если такой мутации не существует, верните -1.

Обратите внимание, что начальная строка считается допустимой, поэтому она может не быть включена в банк.

Пример:

Input: startGene = "AACCGGTT", endGene = "AACCGGTA", bank = ["AACCGGTA"]
Output: 1

👨‍💻 Алгоритм:

1⃣Инициализируйте очередь и множество seen. Очередь будет использоваться для выполнения BFS, а множество seen будет использоваться для предотвращения повторного посещения одного и того же узла. Изначально в очередь и множество должен быть помещен startGene.

2⃣Выполняйте BFS. На каждом узле, если node == endGene, верните количество шагов, пройденных до этого момента. В противном случае, итеративно заменяйте каждый символ в строке на один из "A", "C", "G", "T" для нахождения соседей. Для каждого соседа, если он еще не был посещен и находится в bank, добавьте его в очередь и в множество seen.

3⃣Если BFS завершился и endGene не был найден, задача невыполнима. Верните -1.

😎 Решение:

class Solution {
    func minMutation(_ start: String, _ end: String, _ bank: [String]) -> Int {
        var queue: [String] = [start]
        var seen: Set<String> = [start]
        var steps = 0
        
        while !queue.isEmpty {
            for _ in 0..<queue.count {
                let node = queue.removeFirst()
                
                if node == end {
                    return steps
                }
                
                for c in "ACGT" {
                    for i in node.indices {
                        var neighbor = Array(node)
                        neighbor[i] = c
                        let neighborStr = String(neighbor)
                        if !seen.contains(neighborStr) && bank.contains(neighborStr) {
                            queue.append(neighborStr)
                            seen.insert(neighborStr)
                        }
                    }
                }
            }
            steps += 1
        }
        
        return -1
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 281. Zigzag Iterator

Даны два вектора целых чисел v1 и v2, реализуйте итератор, который возвращает их элементы поочередно.

Реализуйте класс ZigzagIterator:
ZigzagIterator(List<int> v1, List<int> v2) инициализирует объект с двумя векторами v1 и v2.
boolean hasNext() возвращает true, если в итераторе еще есть элементы, и false в противном случае.
int next() возвращает текущий элемент итератора и перемещает итератор к следующему элементу.

Пример:

Input: v1 = [1,2], v2 = [3,4,5,6]
Output: [1,3,2,4,5,6]
Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,3,2,4,5,6].

👨‍💻 Алгоритм:

1⃣Инициализация объекта:
Создайте класс ZigzagIterator с двумя списками v1 и v2. Сохраните эти списки в структуре vectors.
Инициализируйте очередь queue, содержащую пары индексов: индекс списка и индекс элемента в этом списке, если список не пуст.

2⃣Метод next:
Удалите первую пару индексов из очереди.
Извлеките элемент из соответствующего списка по указанным индексам.
Если в текущем списке есть еще элементы, добавьте новую пару индексов (тот же список, следующий элемент) в конец очереди.
Верните извлеченный элемент.

3⃣Метод hasNext:
Проверьте, пуста ли очередь.
Верните true, если в очереди есть элементы, и false в противном случае.

😎 Решение:

class ZigzagIterator {
    private var vectors: [[Int]]
    private var queue: [(Int, Int)] = []

    init(_ v1: [Int], _ v2: [Int]) {
        self.vectors = [v1, v2]
        for (index, vec) in vectors.enumerated() {
            if !vec.isEmpty {
                queue.append((index, 0))
            }
        }
    }

    func next() -> Int {
        let (vecIndex, elemIndex) = queue.removeFirst()
        let nextElemIndex = elemIndex + 1
        if nextElemIndex < vectors[vecIndex].count {
            queue.append((vecIndex, nextElemIndex))
        }
        return vectors[vecIndex][elemIndex]
    }

    func hasNext() -> Bool {
        return !queue.isEmpty
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#hard
Задача: 282. Expression Add Operators

Дана строка num, содержащая только цифры, и целое число target. Верните все возможные варианты вставки бинарных операторов '+', '-', и/или '*' между цифрами строки num так, чтобы результирующее выражение вычислялось в значение target.

Учтите, что операнды в возвращаемых выражениях не должны содержать ведущих нулей.

Пример:

Input: num = "232", target = 8
Output: ["2*3+2","2+3*2"]
Explanation: Both "2*3+2" and "2+3*2" evaluate to 8.

👨‍💻 Алгоритм:

1⃣Инициализация и рекурсивный вызов:
Создайте класс Solution с полями для хранения результирующих выражений, строки цифр и целевого значения.
Инициализируйте эти поля в методе addOperators и запустите рекурсивный метод для генерации всех возможных выражений.

2⃣Рекурсивная генерация выражений:
В методе recurse на каждом шаге рассматривайте текущий индекс, предыдущий операнд, текущий операнд и текущее значение выражения.
Обрабатывайте все возможные операторы: без оператора (расширение текущего операнда), сложение, вычитание и умножение. На каждом шаге обновляйте текущее значение и выражение.

3⃣Проверка и запись валидных выражений:
Когда вся строка цифр обработана, проверяйте, соответствует ли итоговое значение целевому значению и нет ли остатков операндов.
Если выражение валидное, записывайте его в список результатов.

😎 Решение:

class Solution {
    var answer = [String]()
    var digits = ""
    var target: Int64 = 0

    func recurse(_ index: Int, _ previousOperand: Int64, _ currentOperand: Int64, _ value: Int64, _ ops: inout [String]) {
        if index == digits.count {
            if value == target && currentOperand == 0 {
                answer.append(ops.joined())
            }
            return
        }

        let nums = Array(digits)
        let currentDigit = Int64(String(nums[index]))!
        let currentOperand = currentOperand * 10 + currentDigit
        let currentValRep = String(currentOperand)

        if currentOperand > 0 {
            recurse(index + 1, previousOperand, currentOperand, value, &ops)
        }

        ops.append("+")
        ops.append(currentValRep)
        recurse(index + 1, currentOperand, 0, value + currentOperand, &ops)
        ops.removeLast(2)

        if !ops.isEmpty {
            ops.append("-")
            ops.append(currentValRep)
            recurse(index + 1, -currentOperand, 0, value - currentOperand, &ops)
            ops.removeLast(2)

            ops.append("*")
            ops.append(currentValRep)
            recurse(index + 1, currentOperand * previousOperand, 0, value - previousOperand + (currentOperand * previousOperand), &ops)
            ops.removeLast(2)
        }
    }

    func addOperators(_ num: String, _ target: Int) -> [String] {
        if num.isEmpty {
            return []
        }

        self.target = Int64(target)
        self.digits = num
        self.answer = []
        var ops = [String]()
        recurse(0, 0, 0, 0, &ops)
        return answer
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#easy
Задача: 283. Move Zeroes

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

Обратите внимание, что вы должны сделать это на месте, не создавая копию массива.

Пример:

Input: nums = [0,1,0,3,12]
Output: [1,3,12,0,0]

👨‍💻 Алгоритм:

1⃣Инициализация указателей:
Инициализируйте два указателя: lastNonZeroFoundAt для отслеживания позиции последнего ненулевого элемента и cur для итерации по массиву.

2⃣Итерация и обмен элементами:
Итерируйтесь по массиву с помощью указателя cur.
Если текущий элемент ненулевой, поменяйте его местами с элементом, на который указывает lastNonZeroFoundAt, и продвиньте указатель lastNonZeroFoundAt.

3⃣Завершение итерации:
Повторяйте шаг 2 до конца массива. В итоге все нули будут перемещены в конец массива, сохраняя относительный порядок ненулевых элементов.

😎 Решение:

class Solution {
    func moveZeroes(_ nums: inout [Int]) {
        var lastNonZeroFoundAt = 0
        for cur in 0..<nums.count {
            if nums[cur] != 0 {
                nums.swapAt(lastNonZeroFoundAt, cur)
                lastNonZeroFoundAt += 1
            }
        }
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 284. Peeking Iterator

Создайте итератор, который поддерживает операцию peek (просмотр следующего элемента) на существующем итераторе, помимо операций hasNext (проверка наличия следующего элемента) и next (получение следующего элемента).

Реализуйте класс PeekingIterator:
PeekingIterator(Iterator<int> nums): Инициализирует объект с заданным итератором целых чисел.
int next(): Возвращает следующий элемент в массиве и перемещает указатель на следующий элемент.
boolean hasNext(): Возвращает true, если в массиве еще есть элементы.
int peek(): Возвращает следующий элемент в массиве без перемещения указателя.

Пример:

Input
["PeekingIterator", "next", "peek", "next", "next", "hasNext"]
[[[1, 2, 3]], [], [], [], [], []]
Output
[null, 1, 2, 2, 3, false]

Explanation
PeekingIterator peekingIterator = new PeekingIterator([1, 2, 3]); // [1,2,3]
peekingIterator.next();    // return 1, the pointer moves to the next element [1,2,3].
peekingIterator.peek();    // return 2, the pointer does not move [1,2,3].
peekingIterator.next();    // return 2, the pointer moves to the next element [1,2,3]
peekingIterator.next();    // return 3, the pointer moves to the next element [1,2,3]
peekingIterator.hasNext(); // return False

👨‍💻 Алгоритм:

1⃣Инициализация итератора:
В конструкторе класса PeekingIterator инициализируйте итератор и проверьте, есть ли следующий элемент. Если есть, установите его как next, иначе установите next в null.

2⃣Операция peek:
Метод peek возвращает значение next, не перемещая указатель итератора.

3⃣Операции next и hasNext:
Метод next возвращает текущее значение next, обновляет next к следующему элементу в итераторе и перемещает указатель итератора. Если нет следующего элемента, бросает исключение NoSuchElementException.
Метод hasNext возвращает true, если next не равно null, и false в противном случае.

😎 Решение:

class PeekingIterator {
    private var iterator: IndexingIterator<[Int]>
    private var nextElement: Int?

    init(_ nums: [Int]) {
        self.iterator = nums.makeIterator()
        self.nextElement = self.iterator.next()
    }

    func next() -> Int {
        let currentElement = nextElement
        nextElement = iterator.next()
        return currentElement!
    }

    func hasNext() -> Bool {
        return nextElement != nil
    }

    func peek() -> Int {
        return nextElement!
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 285. Inorder Successor in BST

Дан корень бинарного дерева поиска и узел p в нем. Верните преемника этого узла в порядке возрастания в бинарном дереве поиска (BST). Если у данного узла нет преемника в порядке возрастания в дереве, верните null.

Преемник узла p — это узел с наименьшим ключом, который больше p.val.

Пример:

Input: root = [2,1,3], p = 1
Output: 2
Explanation: 1's in-order successor node is 2. Note that both p and the return value is of TreeNode type.

👨‍💻 Алгоритм:

1⃣Определение переменных класса:
Определите две переменные класса: previous и inorderSuccessorNode. Переменная previous будет использоваться при обработке второго случая, а inorderSuccessorNode будет содержать результат, который нужно вернуть.

2⃣Обработка двух случаев:
В функции inorderSuccessor сначала проверьте, какой из двух случаев нужно обработать, проверяя наличие правого дочернего элемента.
Правый дочерний элемент существует:
- присвойте правый дочерний элемент узлу leftmost и итерируйтесь, пока не достигнете узла (leftmost), у которого нет левого дочернего элемента. Итерируйте, присваивая leftmost = leftmost.left, пока не получите левый узел в поддереве.
Правый дочерний элемент не существует:
- определите функцию inorderCase2 и передайте ей узел и узел p.
- выполните простой обход в порядке возрастания: сначала рекурсируйте на левый дочерний элемент узла.
- когда рекурсия вернется, проверьте, равна ли переменная класса previous узлу p. Если это так, значит p является предшественником узла, или, другими словами, узел является преемником узла p. Назначьте inorderSuccessorNode узлу и вернитесь из функции.
- наконец, верните inorderSuccessorNode как результат.

3⃣Итерация и обновление:
В функции inorderCase2 обновляйте previous текущим узлом и продолжайте рекурсировать на правый дочерний элемент.

😎 Решение:

class TreeNode {
    var val: Int
    var left: TreeNode?
    var right: TreeNode?
    init(_ val: Int) {
        self.val = val
        self.left = nil
        self.right = nil
    }
}

class Solution {
    private var previous: TreeNode?
    private var inorderSuccessorNode: TreeNode?

    func inorderSuccessor(_ root: TreeNode?, _ p: TreeNode?) -> TreeNode? {
        if let right = p?.right {
            var leftmost = right
            while leftmost.left != nil {
                leftmost = leftmost.left!
            }
            self.inorderSuccessorNode = leftmost
        } else {
            self.inorderCase2(root, p)
        }
        return self.inorderSuccessorNode
    }

    private func inorderCase2(_ node: TreeNode?, _ p: TreeNode?) {
        guard let node = node else { return }

        inorderCase2(node.left, p)

        if previous === p && inorderSuccessorNode == nil {
            inorderSuccessorNode = node
            return
        }

        previous = node

        inorderCase2(node.right, p)
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 286. Walls and Gates

Вам дана сетка размером m x n, представляющая комнаты, инициализированные следующими значениями:
-1: Стена или препятствие.
0: Ворота.
INF: Бесконечность, обозначающая пустую комнату. Мы используем значение 2^31 - 1 = 2147483647 для представления INF, так как можно предположить, что расстояние до ворот меньше 2147483647.
Заполните каждую пустую комнату расстоянием до ближайших ворот. Если невозможно добраться до ворот, комната должна быть заполнена значением INF.

Пример:

Input: rooms = [[2147483647,-1,0,2147483647],[2147483647,2147483647,2147483647,-1],[2147483647,-1,2147483647,-1],[0,-1,2147483647,2147483647]]
Output: [[3,-1,0,1],[2,2,1,-1],[1,-1,2,-1],[0,-1,3,4]]

👨‍💻 Алгоритм:

1⃣Обход всех комнат:
Пройдите через каждую клетку сетки, инициализируя очередь для BFS. Если клетка содержит ворота (0), добавьте её в очередь.

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

3⃣Проверка всех направлений:
Для каждой клетки проверьте все возможные направления (вверх, вниз, влево, вправо) и добавляйте в очередь те, которые являются пустыми комнатами.

😎 Решение:

class Solution {
    private let INF = 2147483647
    private let directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    func wallsAndGates(_ rooms: inout [[Int]]) {
        let m = rooms.count
        let n = rooms[0].count
        var queue = [(Int, Int)]()

        for i in 0..<m {
            for j in 0..<n {
                if rooms[i][j] == 0 {
                    queue.append((i, j))
                }
            }
        }

        while !queue.isEmpty {
            let (x, y) = queue.removeFirst()
            for (dx, dy) in directions {
                let nx = x + dx
                let ny = y + dy
                if nx >= 0, ny >= 0, nx < m, ny < n, rooms[nx][ny] == INF {
                    rooms[nx][ny] = rooms[x][y] + 1
                    queue.append((nx, ny))
                }
            }
        }
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 287. Find the Duplicate Number

Дан массив целых чисел nums, содержащий n + 1 целых чисел, где каждое число находится в диапазоне [1, n] включительно.
В массиве есть только одно повторяющееся число, верните это повторяющееся число.
Вы должны решить задачу, не изменяя массив nums и используя только постоянное дополнительное пространство.

Пример:

Input: nums = [1,3,4,2,2]
Output: 2

👨‍💻 Алгоритм:

1⃣Определение дубликата:
Итерируйте по массиву, оценивая каждый элемент (назовем его cur). Используйте абсолютное значение текущего элемента, чтобы получить индекс.
Если элемент по индексу cur отрицательный, значит, мы уже встречали этот элемент ранее, и cur является дубликатом. Сохраните cur как дубликат и выйдите из цикла.
Если элемент по индексу cur положительный, инвертируйте знак этого элемента, чтобы пометить его как встреченный, и перейдите к следующему элементу.

2⃣Восстановление массива:
Пройдите по массиву и измените все отрицательные элементы обратно на положительные, чтобы восстановить исходное состояние массива.

3⃣Возврат результата:
Верните найденный дубликат.

😎 Решение:

class Solution {
    func findDuplicate(_ nums: [Int]) -> Int {
        var nums = nums
        var duplicate = -1
        for i in 0..<nums.count {
            let cur = abs(nums[i])
            if nums[cur] < 0 {
                duplicate = cur
                break
            }
            nums[cur] *= -1
        }
        for i in 0..<nums.count {
            nums[i] = abs(nums[i])
        }
        return duplicate
    }
}

Ставь 👍 и забирай 📚 Базу знаний