C# | LeetCode

📺 Уникальная база записей IT собеседований 180+ записей реальных собеседований на программиста, тестировщика, аналитика и прочие IT профы. Записи собесов от ведущих компаний: Сбер, Яндекс, ВТБ, Тинькофф, Озон, Wildberries и т.д. 🎯 Переходи по ссылке и присоединяйся к базе, чтобы прокачать свои шансы на успешное трудоустройство! У тебя есть запись собеседования? Мы готовы ее купить и заплатим до 3000 руб. за каждую

#medium Задача: 473. Matchsticks to Square Дано целочисленный массив спичек, где matchsticks[i] — это длина i-й спички. Необходимо использовать все спички для создания одного квадрата. Нельзя ломать никакую спичку, но можно соединять их, при этом каждая спичка должна быть использована ровно один раз. Вернуть true, если можно составить квадрат, и false в противном случае. Пример:

Input: matchsticks = [1,1,2,2,2]
Output: true
Explanation: You can form a square with length 2, one side of the square came two sticks with length 1.

👨‍💻 Алгоритм: 1⃣Определяем рекурсивную функцию, которая принимает текущий индекс обрабатываемой спички и количество сторон квадрата, которые уже полностью сформированы. Базовый случай для рекурсии: если все спички использованы и сформировано 4 стороны, возвращаем True. 2⃣Для текущей спички рассматриваем 4 варианта: она может быть частью любой из сторон квадрата. Пробуем каждый из 4 вариантов, вызывая рекурсию для них. 3⃣Если какой-либо из рекурсивных вызовов возвращает True, возвращаем True, в противном случае возвращаем False. 😎 Решение:

using System;
using System.Collections.Generic;
using System.Linq;

public class Solution {
    private IList<int> nums;
    private int[] sums;
    private int possibleSquareSide;

    public Solution() {
        this.sums = new int[4];
    }

    private bool Dfs(int index) {
        if (index == this.nums.Count) {
            return sums[0] == sums[1] && sums[1] == sums[2] && sums[2] == sums[3];
        }

        int element = this.nums[index];

        for (int i = 0; i < 4; i++) {
            if (this.sums[i] + element <= this.possibleSquareSide) {
                this.sums[i] += element;
                if (this.Dfs(index + 1)) {
                    return true;
                }
                this.sums[i] -= element;
            }
        }

        return false;
    }

    public bool Makesquare(int[] nums) {
        if (nums == null || nums.Length == 0) {
            return false;
        }

        int perimeter = nums.Sum();
        this.possibleSquareSide = perimeter / 4;
        if (this.possibleSquareSide * 4 != perimeter) {
            return false;
        }

        this.nums = nums.OrderByDescending(x => x).ToList();
        return this.Dfs(0);
    }
}

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

#medium Задача: 328. Odd Even Linked List Дан заголовок односвязного списка. Сгруппируйте все узлы с нечетными индексами вместе, а затем узлы с четными индексами, и верните упорядоченный список. Первый узел считается нечетным, второй узел — четным и так далее. Учтите, что относительный порядок внутри обеих групп (четной и нечетной) должен оставаться таким же, как в исходном списке. Вы должны решить задачу с дополнительной сложностью по памяти O(1) и временной сложностью O(n). Пример:

Input: head = [2,1,3,5,6,4,7]
Output: [2,3,6,7,1,5,4]

👨‍💻 Алгоритм: 1⃣Инициализация указателей: Создайте указатели odd и even для работы с нечетными и четными узлами, соответственно. Инициализируйте odd началом списка head, а even — следующим узлом head.next. Также создайте указатель evenHead для сохранения начала четного списка. 2⃣Разделение списка: Используйте цикл для прохождения списка, перенаправляя нечетные узлы в oddList, а четные узлы в evenList. Обновляйте указатели odd и even в процессе итерации. 3⃣Соединение списков: После окончания цикла соедините конец нечетного списка с началом четного списка, используя указатель evenHead. 😎 Решение:

public class ListNode {
    public int val;
    public ListNode next;
    public ListNode(int x) { val = x; }
}

public class Solution {
    public ListNode OddEvenList(ListNode head) {
        if (head == null) return null;
        ListNode odd = head, even = head.next, evenHead = even;
        
        while (even != null && even.next != null) {
            odd.next = even.next;
            odd = odd.next;
            even.next = odd.next;
            even = even.next;
        }
        odd.next = evenHead;
        return head;
    }
}

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

Перец на канале «Записки необычного препода» делает невозможное! А именно — встраивает мышление на английском взрослым людям. Как обычно пытаются научить «думать на языке»? Методом «бери больше, кидай дальше». Слушайте песни, смотрите фильмы, читайте книги в оригинале, и оно само как-нибудь запустится. Тут всё совсем не так. Тут происходит встраивание языка на кардинально других принципах. В результате вы ощущаете грамматику и слова «изнутри». Так, как бы вы их ощущали, будь вы носителем английского языка. Почитать подробнее про эту технологию можно тут. Есть конкретный механизм мышления. Он состоит из визуального слоя, слоя смыслов и слоя слов. Механизм разбивается на элементы. Каждый элемент тренируется отдельно. Оттренированные элементы стыкуются друг с другом с помощью специальных упражнений. Здесь: - Пошаговая технология; - Разбор механик мышления на языке; - Простота — любое сложное упражнение должно быть разбито на простые. - Измеримость — все упражнения тренируются до норматива (как правило в секундах). Норматив гарантирует освоение упражнения на уровне навыка. - Сумма упражнений неизбежно приводит к мышлению на языке. Так же, как правильно собранные вместе детали создают автомобиль. Вот, например: - как найти английские артикли в русском; - как освоить что угодно в 10 раз быстрее; - как взломать английскую грамматику. Подписывайся, чтобы узнать больше.

#hard Задача: 352. Data Stream as Disjoint Intervals Дано поступление данных из последовательности неотрицательных целых чисел a1, a2, ..., an, необходимо обобщить увиденные числа в виде списка непересекающихся интервалов. Реализуйте класс SummaryRanges: SummaryRanges() Инициализирует объект с пустым потоком. void addNum(int value) Добавляет целое число в поток. int[][] getIntervals() Возвращает обобщение текущих чисел в потоке в виде списка непересекающихся интервалов [starti, endi]. Ответ должен быть отсортирован по starti. Пример:

Input
["SummaryRanges", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals"]
[[], [1], [], [3], [], [7], [], [2], [], [6], []]
Output
[null, null, [[1, 1]], null, [[1, 1], [3, 3]], null, [[1, 1], [3, 3], [7, 7]], null, [[1, 3], [7, 7]], null, [[1, 3], [6, 7]]]

👨‍💻 Алгоритм: 1⃣Инициализировать структуру данных TreeSet для хранения значений. 2⃣addNum(int value) Просто добавить value в values. Если эквивалент TreeSet вашего языка программирования позволяет дублировать значения, как например SortedList в Python, нужно также проверить, что value не существует в values, так как дубликаты нарушат алгоритм. 3⃣getIntervals Если values пуст, вернуть пустой массив. Создать пустой список интервалов. Установить left = right = -1. left представляет левую границу текущего интервала, а right представляет правую границу. Итерировать по values. На каждой итерации: Если left < 0, установить left = right = value. Иначе, если value = right + 1, установить right = value, так как мы можем продолжить текущий интервал. Иначе, мы не можем продолжить текущий интервал. Вставить [left, right] в intervals и установить left = right = value для начала нового интервала. Вставить [left, right] в intervals и вернуть intervals. 😎 Решение:

using System;
using System.Collections.Generic;

public class SummaryRanges {
    private SortedSet<int> values;

    public SummaryRanges() {
        values = new SortedSet<int>();
    }

    public void AddNum(int value) {
        values.Add(value);
    }

    public List<int[]> GetIntervals() {
        var intervals = new List<int[]>();
        if (values.Count == 0) {
            return intervals;
        }

        int left = -1, right = -1;
        foreach (var value in values) {
            if (left < 0) {
                left = right = value;
            } else if (value == right + 1) {
                right = value;
            } else {
                intervals.Add(new int[] { left, right });
                left = right = value;
            }
        }
        intervals.Add(new int[] { left, right });
        return intervals;
    }
}

// Example usage
public class Program {
    public static void Main() {
        SummaryRanges sr = new SummaryRanges();
        sr.AddNum(1);
        sr.AddNum(3);
        sr.AddNum(7);
        sr.AddNum(2);
        sr.AddNum(6);
        List<int[]> intervals = sr.GetIntervals();
        foreach (var interval in intervals) {
            Console.WriteLine($"{interval[0]} {interval[1]}");
        }
    }
}

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

Запустите рекламу в телеграм-каналах с Яндекс Директом Перфоманс-реклама теперь в телеграм-каналах ⚡ Яндекс Директ знает, как привлечь целевую аудиторию 💰👌 Попробовать #реклама yandex.ru О рекламодателе

#medium Задача: 289. Game of Life Согласно статье Википедии: "Игра Жизнь, также известная просто как Жизнь, — это клеточный автомат, созданный британским математиком Джоном Хортоном Конуэем в 1970 году." Доска состоит из сетки клеток размером m x n, где каждая клетка имеет начальное состояние: живая (представляется числом 1) или мёртвая (представляется числом 0). Каждая клетка взаимодействует с восемью соседями (по горизонтали, вертикали и диагоналям) согласно следующим четырём правилам (взято из вышеупомянутой статьи Википедии): Любая живая клетка с менее чем двумя живыми соседями умирает, как будто из-за недостатка населения. Любая живая клетка с двумя или тремя живыми соседями остаётся живой до следующего поколения. Любая живая клетка с более чем тремя живыми соседями умирает, как будто из-за перенаселения. Любая мёртвая клетка с ровно тремя живыми соседями становится живой, как будто вследствие размножения. Следующее состояние создаётся путем одновременного применения вышеупомянутых правил ко всем клеткам в текущем состоянии, где рождения и смерти происходят одновременно. Дано текущее состояние сетки m x n, верните следующее состояние. Пример:

Input: board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
Output: [[0,0,0],[1,0,1],[0,1,1],[0,1,0]]

👨‍💻 Алгоритм: 1⃣Итерация по клеткам доски: Пройдите через каждую клетку на доске. Для каждой клетки подсчитайте количество живых соседей, проверяя все восемь соседних клеток. 2⃣Применение правил: На основе количества живых соседей и текущего состояния клетки примените правила игры: Любая живая клетка с менее чем двумя живыми соседями умирает (становится -1). Любая живая клетка с двумя или тремя живыми соседями остаётся живой (без изменений). Любая живая клетка с более чем тремя живыми соседями умирает (становится -1). Любая мёртвая клетка с ровно тремя живыми соседями становится живой (становится 2). 3⃣Обновление доски: Пройдите через доску ещё раз и обновите состояния клеток: Если значение клетки больше 0, установите её в 1 (живая). Если значение клетки меньше или равно 0, установите её в 0 (мёртвая). 😎 Решение:

public class Solution {
    public void GameOfLife(int[][] board) {
        int[] neighbors = {0, 1, -1};
        int rows = board.Length;
        int cols = board[0].Length;

        for (int row = 0; row < rows; row++) {
            for (int col = 0; col < cols; col++) {
                int liveNeighbors = 0;

                for (int i = 0; i < 3; i++) {
                    for (int j = 0; j < 3; j++) {
                        if (!(neighbors[i] == 0 && neighbors[j] == 0)) {
                            int r = row + neighbors[i];
                            int c = col + neighbors[j];

                            if ((r < rows && r >= 0) && (c < cols && c >= 0) && (Math.Abs(board[r][c]) == 1)) {
                                liveNeighbors++;
                            }
                        }
                    }
                }

                if ((board[row][col] == 1) && (liveNeighbors < 2 || liveNeighbors > 3)) {
                    board[row][col] = -1;
                }
                if (board[row][col] == 0 && liveNeighbors == 3) {
                    board[row][col] = 2;
                }
            }
        }

        for (int row = 0; row < rows; row++) {
            for (int col = 0; col < cols; col++) {
                if (board[row][col] > 0) {
                    board[row][col] = 1;
                } else {
                    board[row][col] = 0;
                }
            }
        }
    }
}

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

Программист — лекарство от больных тимлидов, тупых багов и тех самых митов в 10 утра ☠️ Здесь собирают лучшие мемы про айтишников, чтобы спасти вашу психику от died'осов на работе. Идеально зачиллить вечерком и скинуть друзьям: @progeri

#easy Задача: 459. Repeated Substring Pattern Дана строка s, проверьте, может ли она быть построена путем взятия подстроки и добавления нескольких копий этой подстроки друг за другом. Пример:

Input: heights = [2,1,5,6,2,3]
Output: 10
Explanation: The above is a histogram where width of each bar is 1.
The largest rectangle is shown in the red area, which has an area = 10 units.

👨‍💻 Алгоритм: 1⃣Создайте целочисленную переменную n, равную длине строки s. 2⃣Итерация по всем префиксным подстрокам длины i от 1 до n/2: Если i делит n, объявите пустую строку pattern. Используйте внутренний цикл, который выполняется n/i раз для конкатенации подстроки, сформированной из первых i символов строки s. Если pattern равен s, вернуть true. 3⃣Если нет подстроки, которую можно повторить для формирования s, вернуть false. 😎 Решение:

public class Solution {
    public bool RepeatedSubstringPattern(string s) {
        int n = s.Length;
        for (int i = 1; i <= n / 2; i++) {
            if (n % i == 0) {
                string pattern = "";
                string substr = s.Substring(0, i);
                for (int j = 0; j < n / i; j++) {
                    pattern += substr;
                }
                if (s == pattern) {
                    return true;
                }
            }
        }
        return false;
    }
}

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

#medium Задача: 288. Unique Word Abbreviation Сокращение слова — это объединение его первой буквы, количества символов между первой и последней буквой и последней буквы. Если слово состоит только из двух символов, то оно является сокращением само по себе. Например: dog --> d1g, потому что между первой буквой 'd' и последней буквой 'g' одна буква. internationalization --> i18n, потому что между первой буквой 'i' и последней буквой 'n' 18 букв. it --> it, потому что любое слово из двух символов является своим собственным сокращением. Реализуйте класс ValidWordAbbr: ValidWordAbbr(String[] dictionary) Инициализирует объект со словарем слов. boolean isUnique(string word) Возвращает true, если выполняется одно из следующих условий (в противном случае возвращает false): В словаре нет слова, сокращение которого равно сокращению слова word. Для любого слова в словаре, сокращение которого равно сокращению слова word, это слово и word одинаковы. Пример:

Input
["ValidWordAbbr", "isUnique", "isUnique", "isUnique", "isUnique", "isUnique"]
[[["deer", "door", "cake", "card"]], ["dear"], ["cart"], ["cane"], ["make"], ["cake"]]
Output
[null, false, true, false, true, true]

Explanation
ValidWordAbbr validWordAbbr = new ValidWordAbbr(["deer", "door", "cake", "card"]);
validWordAbbr.isUnique("dear"); // return false, dictionary word "deer" and word "dear" have the same abbreviation "d2r" but are not the same.
validWordAbbr.isUnique("cart"); // return true, no words in the dictionary have the abbreviation "c2t".
validWordAbbr.isUnique("cane"); // return false, dictionary word "cake" and word "cane" have the same abbreviation  "c2e" but are not the same.
validWordAbbr.isUnique("make"); // return true, no words in the dictionary have the abbreviation "m2e".
validWordAbbr.isUnique("cake"); // return true, because "cake" is already in the dictionary and no other word in the dictionary has "c2e" abbreviation.

👨‍💻 Алгоритм: 1⃣Инициализация: Создайте словарь сокращений abbrDict, который будет хранить сокращения слов в виде ключей и булевы значения, указывающие, уникально ли сокращение. Создайте множество dict, содержащее все слова из словаря, чтобы быстро проверять наличие слова в словаре. 2⃣Генерация сокращений: При инициализации объекта ValidWordAbbr пройдите через каждое слово в словаре и создайте его сокращение. Если сокращение уже существует в abbrDict, установите значение в false (не уникальное). В противном случае установите значение в true (уникальное). 3⃣Проверка уникальности: Для метода isUnique создайте сокращение для входного слова и проверьте, есть ли это сокращение в abbrDict. Если сокращение отсутствует в abbrDict, возвращайте true. Если сокращение присутствует и оно уникально, проверьте, есть ли это слово в словаре. Если да, возвращайте true, в противном случае - false. 😎 Решение:

public class ValidWordAbbr {
    private readonly Dictionary<string, bool> abbrDict = new Dictionary<string, bool>();
    private readonly HashSet<string> dict;

    public ValidWordAbbr(string[] dictionary) {
        dict = new HashSet<string>(dictionary);
        foreach (var word in dict) {
            var abbr = ToAbbr(word);
            abbrDict[abbr] = !abbrDict.ContainsKey(abbr);
        }
    }

    public bool IsUnique(string word) {
        var abbr = ToAbbr(word);
        return !abbrDict.ContainsKey(abbr) || (abbrDict[abbr] && dict.Contains(word));
    }

    private string ToAbbr(string word) {
        int n = word.Length;
        return n <= 2 ? word : $"{word[0]}{n - 2}{word[n - 1]}";
    }
}

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

⚡️ Вся база знаний по IT в одном месте! 🧑‍💻 IT База — краткие разборы самого важного из мира IT. Сотни мастхев-ресурсов, каждый день новые материалы по работе и подготовке к собеседованиям. Подойдёт как новичкам, так и состоявшимся айтишникам; 🖥 Frontend База — всё для фронтенд разработчиков. Готовые решения для проектов, полезные курсы по JS/HTML/CSS, готовые роадмапы для комфортного освоения в профессии и дальнейшего развития; 👣 Backend База — самое важное для бэкендеров. Всё о работе с PHP, MySQL, MongoDB, Golang и Rust в одном месте, плюс полные курсы и лайфхаки для работы на каждый день; 🖥 База Знаний — склад полезных курсов и материалов, где легко найти что-то нужное по хэштегам. Если вам что-то интересно про IT, то оно уже лежит на Базе, проверяйте. ⏲ Успей подписаться, чтобы не потерять!

#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⃣Возврат результата: Верните найденный дубликат. 😎 Решение:

public class Solution {
    public int FindDuplicate(int[] nums) {
        int duplicate = -1;
        for (int i = 0; i < nums.Length; i++) {
            int cur = Math.Abs(nums[i]);
            if (nums[cur] < 0) {
                duplicate = cur;
                break;
            }
            nums[cur] *= -1;
        }
        for (int i = 0; i < nums.Length; i++) {
            nums[i] = Math.Abs(nums[i]);
        }
        return duplicate;
    }
}

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

#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⃣Проверка всех направлений: Для каждой клетки проверьте все возможные направления (вверх, вниз, влево, вправо) и добавляйте в очередь те, которые являются пустыми комнатами. 😎 Решение:

using System;
using System.Collections.Generic;

public class Solution {
    private static readonly int INF = 2147483647;
    private static readonly int[][] Directions = new int[][] {
        new int[] { 0, 1 },
        new int[] { 1, 0 },
        new int[] { 0, -1 },
        new int[] { -1, 0 }
    };

    public void WallsAndGates(int[][] rooms) {
        if (rooms.Length == 0) return;

        int m = rooms.Length;
        int n = rooms[0].Length;
        Queue<(int, int)> queue = new Queue<(int, int)>();

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (rooms[i][j] == 0) {
                    queue.Enqueue((i, j));
                }
            }
        }

        while (queue.Count > 0) {
            var (x, y) = queue.Dequeue();
            foreach (var direction in Directions) {
                int nx = x + direction[0];
                int ny = y + direction[1];
                if (nx >= 0 && ny >= 0 && nx < m && ny < n && rooms[nx][ny] == INF) {
                    rooms[nx][ny] = rooms[x][y] + 1;
                    queue.Enqueue((nx, ny));
                }
            }
        }
    }
}

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

#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 текущим узлом и продолжайте рекурсировать на правый дочерний элемент. 😎 Решение:

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int x) { val = x; }
}

public class Solution {
    private TreeNode previous = null;
    private TreeNode inorderSuccessorNode = null;

    public TreeNode InorderSuccessor(TreeNode root, TreeNode p) {
        if (p.right != null) {
            TreeNode leftmost = p.right;
            while (leftmost.left != null) {
                leftmost = leftmost.left;
            }
            inorderSuccessorNode = leftmost;
        } else {
            InorderCase2(root, p);
        }
        return inorderSuccessorNode;
    }

    private void InorderCase2(TreeNode node, TreeNode p) {
        if (node == null) {
            return;
        }

        InorderCase2(node.left, p);

        if (previous == p && inorderSuccessorNode == null) {
            inorderSuccessorNode = node;
            return;
        }

        previous = node;

        InorderCase2(node.right, p);
    }
}

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

#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 в противном случае. 😎 Решение:

using System;
using System.Collections.Generic;

public class PeekingIterator {
    private IEnumerator<int> iterator;
    private bool hasPeeked;
    private int peekedElement;

    public PeekingIterator(IEnumerator<int> iterator) {
        this.iterator = iterator;
    }

    public int Next() {
        if (hasPeeked) {
            hasPeeked = false;
            return peekedElement;
        }
        return iterator.MoveNext() ? iterator.Current : throw new InvalidOperationException();
    }

    public bool HasNext() {
        return hasPeeked || iterator.MoveNext();
    }

    public int Peek() {
        if (!hasPeeked) {
            hasPeeked = iterator.MoveNext();
            peekedElement = iterator.Current;
        }
        return peekedElement;
    }
}

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

#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 до конца массива. В итоге все нули будут перемещены в конец массива, сохраняя относительный порядок ненулевых элементов. 😎 Решение:

public class Solution {
    public void MoveZeroes(int[] nums) {
        int lastNonZeroFoundAt = 0;
        for (int cur = 0; cur < nums.Length; cur++) {
            if (nums[cur] != 0) {
                int temp = nums[lastNonZeroFoundAt];
                nums[lastNonZeroFoundAt] = nums[cur];
                nums[cur] = temp;
                lastNonZeroFoundAt++;
            }
        }
    }
}

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

#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⃣Проверка и запись валидных выражений: Когда вся строка цифр обработана, проверяйте, соответствует ли итоговое значение целевому значению и нет ли остатков операндов. Если выражение валидное, записывайте его в список результатов. 😎 Решение:

using System;
using System.Collections.Generic;
using System.Text;

public class Solution {
    public List<string> answer;
    public string digits;
    public long target;

    public void Recurse(int index, long previousOperand, long currentOperand, long value, List<string> ops) {
        if (index == digits.Length) {
            if (value == target && currentOperand == 0) {
                StringBuilder sb = new StringBuilder();
                for (int i = 1; i < ops.Count; i++) {
                    sb.Append(ops[i]);
                }
                answer.Add(sb.ToString());
            }
            return;
        }

        currentOperand = currentOperand * 10 + (digits[index] - '0');
        string currentValRep = currentOperand.ToString();

        if (currentOperand > 0) {
            Recurse(index + 1, previousOperand, currentOperand, value, ops);
        }

        ops.Add("+");
        ops.Add(currentValRep);
        Recurse(index + 1, currentOperand, 0, value + currentOperand, ops);
        ops.RemoveAt(ops.Count - 1);
        ops.RemoveAt(ops.Count - 1);

        if (ops.Count > 0) {
            ops.Add("-");
            ops.Add(currentValRep);
            Recurse(index + 1, -currentOperand, 0, value - currentOperand, ops);
            ops.RemoveAt(ops.Count - 1);
            ops.RemoveAt(ops.Count - 1);

            ops.Add("*");
            ops.Add(currentValRep);
            Recurse(index + 1, currentOperand * previousOperand, 0, value - previousOperand + (currentOperand * previousOperand), ops);
            ops.RemoveAt(ops.Count - 1);
            ops.RemoveAt(ops.Count - 1);
        }
    }

    public IList<string> AddOperators(string num, int target) {
        if (num.Length == 0) {
            return new List<string>();
        }

        this.target = target;
        this.digits = num;
        this.answer = new List<string>();
        Recurse(0, 0, 0, 0, new List<string>());
        return answer;
    }
}

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

#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 в противном случае. 😎 Решение:

using System.Collections.Generic;

public class ZigzagIterator {
    private List<List<int>> vectors = new List<List<int>>();
    private Queue<KeyValuePair<int, int>> queue = new Queue<KeyValuePair<int, int>>();

    public ZigzagIterator(List<int> v1, List<int> v2) {
        vectors.Add(v1);
        vectors.Add(v2);
        for (int i = 0; i < vectors.Count; i++) {
            if (vectors[i].Count > 0) {
                queue.Enqueue(new KeyValuePair<int, int>(i, 0));
            }
        }
    }

    public int Next() {
        var pointer = queue.Dequeue();
        int vecIndex = pointer.Key;
        int elemIndex = pointer.Value;
        int nextElemIndex = elemIndex + 1;
        if (nextElemIndex < vectors[vecIndex].Count) {
            queue.Enqueue(new KeyValuePair<int, int>(vecIndex, nextElemIndex));
        }
        return vectors[vecIndex][elemIndex];
    }

    public bool HasNext() {
        return queue.Count > 0;
    }
}

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

#easy Задача: 293. Flip Game Вы играете в игру Flip со своим другом. Вам дана строка currentState, которая содержит только символы '+' и '-'. Вы и ваш друг по очереди переворачиваете две последовательные "++" в "--". Игра заканчивается, когда один из игроков больше не может сделать ход, и, следовательно, другой игрок становится победителем. Верните все возможные состояния строки currentState после одного допустимого хода. Вы можете вернуть ответы в любом порядке. Если допустимых ходов нет, верните пустой список []. Пример:

Input: currentState = "++++"
Output: ["--++","+--+","++--"]

👨‍💻 Алгоритм: 1⃣Создайте пустой массив nextPossibleStates для хранения всех возможных следующих состояний после одного хода. 2⃣Запустите цикл от index = 0 до currentState.size() - 1. Для каждого индекса: Если символы на позициях index и index + 1 равны '+': Создайте новую строку nextState, заменив две последовательные '+' на '--'. Используйте конкатенацию строк для создания nextState из подстроки до первого '+', "--" и подстроки после второго '+' до конца. Сохраните созданное nextState в массив nextPossibleStates. 3⃣После цикла верните массив nextPossibleStates, содержащий все возможные следующие состояния. 😎 Решение:

using System;
using System.Collections.Generic;

public class Solution {
    public IList<string> GeneratePossibleNextMoves(string currentState) {
        var nextPossibleStates = new List<string>();

        for (int index = 0; index < currentState.Length - 1; index++) {
            if (currentState[index] == '+' && currentState[index + 1] == '+') {
                string nextState = currentState.Substring(0, index) + "--" + currentState.Substring(index + 2);
                nextPossibleStates.Add(nextState);
            }
        }

        return nextPossibleStates;
    }
}

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

#medium Задача: 291. Word Pattern II Дан шаблон и строка s, вернуть true, если строка s соответствует шаблону. Строка s соответствует шаблону, если существует биективное отображение отдельных символов на непустые строки так, что если каждый символ в шаблоне заменить на строку, которой он отображается, то результирующая строка будет равна s. Биективное отображение означает, что ни два символа не отображаются на одну и ту же строку, и ни один символ не отображается на две разные строки. Пример:

Input: pattern = "abab", s = "redblueredblue"
Output: true
Explanation: One possible mapping is as follows:
'a' -> "red"
'b' -> "blue"

👨‍💻 Алгоритм: 1⃣Инициализация структур данных и определение рекурсивной функции: Создайте хеш-таблицу symbolMap для отображения символов шаблона на подстроки строки s. Создайте множество wordSet для хранения уникальных подстрок строки s, которые были отображены на символ. Определите рекурсивную функцию isMatch, принимающую индексы в строке s (sIndex) и в шаблоне (pIndex), чтобы определить, соответствует ли строка s шаблону. 2⃣Рекурсивная проверка соответствия: Базовый случай: если pIndex равно длине шаблона, верните true, если sIndex равно длине строки s; иначе верните false. Получите символ из шаблона по индексу pIndex. Если символ уже ассоциирован с подстрокой, проверьте, совпадают ли следующие символы в строке s с этой подстрокой. Если нет, верните false. Если совпадают, вызовите isMatch для следующего символа в шаблоне. 3⃣Отображение новых подстрок: Если символ новый, попробуйте сопоставить его с новыми подстроками строки s, начиная с sIndex и до конца строки. Для каждой новой подстроки проверьте, существует ли она уже в ` 😎 Решение:

using System;
using System.Collections.Generic;

public class Solution {
    public bool WordPatternMatch(string pattern, string s) {
        var symbolMap = new Dictionary<char, string>();
        var wordSet = new HashSet<string>();
        return IsMatch(s, 0, pattern, 0, symbolMap, wordSet);
    }

    private bool IsMatch(string s, int sIndex, string pattern, int pIndex,
                         Dictionary<char, string> symbolMap, HashSet<string> wordSet) {
        if (pIndex == pattern.Length) {
            return sIndex == s.Length;
        }
        char symbol = pattern[pIndex];
        if (symbolMap.ContainsKey(symbol)) {
            string word = symbolMap[symbol];
            if (!s.Substring(sIndex).StartsWith(word)) {
                return false;
            }
            return IsMatch(s, sIndex + word.Length, pattern, pIndex + 1, symbolMap, wordSet);
        }
        for (int k = sIndex + 1; k <= s.Length; k++) {
            string newWord = s.Substring(sIndex, k - sIndex);
            if (wordSet.Contains(newWord)) {
                continue;
            }
            symbolMap[symbol] = newWord;
            wordSet.Add(newWord);
            if (IsMatch(s, k, pattern, pIndex + 1, symbolMap, wordSet)) {
                return true;
            }
            symbolMap.Remove(symbol);
            wordSet.Remove(newWord);
        }
        return false;
    }
}

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