Java | LeetCode

Скидки до 90% на Wildberries На WB собрали удобную и стильную обувь для всей семьи 🏃‍♂️ Модные кроссовки, удобные сабо, классические туфли и другие популярные модели от известных брендов. Кстати, сейчас на Wildberries действуют скидки до 90% и быстрая доставка от 1 дня. Отличный шанс пополнить свою коллекцию обуви ❤️ Перейти на сайт #реклама wildberries.ru О рекламодателе

Задача: 1036. Escape a Large Maze Сложность: hard Имеется сетка размером 1 миллион на 1 миллион на плоскости XY, координаты каждого квадрата сетки - (x, y). Мы начинаем с исходного квадрата = [sx, sy] и хотим достичь цели = [tx, ty]. Существует также массив заблокированных квадратов, где каждый заблокированный[i] = [xi, yi] представляет собой заблокированный квадрат с координатами (xi, yi). Каждый ход мы можем пройти один квадрат на север, восток, юг или запад, если квадрат не находится в массиве заблокированных квадратов. Нам также не разрешается выходить за пределы сетки. Возвращается true тогда и только тогда, когда можно достичь целевого квадрата из исходного квадрата с помощью последовательности правильных ходов. Пример:

Input: blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
Output: false

👨‍💻 Алгоритм: 1⃣Обработка входных данных: Загрузите координаты исходного квадрата sx, sy, целевого квадрата tx, ty и список заблокированных квадратов blocked. 2⃣Проверка простого случая: Если список blocked пуст, верните true, так как путь не будет заблокирован. Проверка начальной или целевой клетки: Если исходная или целевая клетка заблокированы, верните false. 3⃣Поиск пути с использованием BFS или DFS: Используйте алгоритм поиска в ширину (BFS) или поиска в глубину (DFS) для поиска пути от sx, sy до tx, ty, избегая заблокированных клеток. Если обнаружен путь, верните true, в противном случае верните false. 😎 Решение:

import java.util.*;

public class Solution {
    public boolean isEscapePossible(int[][] blocked, int[] source, int[] target) {
        Set<Pair<Integer, Integer>> blockedSet = new HashSet<>();
        for (int[] b : blocked) {
            blockedSet.add(new Pair<>(b[0], b[1]));
        }
        Pair<Integer, Integer> src = new Pair<>(source[0], source[1]);
        Pair<Integer, Integer> tgt = new Pair<>(target[0], target[1]);

        if (blockedSet.contains(src) || blockedSet.contains(tgt)) return false;

        List<int[]> directions = Arrays.asList(
                new int[]{0, 1}, new int[]{1, 0},
                new int[]{0, -1}, new int[]{-1, 0});
        int maxArea = blocked.length * (blocked.length - 1) / 2;

        boolean bfs(Pair<Integer, Integer> start, Pair<Integer, Integer> end) {
            Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
            queue.add(start);
            Set<Pair<Integer, Integer>> visited = new HashSet<>();
            visited.add(start);

            while (!queue.isEmpty()) {
                if (visited.size() > maxArea) return true;
                Pair<Integer, Integer> current = queue.poll();
                for (int[] dir : directions) {
                    int nx = current.getKey() + dir[0];
                    int ny = current.getValue() + dir[1];
                    Pair<Integer, Integer> next = new Pair<>(nx, ny);
                    if (nx >= 0 && nx < 1_000_000 && ny >= 0 && ny < 1_000_000 && !visited.contains(next) && !blockedSet.contains(next)) {
                        if (next.equals(end)) return true;
                        queue.add(next);
                        visited.add(next);
                    }
                }
            }
            return false;
        }

        return bfs(src, tgt) && bfs(tgt, src);
    }
}

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

Задача: 940. Distinct Subsequences II Сложность: hard Поскольку ответ может быть очень большим, верните его по модулю 10^9 + 7. Подпоследовательность строки - это новая строка, которая образуется из исходной строки путем удаления некоторых (можно ни одного) символов без нарушения взаимного расположения оставшихся символов. (Например, "ace" является подпоследовательностью "abcde", а "aec" - нет. Пример:

Input: s = "abc"
Output: 7

👨‍💻 Алгоритм: 1⃣Определить матрицу DP, где dp[i][j] будет хранить количество подпоследовательностей строки s с длиной i, оканчивающихся символом j. 2⃣Инициализировать матрицу DP нулями. Пройти по каждому символу строки: Если символ еще не был встречен, все подпоследовательности до текущего символа + текущий символ. Если символ уже был встречен, учет всех подпоследовательностей, включающих текущий символ, с учетом предыдущих вхождений. 3⃣Вернуть сумму всех значений в DP по модулю 10^9 + 7. 😎 Решение:

class Solution {
    private static final int MOD = 1000000007;
    
    public int countSubsequences(String s) {
        int[] dp = new int[26];
        for (char c : s.toCharArray()) {
            int index = c - 'a';
            dp[index] = (int)(((long)sum(dp) + 1) % MOD);
        }
        return sum(dp);
    }
    
    private int sum(int[] dp) {
        int result = 0;
        for (int val : dp) {
            result = (result + val) % MOD;
        }
        return result;
    }
}

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

Задача: 1426. Counting Elements Сложность: easy Дан целочисленный массив arr, посчитайте, сколько элементов x в нем есть таких, что x + 1 также находится в arr. Если в arr есть дубликаты, считайте их отдельно. Пример:

Input: arr = [1,2,3]
Output: 2
Explanation: 1 and 2 are counted cause 2 and 3 are in arr.

👨‍💻 Алгоритм: 1⃣Создайте вспомогательную функцию для проверки, содержится ли элемент в массиве. 2⃣Итерируйте по каждому элементу массива и используйте вспомогательную функцию для проверки, содержится ли элемент x + 1 в массиве. 3⃣Увеличьте счетчик, если x + 1 найден, и верните значение счетчика. 😎 Решение:

class Solution {
    public int countElements(int[] arr) {
        int count = 0;
        for (int x : arr) {
            if (integerInArray(arr, x + 1)) {
                count++;
            }
        }
        return count;
    }

    public boolean integerInArray(int[] arr, int target) {
        for (int x : arr) {
            if (x == target) {
                return true;
            }
        }
        return false;
    }
}

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

Знаешь, что отличает студента Алабуга Политех? Они не теряют время зря. Они с первого курса получают опыт и работают на проектах. - Учеба + практический опыт в компании мирового уровня - Финансовая самостоятельность - зарплата уже с первого курса! К выпуску у тебя: • диплом гос. образца • официальный трудовой стаж от 2 лет • реальный опыт работы по профессии • карьерные перспективы в одной из лучших ОЭЗ России Подавай заявку и принимай решение о будущем прямо сейчас! Перейти на сайт #реклама 16+ polytech.alabuga.ru О рекламодателе

Задача: 179. Largest Number Сложность: medium Дан список неотрицательных целых чисел nums. Организуйте их таким образом, чтобы они составляли наибольшее число и верните его. Поскольку результат может быть очень большим, вам необходимо вернуть строку вместо целого числа. Пример:

Input: nums = [10,2]
Output: "210"

👨‍💻 Алгоритм: 1⃣Преобразование и сортировка: Преобразовать каждое число в строку и отсортировать массив строк с использованием специального компаратора, который для двух строк 𝑎 и b сравнивает результаты конкатенации 𝑎+𝑏 и 𝑏+𝑎. 2⃣Проверка на нули: Если после сортировки первый элемент массива равен "0", вернуть "0", так как все числа в массиве нули. 3⃣Формирование результата: Конкатенировать отсортированные строки для формирования наибольшего числа и вернуть это число в виде строки. 😎 Решение:

class Solution {
    private class LargerNumberComparator implements Comparator<String> {
        @Override
        public int compare(String a, String b) {
            String order1 = a + b;
            String order2 = b + a;
            return order2.compareTo(order1);
        }
    }

    public String largestNumber(int[] nums) {
        String[] asStrs = new String[nums.length];
        for (int i = 0; i < nums.length; i++) {
            asStrs[i] = String.valueOf(nums[i]);
        }
        Arrays.sort(asStrs, new LargerNumberComparator());
        if (asStrs[0].equals("0")) {
            return "0";
        }
        String largestNumberStr = new String();
        for (String numAsStr : asStrs) {
            largestNumberStr += numAsStr;
        }

        return largestNumberStr;
    }
}

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

Задача: 305. Number of Islands II Сложность: hard Дан пустой двумерный бинарный массив grid размером m x n. Этот массив представляет собой карту, где 0 означает воду, а 1 — сушу. Изначально все ячейки массива — водные (т.е. все ячейки содержат 0). Вы можете выполнить операцию "добавить землю", которая превращает воду в указанной позиции в сушу. Вам дан массив positions, где positions[i] = [ri, ci] — позиция (ri, ci), в которой следует выполнить i-ю операцию. Верните массив целых чисел answer, где answer[i] — количество островов после превращения ячейки (ri, ci) в сушу. Остров окружен водой и образуется путем соединения соседних земель по горизонтали или вертикали. Вы можете считать, что все четыре края сетки окружены водой. Пример:

Input: m = 1, n = 1, positions = [[0,0]]
Output: [1]

👨‍💻 Алгоритм: 1⃣Инициализация: Создайте массивы x[] = { -1, 1, 0, 0 } и y[] = { 0, 0, -1, 1 }, которые будут использоваться для нахождения соседей ячейки. Создайте экземпляр UnionFind, например, dsu(m * n). Инициализируйте всех родителей значением -1. Используйте объединение по рангу, инициализируйте все ранги значением 0. Наконец, инициализируйте count = 0. Создайте список целых чисел answer, где answer[i] будет хранить количество островов, образованных после превращения ячейки positions[i] в сушу. 2⃣Обработка позиций: Итерация по массиву positions. Для каждой позиции в positions: Выполните линейное отображение, чтобы преобразовать двумерную позицию ячейки в landPosition = position[0] * n + position[1]. Используйте операцию addLand(landPosition), чтобы добавить landPosition как узел в граф. Эта функция также увеличит count. Итерация по каждому соседу позиции. Соседа можно определить с помощью neighborX = position[0] + x[i] и neighborY = position[1] + y[i], где neighborX — координата X, а neighborY — координата Y соседней ячейки. Выполните линейное отображение соседней ячейки с помощью neighborPosition = neighborX * n + neighborY. Теперь, если на neighborPosition есть суша, т.е. isLand(neighborPosition) возвращает true, выполните объединение neighborPosition и landPosition. В объединении уменьшите count на 1. 3⃣Определение количества островов: Выполните операцию numberOfIslands, которая возвращает количество островов, образованных после превращения позиции в сушу. Добавьте это значение в answer. Верните answer. 😎 Решение

class UnionFind {
    private int[] parent, rank;
    private int count;
    public UnionFind(int size) { parent = new int[size]; rank = new int[size]; Arrays.fill(parent, -1); count = 0; }
    public void addLand(int x) { if (parent[x] >= 0) return; parent[x] = x; count++; }
    public boolean isLand(int x) { return parent[x] >= 0; }
    public int numberOfIslands() { return count; }
    public int find(int x) { if (parent[x] != x) parent[x] = find(parent[x]); return parent[x]; }
    public void unionSet(int x, int y) { int xset = find(x), yset = find(y); if (xset == yset) return;
        if (rank[xset] < rank[yset]) parent[xset] = yset; else { parent[yset] = xset; if (rank[xset] == rank[yset]) rank[xset]++; } count--; }
}

class Solution {
    public List<Integer> numIslands2(int m, int n, List<int[]> positions) {
        UnionFind dsu = new UnionFind(m * n);
        int[] x = {-1, 1, 0, 0}, y = {0, 0, -1, 1};
        List<Integer> answer = new ArrayList<>();
        for (int[] pos : positions) {
            int land = pos[0] * n + pos[1];
            dsu.addLand(land);
            for (int i = 0; i < 4; i++) {
                int nx = pos[0] + x[i], ny = pos[1] + y[i], neighbor = nx * n + ny;
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && dsu.isLand(neighbor)) { dsu.unionSet(land, neighbor); }
            }
            answer.add(dsu.numberOfIslands());
        }
        return answer;
    }
}

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

Задача: 895. Maximum Frequency Stack Сложность: hard Разработайте структуру данных, похожую на стек, чтобы заталкивать элементы в стек и вытаскивать из него самый частый элемент. Реализуйте класс FreqStack: FreqStack() строит пустой стек частот. void push(int val) заталкивает целое число val на вершину стека. int pop() удаляет и возвращает самый частый элемент в стеке. Если есть равенство в выборе самого частого элемента, то удаляется и возвращается элемент, который ближе всего к вершине стека. Пример:

Input
["FreqStack", "push", "push", "push", "push", "push", "push", "pop", "pop", "pop", "pop"]
[[], [5], [7], [5], [7], [4], [5], [], [], [], []]
Output
[null, null, null, null, null, null, null, 5, 7, 5, 4]

👨‍💻 Алгоритм: 1⃣Создать два словаря: freq для хранения частоты каждого элемента и group для хранения стека элементов для каждой частоты. 2⃣При добавлении элемента увеличивать его частоту в freq и добавлять его в стек соответствующей частоты в group. 3⃣При извлечении элемента найти максимальную частоту, удалить элемент из стека соответствующей частоты и уменьшить его частоту в freq. Если стек для данной частоты становится пустым, удалить его. 😎 Решение:

import java.util.*;

class FreqStack {
    private Map<Integer, Integer> freq;
    private Map<Integer, Stack<Integer>> group;
    private int maxfreq;

    public FreqStack() {
        freq = new HashMap<>();
        group = new HashMap<>();
        maxfreq = 0;
    }

    public void push(int val) {
        int f = freq.getOrDefault(val, 0) + 1;
        freq.put(val, f);
        if (f > maxfreq) {
            maxfreq = f;
            group.put(f, new Stack<>());
        }
        group.get(f).push(val);
    }

    public int pop() {
        int val = group.get(maxfreq).pop();
        freq.put(val, freq.get(val) - 1);
        if (group.get(maxfreq).isEmpty()) {
            maxfreq--;
        }
        return val;
    }
}

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

Задача: 1356. Sort Integers by The Number of 1 Bits Сложность: easy Дан целочисленный массив arr. Отсортируйте целые числа в массиве по возрастанию числа единиц в их двоичном представлении, а в случае, если у двух или более чисел одинаковое количество единиц, отсортируйте их по возрастанию. Верните массив после сортировки. Пример:

Input: arr = [1024,512,256,128,64,32,16,8,4,2,1]
Output: [1,2,4,8,16,32,64,128,256,512,1024]
Explantion: All integers have 1 bit in the binary representation, you should just sort them in ascending order.

👨‍💻 Алгоритм: 1⃣Создание функции для подсчета единиц: Создайте функцию, которая принимает целое число и возвращает количество единиц в его двоичном представлении. 2⃣Сортировка массива: Используйте встроенную функцию сортировки, передавая ей пользовательскую функцию сравнения, которая использует количество единиц в двоичном представлении чисел для сортировки. Если количество единиц одинаковое, используйте само число для сортировки. 3⃣Возврат отсортированного массива: Верните отсортированный массив. 😎 Решение:

import java.util.Arrays;

public class Solution {
    public int[] sortByBits(int[] arr) {
        return Arrays.stream(arr)
            .boxed()
            .sorted((a, b) -> {
                int countA = Integer.bitCount(a);
                int countB = Integer.bitCount(b);
                return countA == countB ? a - b : countA - countB;
            })
            .mapToInt(i -> i)
            .toArray();
    }
}

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

Нужны 12 человек для работы с искусственным интеллектом Требования: 18-45 лет Работа из дома. График свободный. Пришло задание — изучили — выполнили — получили свои деньги. Деньги вы получаете в зависимости от сложности задания. Например: За задание могут платить 500-10.000 рублей. 500 рублей — это около 5-30 минут. 10 000 руб. это 5-6 часов. Работа может быть разной: Оживить фото, создать видео, реставрировать старое фото и т.д. 💰 В среднем новичок получает до 150.000 руб в месяц. А опытный может и 300-500т. Мы обучим вас сами: ✅ 3 дня уроков по 30 минут ✅ Домашки с проверкой и оплатой бонусами ✅ Платим 10 тыс за каждую выполненную домашку ⚡ Набор заканчивается завтра. Для регистрации жмите кнопку "Зарегистрироваться": Зарегистрироваться #реклама 16+ neuromachina.ru О рекламодателе

Задача: 540. Single Element in a Sorted Array Сложность: medium Дан отсортированный массив, состоящий только из целых чисел, где каждый элемент встречается ровно дважды, кроме одного элемента, который встречается ровно один раз. Верните единственный элемент, который встречается только один раз. Ваше решение должно работать за время O(log n) и использовать O(1) памяти. Пример:

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

👨‍💻 Алгоритм: 1⃣Начиная с первого элемента, итерируемся через каждый второй элемент, проверяя, является ли следующий элемент таким же, как текущий. Если нет, то текущий элемент — это искомый элемент. 2⃣Если доходим до последнего элемента, то он является искомым элементом. Обрабатываем этот случай после завершения цикла, чтобы избежать выхода за пределы массива. 3⃣Возвращаем найденный элемент. 😎 Решение:

class Solution {
    public int singleNonDuplicate(int[] nums) {
        for (int i = 0; i < nums.length - 1; i += 2) {
            if (nums[i] != nums[i + 1]) {
                return nums[i];
            }
        }
        return nums[nums.length - 1];
    }
}

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

Онлайн-магистратура «DevOps-инженер облачных сервисов» Как стать DevOps-инженером и какие знания действительно нужны на старте? 25 марта проведём День открытых дверей онлайн-магистратуры ИТМО «DevOps-инженер облачных сервисов» в партнёрстве с Яндекс Практикумом. На встрече обсудим: — что ждут работодатели от DevOps-инженеров в 2026 году — какая главная сложность входа в профессию DevOps — как устроено обучение и вступительные экзамены Расскажем, как проходит обучение, какие навыки получают студенты магистратуры и как совмещать учёбу с работой. А ещё сможете задать вопросы команде программы. Ждём вас 25 марта в 19:00 мск. Забронировать #реклама 16+ practicum.yandex.ru О рекламодателе

Задача: 815. Bus Routes Сложность: hard Дан массив routes, представляющий автобусные маршруты, где routes[i] - это автобусный маршрут, который i-й автобус повторяет бесконечно. Например, если routes[0] = [1, 5, 7], это означает, что 0-й автобус путешествует в последовательности 1 -> 5 -> 7 -> 1 -> 5 -> 7 -> 1 -> ... бесконечно. Вы начинаете на автобусной остановке source (вы изначально не находитесь в автобусе) и хотите добраться до автобусной остановки target. Перемещаться между автобусными остановками можно только на автобусах. Верните наименьшее количество автобусов, которые вам нужно взять, чтобы доехать от source до target. Верните -1, если это невозможно. Пример:

Input: routes = [[1,2,7],[3,6,7]], source = 1, target = 6
Output: 2
Explanation: The best strategy is take the first bus to the bus stop 7, then take the second bus to the bus stop 6.

👨‍💻 Алгоритм: 1⃣Верните 0, если source и target совпадают. Инициализируйте пустую карту adjList, чтобы хранить ребра, где ключ - это автобусная остановка, а значение - список целых чисел, обозначающих индексы маршрутов, которые имеют эту остановку. Инициализируйте пустую очередь q и неупорядоченное множество vis, чтобы отслеживать посещенные маршруты. Вставьте начальные маршруты в очередь q и отметьте их посещенными в vis. 2⃣Итерация по очереди, пока она не пуста: извлеките маршрут из очереди, итерируйтесь по остановкам в маршруте. Если остановка равна target, верните busCount. В противном случае, итерируйтесь по маршрутам для этой остановки в карте adjList, добавьте непосещенные маршруты в очередь и отметьте их посещенными. 3⃣Верните -1 после завершения обхода в ширину (BFS). 😎 Решение:

class Solution {
    public int numBusesToDestination(int[][] routes, int source, int target) {
        if (source == target) return 0;

        Map<Integer, List<Integer>> adjList = new HashMap<>();
        for (int route = 0; route < routes.length; route++) {
            for (int stop : routes[route]) {
                adjList.computeIfAbsent(stop, k -> new ArrayList<>()).add(route);
            }
        }

        Queue<Integer> q = new LinkedList<>();
        Set<Integer> vis = new HashSet<>();
        for (int route : adjList.getOrDefault(source, Collections.emptyList())) {
            q.add(route);
            vis.add(route);
        }

        int busCount = 1;
        while (!q.isEmpty()) {
            int size = q.size();

            for (int i = 0; i < size; i++) {
                int route = q.poll();

                for (int stop : routes[route]) {
                    if (stop == target) {
                        return busCount;
                    }

                    for (int nextRoute : adjList.getOrDefault(stop, Collections.emptyList())) {
                        if (!vis.contains(nextRoute)) {
                            vis.add(nextRoute);
                            q.add(nextRoute);
                        }
                    }
                }
            }
            busCount++;
        }
        return -1;
    }

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

Нужны 7 желающих для работы с искусственным интеллектом. Требования: 18-45 лет Работа из дома. График свободный. Пришло задание — изучили — выполнили — получили свои деньги. Деньги вы получаете в зависимости от сложности задания. Например: За задание могут платить 500-10.000 рублей. 500 рублей — это около 5-30 минут. 10 000 руб. это 5-6 часов. Работа может быть разной: Оживить фото, создать видео, реставрировать старое фото и т.д. 💰 В среднем новичок получает до 150.000 руб в месяц. А опытный может и 300-500т. Мы обучим вас сами: — 3 дня уроков по 30 минут — Домашки с проверкой и оплатой бонусами — Платим 10 тыс за каждую выполненную домашку ⚡ Набор заканчивается завтра. Для регистрации жмите кнопку "Зарегистрироваться": Зарегистрироваться #реклама 16+ ganstaagency.com О рекламодателе

Задача: 1028. Recover a Tree From Preorder Traversal Сложность: hard Мы запускаем предварительный поиск в глубину (DFS) на корне двоичного дерева. На каждый узел в этом обходе мы выводим D тире (где D - глубина этого узла), а затем выводим значение этого узла.Если глубина узла равна D, то глубина его ближайшего потомка равна D + 1.Глубина корневого узла равна 0. Если у узла есть только один ребенок, то этот ребенок гарантированно является левым ребенком. Учитывая выходной обход этого обхода, восстановите дерево и верните его корень. Пример:

Input: traversal = "1-2--3--4-5--6--7"
Output: [1,2,5,3,4,6,7]

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

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

public class Solution {
    public TreeNode recoverFromPreorder(String S) {
        Stack<TreeNode> stack = new Stack<>();
        for (int i = 0; i < S.length();) {
            int level = 0;
            while (i < S.length() && S.charAt(i) == '-') {
                level++;
                i++;
            }
            
            int value = 0;
            while (i < S.length() && Character.isDigit(S.charAt(i))) {
                value = value * 10 + (S.charAt(i) - '0');
                i++;
            }
            
            TreeNode node = new TreeNode(value);
            if (level == stack.size()) {
                if (!stack.isEmpty()) {
                    stack.peek().left = node;
                }
            } else {
                while (level != stack.size()) {
                    stack.pop();
                }
                stack.peek().right = node;
            }
            stack.push(node);
        }
        
        while (stack.size() > 1) {
            stack.pop();
        }
        
        return stack.peek();
    }
}

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

Задача: 905. Sort Array By Parity Сложность: easy Если задан целочисленный массив nums, переместите все четные числа в начало массива, а затем все нечетные. Верните любой массив, удовлетворяющий этому условию. Пример:

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

👨‍💻 Алгоритм: 1⃣Создать два списка: один для четных чисел, другой для нечетных. 2⃣Пройтись по массиву и добавить четные числа в один список, а нечетные в другой. 3⃣Объединить два списка и вернуть результат. 😎 Решение:

class Solution {
    public int[] sortArrayByParity(int[] nums) {
        List<Integer> evens = new ArrayList<>();
        List<Integer> odds = new ArrayList<>();
        for (int num : nums) {
            if (num % 2 == 0) {
                evens.add(num);
            } else {
                odds.add(num);
            }
        }
        evens.addAll(odds);
        int[] result = new int[nums.length];
        for (int i = 0; i < result.length; i++) {
            result[i] = evens.get(i);
        }
        return result;
    }
}

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

Игровой бесплатный курс по нейрографике ✨4 дня практики для тех, кто хочет жить счастливо, без стресса и обид. ❤️💰🏠Научный метод, которые должна знать каждая женщина, чтобы: -избавиться от негатива, слабости и апатии; -наполниться энергией вдохновения и творчества; -осуществить свои истинные желания, зная, чего на самом деле хочется вам, а не окружению. Меня зовут Наталья Шевякова (психолог, эмотолог). 🎓Я инструктор НейроГрафики и с радостью приглашаю вас на обучающий игровой мини-курс. Его прошли уже более 15000 человек. Всё покажу на живых примерах, просто, с элементами игры — и вы сами почувствуете, как это работает! Не нужно быть художником, чтобы рисовать нейрографику. Это получается у всех! Вам понадобятся лишь бумага, карандаши, маркеры и готовность пробовать новое. Переходите по ссылке, проходите курс. Смотреть #реклама 16+ neuronataly.com О рекламодателе

Задача: 941. Valid Mountain Array Сложность: easy Задав массив целых чисел arr, верните true тогда и только тогда, когда он является допустимым горным массивом. Напомним, что arr является горным массивом тогда и только тогда, когда: arr.length >= 3 Существует некоторое i с 0 < i < arr.length - 1 такое, что: arr[0] < arr[1] < ... < arr[i - 1] < arr[i] arr[i] > arr[i + 1] > ... > arr[arr.length - 1] Пример:

Input: arr = [2,1]
Output: false

👨‍💻 Алгоритм: 1⃣Убедиться, что длина массива не меньше 3. 2⃣Найти вершину горы, которая удовлетворяет условиям горного массива. Проверить, что все элементы слева от вершины строго возрастают. Проверить, что все элементы справа от вершины строго убывают. 3⃣Вернуть true, если оба условия выполнены, иначе вернуть false. 😎 Решение:

class Solution {
    public boolean validMountainArray(int[] arr) {
        if (arr.length < 3) return false;
        
        int i = 1;
        while (i < arr.length && arr[i] > arr[i - 1]) i++;
        
        if (i == 1 || i == arr.length) return false;
        
        while (i < arr.length && arr[i] < arr[i - 1]) i++;
        
        return i == arr.length;
    }
}

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

Задача: №45. Jump Game II Сложность: medium Вам дан массив целых чисел nums длины n, где каждый элемент nums[i] представляет максимальную длину прыжка вперёд с индекса i. Изначально вы находитесь на nums[0]. Нужно вернуть минимальное количество прыжков, необходимых для достижения последнего элемента массива nums[n - 1]. Гарантируется, что добраться до конца можно. Пример:

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

👨‍💻 Алгоритм: 1⃣Начало — текущие настройки— его конец ,Завести три переменные: near— начало стандартной настройки, far— его конец, jumps— количество прыжков. 2⃣Не достиг конца массива , находим максим.) в пределах текущей позиции ( доНе farдойдя до конца массива, находим ступеньку достижимой позиции ( farthest) в пределах текущей позиции ( nearдо far). 3⃣Обновляем границы границы ( nearи far) и увеличиваем счётчик прыжков. 😎 Решение:

class Solution {
    public int jump(int[] nums) {
        int near = 0, far = 0, jumps = 0;

        while (far < nums.length - 1) {
            int farthest = 0;
            for (int i = near; i <= far; i++) {
                farthest = Math.max(farthest, i + nums[i]);
            }
            near = far + 1;
            far = farthest;
            jumps++;
        }

        return jumps;        
    }
}

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

Высшее образование дистанционно в Московском вузе Хотите карьерного роста, но нет времени на очное обучение или не сдавали ЕГЭ? Вы можете получить высшее образование дистанционно, легко совмещая с работой. ✅ Диплом государственного образца от ТОП-вуза Москвы, который ценится работодателями. ✅ Гибкий график: лекции доступны 24/7, а онлайн-семинары проходят по выходным. ✅ Актуальные знания: программы обновляются ежегодно под запросы работодателей, преподают практики. ✅ 15 востребованных направлений: от IT и интернет-маркетинга до психологии и управления. ✅ Доступно: стоимость от 6 670 ₽/мес, возможна оплата в рассрочку и материнским капиталом. Узнайте подробнее и получите консультацию приемной комиссии о возможности поступления: Узнать больше #реклама 16+ mp-kmept.ru О рекламодателе