اکنون در دسترس! پژوهش تلگرام ۲۰۲۵ — مهمترین بینشهای سال 
Java | LeetCode
رفتن به کانال در Telegram
Cайт easyoffer.ru Реклама @easyoffer_adv ВП @easyoffer_vp Тесты t.me/+icUwivvbGOkwNWRi Вопросы собесов t.me/+7ESm0VKXC4tjYzky Вакансии t.me/+4pspF5nDjgM4MjQy
نمایش بیشتر6 661
مشترکین
-424 ساعت
-177 روز
-4530 روز
آرشیو پست ها
6 662
Не дайте хакерам использовать утечки против вас
Преступники активно используют слитые данные компаний, чтобы получить несанкционированный доступ. А объем таких утечек за 2024 год вырос на 64%.
На вебинаре расскажем, как действовать на опережение и не допустить масштабных взломов с крупными финансовыми потерями.
Подключайтесь 7 октября, чтобы узнать:
Как утечки открывают хакерам двери в инфраструктуру;
Как отслеживать сливы с помощью сервиса мониторинга Solar AURA;
Как базы утечек могут быть использованы для пентестов.
Присоединяйтесь, чтобы научиться закрывать уязвимости раньше, чем их используют хакеры. К тому же мы разыграем три билета на SOC Forum 2025 — главное событие этой осени в российском ИБ-мире.
Зарегистрироваться
#реклама 16+
rt-solar.ru
О рекламодателе
6 662
Задача: 359. Logger Rate Limiter
Сложность: easy
Создайте систему логирования, которая получает поток сообщений вместе с их временными метками. Каждое уникальное сообщение должно печататься не чаще, чем раз в 10 секунд (то есть, сообщение, напечатанное во временной метке t, предотвратит печать других идентичных сообщений до временной метки t + 10).
Все сообщения будут приходить в хронологическом порядке. Несколько сообщений могут поступить в одно и то же время.
Реализуйте класс Logger:
Logger() Инициализирует объект логгера.
bool shouldPrintMessage(int timestamp, string message) Возвращает true, если сообщение должно быть напечатано в данной временной метке, в противном случае возвращает false.
Пример:
Input
["Logger", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage"]
[[], [1, "foo"], [2, "bar"], [3, "foo"], [8, "bar"], [10, "foo"], [11, "foo"]]
Output
[null, true, true, false, false, false, true]
Explanation
Logger logger = new Logger();
logger.shouldPrintMessage(1, "foo"); // return true, next allowed timestamp for "foo" is 1 + 10 = 11
logger.shouldPrintMessage(2, "bar"); // return true, next allowed timestamp for "bar" is 2 + 10 = 12
logger.shouldPrintMessage(3, "foo"); // 3 < 11, return false
logger.shouldPrintMessage(8, "bar"); // 8 < 12, return false
logger.shouldPrintMessage(10, "foo"); // 10 < 11, return false
logger.shouldPrintMessage(11, "foo"); // 11 >= 11, return true, next allowed timestamp for "foo" is 11 + 10 = 21class Logger {
private HashMap<String, Integer> msgDict;
public Logger() {
msgDict = new HashMap<String, Integer>();
}
public boolean shouldPrintMessage(int timestamp, String message) {
if (!this.msgDict.containsKey(message)) {
this.msgDict.put(message, timestamp);
return true;
}
Integer oldTimestamp = this.msgDict.get(message);
if (timestamp - oldTimestamp >= 10) {
this.msgDict.put(message, timestamp);
return true;
} else
return false;
}
}6 662
Тариф, с которым хватит на всё
50 ГБ и безлимитные минуты за 390 ₽ в месяц, если перенесете номер в Т-Мобайл до 30 сентября
Узнать больше
#реклама
tbank.ru
О рекламодателе
6 662
Задача: 187. Repeated DNA Sequences
Сложность: medium
ДНК состоит из серии нуклеотидов, обозначаемых как 'A', 'C', 'G' и 'T'.
Например, "ACGAATTCCG" — это последовательность ДНК.
При изучении ДНК полезно определять повторяющиеся последовательности внутри молекулы ДНК.
Дана строка s, представляющая последовательность ДНК. Верните все последовательности длиной 10 букв (подстроки), которые встречаются более одного раза в молекуле ДНК. Ответ можно возвращать в любом порядке.
Пример:
Input: s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT" Output: ["AAAAACCCCC","CCCCCAAAAA"]👨💻 Алгоритм: 1⃣Перебираем начальные позиции последовательности от 1 до 𝑁−𝐿, где 𝑁 — длина строки, а 𝐿 — длина подстроки (в данном случае 10): Если начальная позиция 𝑠𝑡𝑎𝑟𝑡==0, вычисляем хеш первой последовательности 𝑠[0:𝐿]. В противном случае вычисляем скользящий хеш из предыдущего значения хеша. 2⃣Проверяем хеш в хешсете: Если хеш уже существует в хешсете, значит, мы нашли повторяющуюся последовательность, и пора обновить вывод. В противном случае добавляем хеш в хешсет. 3⃣Возвращаем список вывода, содержащий все повторяющиеся последовательности. 😎 Решение:
class Solution {
public List<String> findRepeatedDnaSequences(String s) {
int L = 10, n = s.length();
if (n <= L) return new ArrayList();
int a = 4, aL = (int) Math.pow(a, L);
Map<Character, Integer> toInt = new HashMap() {
{
put('A', 0);
put('C', 1);
put('G', 2);
put('T', 3);
}
};
int[] nums = new int[n];
for (int i = 0; i < n; ++i) nums[i] = toInt.get(s.charAt(i));
int h = 0;
Set<Integer> seen = new HashSet();
Set<String> output = new HashSet();
for (int start = 0; start < n - L + 1; ++start) {
if (start != 0) h = h * a -
nums[start - 1] * aL +
nums[start + L - 1];
else for (int i = 0; i < L; ++i) h = h * a + nums[i];
if (seen.contains(h)) output.add(s.substring(start, start + L));
seen.add(h);
}
return new ArrayList<String>(output);
}
}6 662
Международные расчёты по ставке — от 0,05% за платёж
Торгуйте с Китаем и другими странами по самой выгодной ставке — от 0,05% за платёж.
Важная новость для импортёров и экспортёров перед новым деловым сезоном: Альфа-Банк улучшил условия международных расчётов для бизнеса.
Это значит, что сделки стали выгоднее, особенно для среднего и крупного бизнеса: чем больше будет сумма сделки — тем ниже комиссия.
Например, для контрактов от 50 000 ¥ тариф составит всего 0,05% — в разы меньше среднего по рынку. Предложение подойдёт для расчётов с партнёрами из Китая, Беларуси, Вьетнама, Индии, Казахстана и других стран.
А ещё Альфа-Банк обеспечит полное сопровождение сделки на всех этапах. Персональный валютный контролёр поможет избежать нарушений, а менеджер с опытом в ВЭД подскажет по любым вопросам.
Перейти на сайт
Финансовые услуги оказывает: АО "Альфа-Банк".
#реклама
alfabank.ru
О рекламодателе
6 662
Задача: 605. Can Place Flowers
Сложность: easy
У вас есть длинная клумба, на которой некоторые участки засажены, а некоторые нет. Однако цветы нельзя сажать на соседних участках.
Дан целочисленный массив
flowerbed, содержащий 0 и 1, где 0 означает пустой участок, а 1 — занятый участок, и целое число n. Верните true, если n новых цветов можно посадить на клумбе, не нарушая правила о соседних цветах, и false в противном случае.
Пример:
Input: flowerbed = [1,0,0,0,1], n = 1
Output: trueclass Solution {
public boolean canPlaceFlowers(int[] flowerbed, int n) {
int count = 0;
for (int i = 0; i < flowerbed.length; i++) {
if (flowerbed[i] == 0) {
boolean emptyLeft = i == 0 || flowerbed[i - 1] == 0;
boolean emptyRight = i == flowerbed.length - 1 || flowerbed[i + 1] == 0;
if (emptyLeft && emptyRight) {
flowerbed[i] = 1;
count++;
}
}
}
return count >= n;
}
}6 662
Задача: 384. Shuffle an Array
Сложность: medium
Дан целочисленный массив nums. Разработайте алгоритм для случайного перемешивания массива. Все перестановки массива должны быть равновероятны в результате перемешивания.
Реализуйте класс Solution:
Solution(int[] nums): Инициализирует объект целочисленным массивом nums.
int[] reset(): Сбрасывает массив в его исходную конфигурацию и возвращает его.
int[] shuffle(): Возвращает случайное перемешивание массива.
Пример:
Input: ransomNote = "a", magazine = "b" Output: false👨💻 Алгоритм: 1⃣Алгоритм Фишера-Йейтса удивительно похож на решение грубой силы. На каждой итерации алгоритма мы генерируем случайное целое число между текущим индексом и последним индексом массива. 2⃣Затем мы меняем местами элементы на текущем индексе и выбранном индексе. Это симулирует выбор (и удаление) элемента из "шляпы", так как следующий диапазон, из которого мы выбираем случайный индекс, не будет включать последний обработанный элемент. 3⃣Один небольшой, но важный момент заключается в том, что возможно поменять элемент сам с собой - в противном случае некоторые перестановки массива были бы более вероятны, чем другие. 😎 Решение:
class Solution {
private int[] array;
private int[] original;
Random rand = new Random();
private int randRange(int min, int max) {
return rand.nextInt(max - min) + min;
}
private void swapAt(int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
public Solution(int[] nums) {
array = nums;
original = nums.clone();
}
public int[] reset() {
array = original;
original = original.clone();
return original;
}
public int[] shuffle() {
for (int i = 0; i < array.length; i++) {
swapAt(i, randRange(i, array.length));
}
return array;
}
}6 662
⚡️ Айтишник из «VISION» скупил топовые айти-курсы и выложил гигабайты материалов к себе
Каждый найдет что-то по душе:
903 ГБ — Python
812 ГБ — Frontend
978 ГБ — C, C++
804 ГБ — Java
432 ГБ — C#, GameDev
411 ГБ — SQL & БД
309 ГБ — DevOps
998 ГБ — ИБ & Хакинг
773 ГБ — Kotlin, Swift
189 ГБ — PHP
201 ГБ — GoLang
170 ГБ — Rust
167 ГБ — QA-Тестирование
310 ГБ — 1C + Лицензии
495 ГБ — Машинное обучение
704 ГБ — Аналитика Данных
991 ГБ — Дизайн
Материалы в закрепе, постоянно пополняются👆🏻
6 662
Такси для бизнеса. Яндекс Go
Оптимизируйте свои расходы и повысьте эффективность бизнеса с Яндекс Go
Узнать больше
#реклама
business.go.yandex
О рекламодателе
6 662
Задача: 461. Hamming Distance
Сложность: easy
Расстояние Хэмминга между двумя целыми числами — это количество позиций, в которых соответствующие биты различны.
Даны два целых числа x и y, верните расстояние Хэмминга между ними.
Пример:
Input: x = 3, y = 1 Output: 1👨💻 Алгоритм: 1⃣Во-первых, стоит упомянуть, что в большинстве (или, по крайней мере, во многих) языков программирования есть встроенные функции для подсчета битов, установленных в 1. Если вам нужно решить такую задачу в реальном проекте, то лучше использовать эти функции, чем изобретать велосипед. 2⃣Однако, поскольку это задача на LeetCode, использование встроенных функций можно сравнить с "реализацией LinkedList с использованием LinkedList". Поэтому рассмотрим также несколько интересных ручных алгоритмов для подсчета битов. 3⃣Пошаговый подсчет битов: Выполните побитовое XOR между x и y. Инициализируйте счетчик bitCount = 0. Пока число не равно нулю: Если текущий бит равен 1, увеличьте bitCount. Сдвиньте число вправо на один бит. Возвращайте bitCount. 😎 Решение:
class Solution {
public int hammingDistance(int x, int y) {
return Integer.bitCount(x ^ y);
}
}6 662
Задача: 1246. Palindrome Removal
Сложность: hard
Вам дан целочисленный массив arr. За один ход вы можете выбрать палиндромный подмассив arr[i], arr[i + 1], ..., arr[j], где i <= j, и удалить этот подмассив из данного массива. Обратите внимание, что после удаления подмассива элементы слева и справа от него перемещаются, чтобы заполнить пробел, образовавшийся в результате удаления. Верните минимальное количество ходов, необходимое для удаления всех чисел из массива.
Пример:
Input: arr = [1,2] Output: 2👨💻 Алгоритм: 1⃣Базовый случай: Если подмассив состоит из одного элемента, то его удаление займет 1 ход, поэтому dp[i][i] = 1. 2⃣Рекурсивный случай: Если arr[i] == arr[j], то мы можем удалить их в одном ходе, если подмассив arr[i+1...j-1] можно удалить за dp[i+1][j-1] ходов, тогда dp[i][j] = dp[i+1][j-1] (если удалим подмассив arr[i+1...j-1] и затем удалим arr[i] и arr[j]). 3⃣В противном случае, минимальное количество ходов для удаления подмассива arr[i...j] будет равно 1 + минимум ходов для удаления каждого из подмассивов arr[i...k] и arr[k+1...j], где i <= k < j. То есть, dp[i][j] = min(dp[i][k] + dp[k+1][j]) для всех k от i до j-1. 😎 Решение:
public class Solution {
public int minMovesToDelete(int[] arr) {
int n = arr.length;
int[][] dp = new int[n][n];
for (int i = 0; i < n; i++) {
dp[i][i] = 1;
}
for (int length = 2; length <= n; length++) {
for (int i = 0; i <= n - length; i++) {
int j = i + length - 1;
if (arr[i] == arr[j]) {
dp[i][j] = length > 2 ? dp[i + 1][j - 1] : 1;
} else {
dp[i][j] = Integer.MAX_VALUE;
for (int k = i; k < j; k++) {
dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k + 1][j]);
}
}
}
}
return dp[0][n - 1];
}
}6 662
Открой мощь новых MSI с GeForce RTX 50
Серия NVIDIA GeForce RTX 50 в ноутбуках MSI — это квантовый скачок в мире мощности. Игры на максималках, 3D-рендер без ожиданий, монтаж видео в реальном времени и искусственный интеллект, работающий с небывалой скоростью. Эта техника создана не просто для задач — она их уничтожает. Будь в центре производительности нового поколения. MSI с RTX 50 — когда ты не хочешь ждать, а действуешь.
Узнать больше
#реклама
msi.gm
О рекламодателе
6 662
Задача: 903. Valid Permutations for DI Sequence
Сложность: hard
Вам дана строка s длины n, где s[i] либо: 'D' означает убывание, либо 'I' означает возрастание. Перестановка perm из n + 1 целых чисел всех целых чисел в диапазоне [0, n] называется допустимой, если для всех допустимых i: если s[i] == 'D', то perm[i] > perm[i + 1], а если s[i] == 'I', то perm[i] < perm[i + 1]. Верните количество допустимых перестановок perm. Поскольку ответ может быть большим, верните его по модулю 109 + 7.
Пример:
Input: s = "DID" Output: 5👨💻 Алгоритм: 1⃣Создать двумерный массив dp, где dp[i][j] представляет количество допустимых перестановок длины i, оканчивающихся на j. 2⃣Заполнить массив dp, учитывая условия возрастания и убывания из строки s. 3⃣Вернуть сумму dp[n][j] для всех j, что даст количество допустимых перестановок длины n + 1. 😎 Решение:
class Solution {
public int numPermsDISequence(String s) {
int MOD = 1_000_000_007;
int n = s.length();
int[][] dp = new int[n + 1][n + 1];
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
if (s.charAt(i - 1) == 'D') {
for (int k = j; k < i; k++) {
dp[i][j] = (dp[i][j] + dp[i - 1][k]) % MOD;
}
} else {
for (int k = 0; k < j; k++) {
dp[i][j] = (dp[i][j] + dp[i - 1][k]) % MOD;
}
}
}
}
int result = 0;
for (int j = 0; j <= n; j++) {
result = (result + dp[n][j]) % MOD;
}
return result;
}
}6 662
Задача: 491. Non-decreasing Subsequences
Сложность: medium
Дан массив целых чисел nums. Верните все возможные различные неубывающие подпоследовательности данного массива, содержащие как минимум два элемента. Вы можете вернуть ответ в любом порядке.
Пример:
Input: nums = [4,6,7,7] Output: [[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]👨💻 Алгоритм: 1⃣Инициализация и запуск функции обратного отслеживания Создайте множество для хранения результатов. Создайте список для хранения текущей последовательности. Запустите рекурсивную функцию обратного отслеживания с начальным индексом 0. 2⃣Функция обратного отслеживания Если текущий индекс равен длине массива, проверьте длину текущей последовательности и добавьте её в результат, если она содержит не менее двух элементов. Если текущая последовательность остаётся неубывающей после добавления текущего элемента массива, добавьте этот элемент, вызовите рекурсивную функцию для следующего индекса и удалите элемент из последовательности (обратное отслеживание). Всегда вызывайте рекурсивную функцию для следующего индекса без добавления текущего элемента. 3⃣Возврат результата После завершения всех рекурсивных вызовов преобразуйте множество результатов в список и верните его. 😎 Решение:
class Solution {
private void backtrack(int[] nums, int index, List<Integer> sequence,
Set<List<Integer>> result) {
if (index == nums.length) {
if (sequence.size() >= 2) {
result.add(new ArrayList<>(sequence));
}
return;
}
if (sequence.isEmpty() ||
sequence.get(sequence.size() - 1) <= nums[index]) {
sequence.add(nums[index]);
backtrack(nums, index + 1, sequence, result);
sequence.remove(sequence.size() - 1);
}
backtrack(nums, index + 1, sequence, result);
}
public List<List<Integer>> findSubsequences(int[] nums) {
Set<List<Integer>> result = new HashSet<List<Integer>>();
List<Integer> sequence = new ArrayList<Integer>();
backtrack(nums, 0, sequence, result);
return new ArrayList(result);
}
}6 662
Задача: 892. Surface Area of 3D Shapes
Сложность: easy
Вам дана сетка n x n, на которой вы разместили несколько кубиков 1 x 1 x 1. Каждое значение v = grid[i][j] представляет собой башню из v кубиков, размещенных на вершине ячейки (i, j). После размещения кубиков вы решили склеить все непосредственно прилегающие кубики друг с другом, образовав несколько неправильных 3D-фигур. Верните общую площадь поверхности получившихся фигур. Примечание: нижняя грань каждой фигуры учитывается в площади ее поверхности.
Пример:
Input: grid = [[1,2],[3,4]] Output: 34👨💻 Алгоритм: 1⃣Пройти по всей сетке и для каждой башни (ячейки) посчитать начальную площадь поверхности: добавить площадь верхней и нижней граней, а также четыре боковые грани. 2⃣Для каждой башни уменьшить площадь боковых граней, которые прилегают к соседним башням, с учетом высоты соседних башен. 3⃣Просуммировать все значения площадей для получения итоговой площади поверхности. 😎 Решение:
public int surfaceArea(int[][] grid) {
int n = grid.length;
int area = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] > 0) {
area += (grid[i][j] * 4) + 2;
}
if (i > 0) {
area -= Math.min(grid[i][j], grid[i-1][j]) * 2;
}
if (j > 0) {
area -= Math.min(grid[i][j], grid[i][j-1]) * 2;
}
}
}
return area;6 662
Задача: 79. Word Search
Сложность: medium
Дана сетка символов размером m на n, называемая board, и строка word. Верните true, если слово word существует в сетке.
Слово можно составить из букв последовательно смежных ячеек, где смежные ячейки находятся рядом по горизонтали или вертикали. Одна и та же ячейка с буквой не может быть использована более одного раза.
Пример:
Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED" Output: true👨💻 Алгоритм: 1⃣Общий подход к алгоритмам обратной трассировки: В каждом алгоритме обратной трассировки существует определенный шаблон кода. Например, один из таких шаблонов можно найти в нашем разделе "Рекурсия II". Скелет алгоритма представляет собой цикл, который проходит через каждую ячейку в сетке. Для каждой ячейки вызывается функция обратной трассировки (backtrack()), чтобы проверить, можно ли найти решение, начиная с этой ячейки. 2⃣Функция обратной трассировки: Эта функция, реализуемая как алгоритм поиска в глубину (DFS), часто представляет собой рекурсивную функцию. Первым делом проверяется, достигнут ли базовый случай рекурсии, когда слово для сопоставления пусто, то есть для каждого префикса слова уже найдено совпадение. Затем проверяется, не является ли текущее состояние недопустимым: либо позиция ячейки выходит за границы доски, либо буква в текущей ячейке не совпадает с первой буквой слова. 3⃣Исследование и завершение: Если текущий шаг допустим, начинается исследование с использованием стратегии DFS. Сначала текущая ячейка помечается как посещенная, например, любой неалфавитный символ подойдет. Затем осуществляется итерация через четыре возможных направления: вверх, вправо, вниз и влево. Порядок направлений может быть изменен по предпочтениям пользователя. В конце исследования ячейка возвращается к своему исходному состоянию, и возвращается результат исследования. 😎 Решение:
class Solution {
private char[][] board;
private int ROWS;
private int COLS;
public boolean exist(char[][] board, String word) {
this.board = board;
this.ROWS = board.length;
this.COLS = board[0].length;
for (int row = 0; row < this.ROWS; ++row) {
for (int col = 0; col < this.COLS; ++col) {
if (this.backtrack(row, col, word, 0)) return true;
}
}
return false;
}
protected boolean backtrack(int row, int col, String word, int index) {
if (index >= word.length()) return true;
if (
row < 0 ||
row == this.ROWS ||
col < 0 ||
col == this.COLS ||
this.board[row][col] != word.charAt(index)
) return false;
boolean ret = false;
this.board[row][col] = '#';
int[] rowOffsets = { 0, 1, 0, -1 };
int[] colOffsets = { 1, 0, -1, 0 };
for (int d = 0; d < 4; ++d) {
ret = this.backtrack(
row + rowOffsets[d],
col + colOffsets[d],
word,
index + 1
);
if (ret) break;
}
this.board[row][col] = word.charAt(index);
return ret;
}
}6 662
Задача: 532. K-diff Pairs in an Array
Сложность: medium
Дан массив целых чисел nums и целое число k. Верните количество уникальных пар с разницей k в массиве.
Пара с разницей k — это пара целых чисел (nums[i], nums[j]), для которой выполняются следующие условия:
0 <= i, j < nums.length
i != j
|nums[i] - nums[j]| == k
Обратите внимание, что |val| обозначает абсолютное значение val.
Пример:
Input: nums = [3,1,4,1,5], k = 2 Output: 2 Explanation: There are two 2-diff pairs in the array, (1, 3) and (3, 5). Although we have two 1s in the input, we should only return the number of unique pairs.👨💻 Алгоритм: 1⃣ Создайте частотный хэш-словарь для подсчета количества каждого уникального числа в массиве nums. 2⃣ Для каждого ключа в хэш-словаре проверьте, можно ли найти пару, удовлетворяющую условиям: Если k > 0, проверьте, существует ли ключ, равный x + k. Если k == 0, проверьте, есть ли более одного вхождения x. 3⃣ Увеличьте счётчик результатов, если условие выполняется. 😎 Решение:
public class Solution {
public int findPairs(int[] nums, int k) {
int result = 0;
HashMap <Integer,Integer> counter = new HashMap<>();
for (int n: nums) {
counter.put(n, counter.getOrDefault(n, 0)+1);
}
for (Map.Entry <Integer, Integer> entry: counter.entrySet()) {
int x = entry.getKey();
int val = entry.getValue();
if (k > 0 && counter.containsKey(x + k)) {
result++;
} else if (k == 0 && val > 1) {
result++;
}
}
return result;
}
}6 662
Задача: 949. Largest Time for Given Digits
Сложность: medium
Учитывая массив arr из 4 цифр, найдите самое позднее 24-часовое время, которое можно составить, используя каждую цифру ровно один раз. 24-часовое время имеет формат "ЧЧ:ММ", где ЧЧ - от 00 до 23, а ММ - от 00 до 59. Самое раннее 24-часовое время - 00:00, а самое позднее - 23:59. Верните самое позднее 24-часовое время в формате "HH:MM". Если не удается определить действительное время, возвращается пустая строка.
Пример:
Input: arr = [1,2,3,4] Output: "23:41"👨💻 Алгоритм: 1⃣Перебрать все возможные перестановки массива arr. 2⃣Проверить каждую перестановку, можно ли из нее составить допустимое 24-часовое время. Найти самое позднее допустимое время среди всех перестановок. 3⃣Алгоритм Перебрать все возможные перестановки массива arr. Проверить каждую перестановку, можно ли из нее составить допустимое 24-часовое время. Найти самое позднее допустимое время среди всех перестановок. Вернуть найденное время в формате "HH ". Если допустимое время не найдено, вернуть пустую строку. 😎 Решение:
import java.util.*;
class Solution {
public String largestTimeFromDigits(int[] arr) {
int maxTime = -1;
List<int[]> permutations = new ArrayList<>();
permute(arr, 0, permutations);
for (int[] perm : permutations) {
int hours = perm[0] * 10 + perm[1];
int minutes = perm[2] * 10 + perm[3];
if (hours < 24 && minutes < 60) {
maxTime = Math.max(maxTime, hours * 60 + minutes);
}
}
if (maxTime == -1) {
return "";
}
String hours = String.format("%02d", maxTime / 60);
String minutes = String.format("%02d", maxTime % 60);
return hours + ":" + minutes;
}
private void permute(int[] nums, int start, List<int[]> res) {
if (start == nums.length) {
res.add(nums.clone());
return;
}
for (int i = start; i < nums.length; i++) {
swap(nums, start, i);
permute(nums, start + 1, res);
swap(nums, start, i);
}
}
private void swap(int[] nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}6 662
Вебинар с ведущим застройщиком Кипра в Лимасоле
Как заработать на Кипре 20% ROI за 2 года?
📅 2 октября в 19:00 по Москве
На вебинаре расскажем об эксклюзивном стоке Tranio в проекте от ведущего застройщика.
Регистрируйтесь бесплатно!
Зарегистрироваться
#реклама 16+
webinar.tranio.ru
О рекламодателе
6 662
Задача: 223. Rectangle Area
Сложность: medium
Даны координаты двух прямоугольных прямоугольников на двумерной плоскости, верните общую площадь, покрытую этими двумя прямоугольниками.
Первый прямоугольник определяется его нижним левым углом (ax1, ay1) и верхним правым углом (ax2, ay2).
Второй прямоугольник определяется его нижним левым углом (bx1, by1) и верхним правым углом (bx2, by2).
Пример:
Input: ax1 = -3, ay1 = 0, ax2 = 3, ay2 = 4, bx1 = 0, by1 = -1, bx2 = 9, by2 = 2 Output: 45👨💻 Алгоритм: 1⃣Вычислить площади двух прямоугольников: Рассчитайте площади прямоугольников A и B, умножив их ширину на высоту. 2⃣Вычислить перекрытие: Найдите перекрытие по оси X и оси Y. Если перекрытие существует, вычислите площадь перекрытия. 3⃣Вычислить и вернуть общую площадь: Вычтите площадь перекрытия из суммы площадей двух прямоугольников и верните результат. 😎 Решение:
class Solution {
public int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
int areaOfA = (ay2 - ay1) * (ax2 - ax1);
int areaOfB = (by2 - by1) * (bx2 - bx1);
int left = Math.max(ax1, bx1);
int right = Math.min(ax2, bx2);
int xOverlap = right - left;
int top = Math.min(ay2, by2);
int bottom = Math.max(ay1, by1);
int yOverlap = top - bottom;
int areaOfOverlap = 0;
if (xOverlap > 0 && yOverlap > 0) {
areaOfOverlap = xOverlap * yOverlap;
}
int totalArea = areaOfA + areaOfB - areaOfOverlap;
return totalArea;
}
}