TGViewer
Channel Public Channel
JavaScript | LeetCode

JavaScript | LeetCode

@easy_frontend_task

Сайт: https://easyoffer.ru/
Все каналы: t.me/+xGeAw6ckJ4liYzQy

Контакт для рекламы: @sendme_ads
Subscribers
8.32K
Photos
248
Videos
1
Links
1.4K

Showing posts older than #2137 · Back to latest

Older Posts 20 shown
Post #2135 516
Задача: 368. Largest Divisible Subset
Сложность: medium

Дан набор различных положительных целых чисел nums. Вернуть наибольшее подмножество answer, такое что каждая пара (answer[i], answer[j]) элементов в этом подмножестве удовлетворяет условию:
answer[i] % answer[j] == 0, или
answer[j] % answer[i] == 0
Если существует несколько решений, вернуть любое из них.

Пример:
Input: nums = [1,2,3]
Output: [1,2]
Explanation: [1,3] is also accepted.


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

1⃣Если число 8 может быть разделено на элемент X_i, то добавив число 8 к EDS(X_i), мы получим еще одно делимое подмножество, которое заканчивается на 8, согласно нашему следствию I. И это новое подмножество является потенциальным значением для EDS(8). Например, поскольку 8 % 2 == 0, то {2,8} может быть конечным значением для EDS(8), и аналогично для подмножества {2,4,8}, полученного из EDS(4).

2⃣Если число 8 не может быть разделено на элемент X_i, то можно быть уверенным, что значение EDS(X_i) не повлияет на EDS(8), согласно определению делимого подмножества. Например, подмножество EDS(7)={7} не имеет влияния на EDS(8).

3⃣Затем мы выбираем наибольшие новые подмножества, которые мы формируем с помощью EDS(X_i). В частности, подмножество {8} является допустимым кандидатом для EDS(8). И в гипотетическом случае, когда 8 не может быть разделено ни на один из предыдущих элементов, мы бы имели EDS(8)={8}.

😎 Решение:
class Solution {
largestDivisibleSubset(nums) {
const n = nums.length;
if (n === 0) return [];

nums.sort((a, b) => a - b);
const EDS = Array.from({ length: n }, () => []);

for (let i = 0; i < n; i++) {
let maxSubset = [];
for (let k = 0; k < i; k++) {
if (nums[i] % nums[k] === 0 && maxSubset.length < EDS[k].length) {
maxSubset = EDS[k];
}
}
EDS[i] = [...maxSubset, nums[i]];
}

let ret = [];
for (const subset of EDS) {
if (ret.length < subset.length) {
ret = subset;
}
}
return ret;
}
}


Ставь 👍 и забирай 📚 Базу знаний
Post #2134 529
Задача: 1058. Minimize Rounding Error to Meet Target
Сложность: medium

Учитывая массив цен [p1,p2...,pn] и цель, округлите каждую цену pi до Roundi(pi) так, чтобы округленный массив [Round1(p1),Round2(p2)...,Roundn(pn)] в сумме достиг заданной цели. Каждая операция Roundi(pi) может быть либо Floor(pi), либо Ceil(pi). Верните строку "-1", если округленный массив невозможно привести к целевому значению. В противном случае возвращается наименьшая ошибка округления, которая определяется как Σ |Roundi(pi) - (pi)| для i от 1 до n, в виде строки с тремя местами после десятичной дроби.

Пример:
Input: prices = ["0.700","2.800","4.900"], target = 8
Output: "1.000"


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

1⃣Округли каждую цену вниз и вычисли текущую сумму округленных цен.
Найди разницу между целевой суммой и текущей суммой.

2⃣Определи количество округлений вверх, необходимых для достижения целевой суммы.
Если разница отрицательная или больше количества элементов в массиве, верни "-1".

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

😎 Решение:
function minimizeRoundingError(prices, target) {
let floors = prices.map(p => Math.floor(parseFloat(p)));
let totalFloor = floors.reduce((a, b) => a + b, 0);

let difference = target - totalFloor;
if (difference < 0 || difference > prices.length) {
return "-1";
}

let roundingErrors = prices.map((p, i) => [Math.ceil(parseFloat(p)) - floors[i], parseFloat(p) - floors[i]]);
roundingErrors.sort((a, b) => a[1] - b[1]);

let roundingErrorSum = floors.reduce((sum, floor, i) => sum + (floor - parseFloat(prices[i])), 0);

for (let i = 0; i < difference; i++) {
roundingErrorSum += roundingErrors[i][1];
}

return roundingErrorSum.toFixed(3);
}


Ставь 👍 и забирай 📚 Базу знаний
Post #2133 509
Задача: 498. Diagonal Traverse
Сложность: medium

Дан массив m x n матрицы mat, верните массив всех элементов матрицы в диагональном порядке.

Пример:
Input: mat = [[1,2,3],[4,5,6],[7,8,9]]
Output: [1,2,4,7,5,3,6,8,9]


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

1⃣Инициализация и подготовка
Проверьте, пуста ли матрица. Инициализируйте переменные для хранения размеров матрицы. Создайте массив result для хранения окончательных результатов и временный список intermediate для промежуточных значений диагоналей.

2⃣Итерация по диагоналям
Внешний цикл для прохождения по всем диагоналям. Головы диагоналей находятся в первой строке и последнем столбце. Внутренний цикл для итерации по элементам каждой диагонали. Индексы элементов диагонали изменяются до выхода за пределы матрицы.

3⃣Обработка диагоналей
Для каждой диагонали сохраните её элементы в списке intermediate. Переверните элементы диагонали, если её номер чётный. Добавьте элементы диагонали в массив result.

😎 Решение:
class Solution {
findDiagonalOrder(mat) {
if (!mat.length || !mat[0].length) return [];
const N = mat.length, M = mat[0].length;
const result = [];

for (let d = 0; d < N + M - 1; ++d) {
const intermediate = [];
let r = d < M ? 0 : d - M + 1;
let c = d < M ? d : M - 1;

while (r < N && c >= 0) {
intermediate.push(mat[r][c]);
r++;
c--;
}

if (d % 2 === 0) {
intermediate.reverse();
}
result.push(...intermediate);
}

return result;
}
}


Ставь 👍 и забирай 📚 Базу знаний
Post #2132 537
Задача: 1102. Path With Maximum Minimum Value
Сложность: medium

Дана целочисленная матрица grid размером m x n. Верните максимальное значение пути, начинающегося в (0, 0) и заканчивающегося в (m - 1, n - 1), двигаясь в 4 кардинальных направлениях.

Значение пути определяется минимальным числом на этом пути.

Пример:
Input: grid = [[5,4,5],[1,2,6],[7,4,6]]
Output: 4
Explanation: The path with the maximum score is highlighted in yellow.


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

1⃣Начните с оценки curScore = min(grid[0][0], grid[m-1][n-1]), где m и n - общее количество строк и столбцов входной матрицы.

2⃣Выполните BFS на матрице и проверьте, существует ли путь, где все значения больше или равны curScore:
Используйте очередь (deque) для хранения всех непосещенных ячеек со значением, большим или равным curScore.
Извлекайте ячейку из начала очереди, проверяйте, есть ли у нее непосещенные соседние ячейки, и добавляйте их в конец очереди.
Если успешно достигли правой нижней ячейки, значит путь существует.
Если очередь опустела до достижения правой нижней ячейки, пути не существует.

3⃣Если пути не существует, что означает, что curScore слишком велик, уменьшите его на 1 и повторите шаг 2.
В противном случае, верните curScore как ответ.

😎 Решение:
var maximumMinimumPath = function(grid) {
const R = grid.length, C = grid[0].length
let curScore = Math.min(grid[0][0], grid[R - 1][C - 1])

while (curScore >= 0) {
if (pathExists(grid, curScore)) {
return curScore
}
curScore--
}
return -1
}

var pathExists = function(grid, curScore) {
const R = grid.length, C = grid[0].length
const visited = Array.from({ length: R }, () => Array(C).fill(false))
const dq = [[0, 0]]
visited[0][0] = true

const push = (row, col) => {
if (row >= 0 && col >= 0 && row < R && col < C && !visited[row][col] && grid[row][col] >= curScore) {
dq.push([row, col])
visited[row][col] = true
}
}

while (dq.length > 0) {
const [curRow, curCol] = dq.shift()
if (curRow == R - 1 && curCol == C - 1) {
return true
}
push(curRow + 1, curCol)
push(curRow - 1, curCol)
push(curRow, curCol + 1)
push(curRow, curCol - 1)
}
return false
}


Ставь 👍 и забирай 📚 Базу знаний
  • 💊 1
Post #2131 507
Задача: 838. Push Dominoes
Сложность: medium

Есть n домино, выстроенные в линию, и каждое домино стоит вертикально. Вначале мы одновременно толкаем некоторые домино либо влево, либо вправо.
Через каждую секунду каждое падающее влево домино толкает соседнее домино слева. Точно так же домино, падающие вправо, толкают соседние домино, стоящие справа.
Когда вертикальное домино оказывается под воздействием падающих домино с обеих сторон, оно остаётся неподвижным из-за баланса сил.

В рамках этой задачи мы будем считать, что падающее домино не передаёт дополнительную силу падающему или уже упавшему домино.
Вам дано строковое представление начального состояния домино:
dominoes[i] = 'L', если i-е домино толкнули влево,
dominoes[i] = 'R', если i-е домино толкнули вправо, и
dominoes[i] = '.', если i-е домино не было толкнуто.
Верните строку, представляющую конечное состояние.

Пример:
Input: dominoes = ".L.R...LR..L.."
Output: "LL.RR.LLRRLL.."


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

1⃣Пройдите по строке и сохраните индексы и символы не пустых домино в массивы.

2⃣Добавьте фиктивные домино 'L' в начале и 'R' в конце для упрощения логики.

3⃣Обработайте промежутки между соседними домино, обновляя их состояния согласно правилам.

😎 Решение:
var pushDominoes = function(dominoes) {
const N = dominoes.length;
const indexes = [-1];
const symbols = ['L'];

for (let i = 0; i < N; ++i) {
if (dominoes[i] !== '.') {
indexes.push(i);
symbols.push(dominoes[i]);
}
}

indexes.push(N);
symbols.push('R');

const ans = dominoes.split('');
for (let idx = 0; idx < indexes.length - 1; ++idx) {
const i = indexes[idx], j = indexes[idx + 1];
const x = symbols[idx], y = symbols[idx + 1];
if (x === y) {
for (let k = i + 1; k < j; ++k) {
ans[k] = x;
}
} else if (x === 'R' && y === 'L') {
for (let k = i + 1; k < j; ++k) {
if (k - i === j - k) {
ans[k] = '.';
} else if (k - i < j - k) {
ans[k] = 'R';
} else {
ans[k] = 'L';
}
}
}
}

return ans.join('');
};


Ставь 👍 и забирай 📚 Базу знаний
Post #2130 496
Задача: 157. Read N Characters Given Read4
Сложность: easy

Предположим, что у вас есть файл, и вы можете читать файл только с помощью данного метода read4. Реализуйте метод для чтения n символов.
Метод read4:
API read4 читает четыре последовательных символа из файла, затем записывает эти символы в массив буфера buf4.
Возвращаемое значение — количество фактически прочитанных символов.
Обратите внимание, что у read4 есть собственный указатель файла, аналогично FILE *fp в C.
Определение read4:
Параметр: char[] buf4
Возвращает: int
buf4[] — это назначение, а не источник. Результаты из read4 будут скопированы в buf4[].
Метод read:
Используя метод read4, реализуйте метод read, который читает n символов из файла и сохраняет их в массиве буфера buf. Учтите, что вы не можете напрямую манипулировать файлом.
Возвращаемое значение — количество фактически прочитанных символов.

Пример:
Input: file = "abc", n = 4
Output: 3
Explanation: After calling your read method, buf should contain "abc". We read a total of 3 characters from the file, so return 3.
Note that "abc" is the file's content, not buf. buf is the destination buffer that you will have to write the results to.


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

1️⃣Инициализация и подготовка:
Инициализируйте переменные: copiedChars = 0 для подсчета скопированных символов и readChars = 4 для подсчета прочитанных символов из файла. Начальное значение readChars установлено в 4, что позволяет использовать условие readChars != 4 в качестве маркера конца файла (EOF).
Создайте внутренний буфер из 4 символов: buf4.

2️⃣Чтение и копирование символов:
Пока количество скопированных символов меньше N (copiedChars < n) и еще есть символы в файле (readChars == 4):
Прочитайте символы из файла во внутренний буфер buf4 с помощью метода read4(buf4).
Копируйте символы из внутреннего буфера buf4 в основной буфер buf по одному. Увеличивайте copiedChars после каждого скопированного символа.

3️⃣Завершение процесса:
Если количество скопированных символов достигло N (copiedChars == n), прервите процесс копирования.
Верните copiedChars как результат функции, указывающий на количество успешно скопированных символов в основной буфер buf.

😎 Решение:
class Reader4 {
read4(buf4) {
return 0;
}
}

class Solution extends Reader4 {
read(buf, n) {
let copiedChars = 0, readChars = 4;
let buf4 = new Array(4).fill('\0');

while (copiedChars < n && readChars === 4) {
readChars = this.read4(buf4);

for (let i = 0; i < readChars; ++i) {
if (copiedChars === n) return copiedChars;
buf[copiedChars] = buf4[i];
++copiedChars;
}
}
return copiedChars;
}
}


Ставь 👍 и забирай 📚 Базу знаний
Post #2129 579
Задача: 1295. Find Numbers with Even Number of Digits
Сложность: easy

Дан массив чисел nums. Верните количество чисел в массиве, которые содержат четное количество цифр.

Пример:
Input: nums = [12,345,2,6,7896]
Output: 2
Explanation:
12 contains 2 digits (even number of digits).
345 contains 3 digits (odd number of digits).
2 contains 1 digit (odd number of digits).
6 contains 1 digit (odd number of digits).
7896 contains 4 digits (even number of digits).
Therefore only 12 and 7896 contain an even number of digits.


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

1⃣Определите вспомогательную функцию hasEvenDigits, которая принимает num в качестве входных данных и возвращает true, если количество цифр четное, иначе возвращает false.

2⃣Внутри функции hasEvenDigits. Инициализируйте переменную digitCount значением 0. Пока num не равно нулю: Увеличивайте digitCount на 1. Делите num на 10. Возвращайте digitCount & 1 == 0.

3⃣В функции findNumbers. Инициализируйте переменную evenDigitCount значением 0. Для каждого числа num в массиве nums, проверяйте, возвращает ли hasEvenDigits(num) значение true. Если да, увеличивайте evenDigitCount на 1. Возвращайте evenDigitCount.

😎 Решение:
class Solution {
hasEvenDigits(num) {
let digitCount = 0
while (num > 0) {
digitCount++
num = Math.floor(num / 10)
}
return (digitCount & 1) === 0
}

findNumbers(nums) {
let evenDigitCount = 0
for (let num of nums) {
if (this.hasEvenDigits(num)) {
evenDigitCount++
}
}
return evenDigitCount
}
}


Ставь 👍 и забирай 📚 Базу знаний
Post #2128 601
Задача: 1480. Running Sum of 1d Array
Сложность: easy

Дан массив nums. Мы определяем текущую сумму массива как runningSum[i] = сумма(nums[0]…nums[i]).

Верните массив текущих сумм для nums.

Пример:
Input: nums = [1,2,3,4]
Output: [1,3,6,10]
Explanation: Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].


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

1⃣Инициализация:
Определите массив result.
Инициализируйте первый элемент массива result первым элементом входного массива nums.

2⃣Вычисление текущих сумм:
На индексе i добавьте сумму элемента nums[i] и предыдущей текущей суммы result[i - 1] в массив result.

3⃣Повторение для всех индексов:
Повторите шаг 2 для всех индексов от 1 до n-1.

😎 Решение:
var runningSum = function(nums) {
let result = Array(nums.length).fill(0);
result[0] = nums[0];
for (let i = 1; i < nums.length; i++) {
result[i] = result[i - 1] + nums[i];
}
return result;
};


Ставь 👍 и забирай 📚 Базу знаний
Post #2127 658
Задача: 718. Maximum Length of Repeated Subarray
Сложность: medium

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

Пример:
Input: nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
Output: 3


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

1⃣Создайте двумерный массив для хранения длин общих подмассивов.

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

3⃣Итеративно обновляйте массив, сравнивая элементы обоих массивов и обновляя максимальную длину подмассива.

😎 Решение:
var findLength = function(nums1, nums2) {
let dp = Array(nums1.length + 1).fill(0).map(() => Array(nums2.length + 1).fill(0));
let maxLength = 0;
for (let i = nums1.length - 1; i >= 0; i--) {
for (let j = nums2.length - 1; j >= 0; j--) {
if (nums1[i] === nums2[j]) {
dp[i][j] = dp[i + 1][j + 1] + 1;
maxLength = Math.max(maxLength, dp[i][j]);
}
}
}
return maxLength;
};


Ставь 👍 и забирай 📚 Базу знаний
Post #2125 610
Задача: 1003. Check If Word Is Valid After Substitutions
Сложность: medium

Дана строка s, определите, является ли она допустимой. Строка s допустима, если, начиная с пустой строки t = "", вы можете преобразовать t в s, выполнив следующую операцию любое количество раз: вставить строку "abc" в любую позицию в t. Более формально, t становится tleft + "abc" + tright, где t == tleft + tright. Обратите внимание, что tleft и tright могут быть пустыми. Верните true, если s - допустимая строка, иначе верните false.

Пример:
Input: s = "aabcbc"
Output: true


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

1⃣Проверка допустимости длины строки:
Проверьте, что длина строки s кратна 3. Если нет, верните false.

2⃣Использование стека для проверки:
Инициализируйте пустой стек. Проходите по каждому символу строки s.
Если текущий символ является 'c', проверьте, что два предыдущих символа в стеке - это 'b' и 'a' соответственно. Если это так, удалите 'b' и 'a' из стека. Если нет, верните false.
Если текущий символ не 'c', добавьте его в стек.

3⃣Проверка остатка стека:
В конце, если стек пуст, верните true. Иначе верните false.

😎 Решение:
class Solution {
isValid(s) {
if (s.length % 3 !== 0) return false;

const stack = [];
for (const char of s) {
if (char === 'c') {
if (stack.length < 2 || stack.pop() !== 'b' || stack.pop() !== 'a') {
return false;
}
} else {
stack.push(char);
}
}

return stack.length === 0;
}
}


Ставь 👍 и забирай 📚 Базу знаний
Post #2124 564
Задача: 128. Longest Consecutive Sequence
Сложность: medium

Дан несортированный массив целых чисел nums. Верните длину самой длинной последовательности последовательных элементов.
Необходимо написать алгоритм, который работает за время O(n).

Пример:
Input: nums = [100,4,200,1,3,2]
Output: 4
Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.


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

1️⃣Проверка базового случая:
Перед началом работы проверяем базовый случай с пустым массивом.
Самая длинная последовательность в пустом массиве, очевидно, равна 0, поэтому мы можем просто вернуть это значение.

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

3️⃣Завершение обработки и возврат результата:
В противном случае последовательность прерывается, и мы записываем нашу текущую последовательность и сбрасываем её до 1 (чтобы включить число, которое прервало последовательность).
Возможно, что последний элемент массива nums является частью самой длинной последовательности, поэтому мы возвращаем максимум из текущей последовательности и самой длинной.

😎 Решение:
var longestConsecutive = function (nums) {
let longestStreak = 0;
for (let num of nums) {
let currentNum = num;
let currentStreak = 1;
while (nums.includes(currentNum + 1)) {
currentNum += 1;
currentStreak += 1;
}
longestStreak = Math.max(longestStreak, currentStreak);
}
return longestStreak;
};


Ставь 👍 и забирай 📚 Базу знаний
Post #2123 627
Задача: 744. Find Smallest Letter Greater Than Target
Сложность: easy

Нам дан массив символов letters, отсортированный в неубывающем порядке, и символ target. В массиве letters есть как минимум два разных символа. Возвращается наименьший символ в letters, который лексикографически больше target. Если такого символа не существует, возвращается первый символ в буквах.

Пример:
Input: letters = ["c","f","j"], target = "a"
Output: "c"


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

1⃣Использовать бинарный поиск для нахождения позиции первого символа в letters, который лексикографически больше target.

2⃣Если найденный символ существует, вернуть его.

3⃣Если такого символа не существует, вернуть первый символ в letters.

😎 Решение:
var nextGreatestLetter = function(letters, target) {
let left = 0;
let right = letters.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (letters[mid] > target) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return letters[left % letters.length];
};


Ставь 👍 и забирай 📚 Базу знаний
Post #2122 596
Задача: 484. Find Permutation
Сложность: medium

Перестановка perm из n целых чисел всех чисел в диапазоне [1, n] может быть представлена в виде строки s длиной n - 1, где:
s[i] == 'I', если perm[i] < perm[i + 1], и
s[i] == 'D', если perm[i] > perm[i + 1].
Дана строка s, восстановите лексикографически наименьшую перестановку perm и верните её.

Пример:
Input: s = "I"
Output: [1,2]
Explanation: [1,2] is the only legal permutation that can represented by s, where the number 1 and 2 construct an increasing relationship.


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

1⃣Инициализация
Создайте пустой стек stack. Создайте пустой список result для хранения конечной перестановки.

2⃣Для каждого числа i
Если текущий символ в строке s равен 'D', добавьте i в стек. Если текущий символ в строке s равен 'I', добавьте i в стек, затем извлеките все элементы из стека и добавьте их в result.

3⃣Завершение
Добавьте n в стек и извлеките все элементы из стека, добавив их в result. Верните список result, который представляет лексикографически наименьшую перестановку.

😎 Решение:
var findPermutation = function(s) {
let res = new Array(s.length + 1).fill(0)
let stack = []
let j = 0
for (let i = 1; i <= s.length; i++) {
if (s[i - 1] === 'I') {
stack.push(i)
while (stack.length) {
res[j++] = stack.pop()
}
} else {
stack.push(i)
}
}
stack.push(s.length + 1)
while (stack.length) {
res[j++] = stack.pop()
}
return res
}


Ставь 👍 и забирай 📚 Базу знаний
Post #2121 625
Задача: 757. Set Intersection Size At Least Two
Сложность: hard

Вам дан двумерный целочисленный массив intervals, в котором intervals[i] = [starti, endi] представляет все целые числа от starti до endi включительно. Содержащее множество - это массив nums, в котором каждый интервал из intervals содержит не менее двух целых чисел в nums. Например, если intervals = [[1,3], [3,7], [8,9]], то [1,2,4,7,8,9] и [2,3,4,8,9] - содержащие множества. Верните минимально возможный размер содержащего множества.

Пример:
Input: intervals = [[1,3],[3,7],[8,9]]
Output: 5


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

1⃣Отсортируйте интервалы по их конечным точкам.

2⃣Инициализируйте пустое множество для хранения чисел.

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

😎 Решение:
function minSetSize(intervals) {
intervals.sort((a, b) => a[1] - b[1]);
let nums = [];
for (let [start, end] of intervals) {
if (nums.length === 0 || nums[nums.length - 1] < start) {
nums.push(end - 1);
nums.push(end);
} else if (nums[nums.length - 1] === end - 1) {
nums.push(end);
}
}
return nums.length;
}


Ставь 👍 и забирай 📚 Базу знаний
Post #2120 593
Задача: 1197. Minimum Knight Moves
Сложность: medium

На бесконечной шахматной доске с координатами от -бесконечности до +бесконечности у вас есть конь на клетке [0, 0].
У коня есть 8 возможных ходов. Каждый ход представляет собой два квадрата в кардинальном направлении, затем один квадрат в ортогональном направлении.

Верните минимальное количество шагов, необходимых для перемещения коня на клетку [x, y]. Гарантируется, что ответ существует.

Пример:
Input: x = 5, y = 5
Output: 4
Explanation: [0, 0] → [2, 1] → [4, 2] → [3, 4] → [5, 5]


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

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

2⃣Реализация двунаправленного поиска в ширину (BFS):
Выполняйте шаги из очередей, расширяя круги поиска как от начальной, так и от конечной точки.
Если круги пересекаются, возвращайте сумму расстояний до точки пересечения.

3⃣Расширение кругов поиска:
Для каждой текущей точки из очередей расширяйте круг поиска по всем возможным ходам коня.
Обновляйте расстояния и добавляйте новые точки в очереди, если они еще не были посещены.
Увеличивайте units на значение, извлеченное из кучи.

😎 Решение:
class Solution {
minKnightMoves(x, y) {
const offsets = [
[1, 2], [2, 1], [2, -1], [1, -2],
[-1, -2], [-2, -1], [-2, 1], [-1, 2]
];

const originQueue = [[0, 0, 0]];
const originDistance = { '0,0': 0 };

const targetQueue = [[x, y, 0]];
const targetDistance = { [`${x},${y}`]: 0 };

while (true) {
const [ox, oy, od] = originQueue.shift();
const originKey = `${ox},${oy}`;
if (originKey in targetDistance) {
return od + targetDistance[originKey];
}

const [tx, ty, td] = targetQueue.shift();
const targetKey = `${tx},${ty}`;
if (targetKey in originDistance) {
return td + originDistance[targetKey];
}

for (const [dx, dy] of offsets) {
const nextOrigin = [ox + dx, oy + dy, od + 1];
const nextOriginKey = `${nextOrigin[0]},${nextOrigin[1]}`;
if (!(nextOriginKey in originDistance)) {
originQueue.push(nextOrigin);
originDistance[nextOriginKey] = nextOrigin[2];
}

const nextTarget = [tx + dx, ty + dy, td + 1];
const nextTargetKey = `${nextTarget[0]},${nextTarget[1]}`;
if (!(nextTargetKey in targetDistance)) {
targetQueue.push(nextTarget);
targetDistance[nextTargetKey] = nextTarget[2];
}
}
}
}
}


Ставь 👍 и забирай 📚 Базу знаний
  • 👍 1
Post #2119 614
Задача: 644. Maximum Average Subarray II
Сложность: hard

Вам дан целочисленный массив nums, состоящий из n элементов, и целое число k. Найдите смежный подмассив, длина которого больше или равна k и который имеет максимальное среднее значение, и верните это значение. Принимается любой ответ с погрешностью вычислений менее 10-5.

Пример:
Input: nums = [1,12,-5,-6,50,3], k = 4
Output: 12.75000


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

1⃣Используйте скользящее окно длины k для нахождения начального среднего значения.

2⃣Перемещайте окно по массиву, добавляя следующий элемент и убирая предыдущий, обновляя текущее среднее значение.

3⃣Следите за максимальным средним значением и верните его после проверки всех возможных окон.

😎 Решение:
var findMaxAverage = function(nums, k) {
let currSum = nums.slice(0, k).reduce((a, b) => a + b, 0);
let maxSum = currSum;
for (let i = k; i < nums.length; i++) {
currSum += nums[i] - nums[i - k];
if (currSum > maxSum) {
maxSum = currSum;
}
}
return maxSum / k;
};


Ставь 👍 и забирай 📚 Базу знаний
Post #2118 632
Задача: 925. Long Pressed Name
Сложность: easy

Ваш друг набирает на клавиатуре свое имя. Иногда, при наборе символа c, клавиша может быть долго нажата, и символ будет набран 1 или более раз. Вы исследуете набранные символы клавиатуры. Верните True, если возможно, что это было имя вашего друга, при этом некоторые символы (возможно, ни один) не были долго нажаты.

Пример:
Input: name = "alex", typed = "aaleex"
Output: true


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

1⃣Инициализировать два указателя i и j для строки имени и набранной строки соответственно.

2⃣Пройти по набранной строке:
Если символы имени и набранной строки совпадают, сдвинуть оба указателя.
Если символы не совпадают, проверить, является ли текущий символ набранной строки повторением предыдущего символа. Если да, сдвинуть указатель набранной строки.
Если символ не совпадает и не является повторением предыдущего символа, вернуть False.
После завершения цикла проверить, что все символы имени были обработаны.

3⃣Вернуть True, если все символы имени были обработаны, иначе False.

😎 Решение:
var isLongPressedName = function(name, typed) {
let i = 0, j = 0;
while (j < typed.length) {
if (i < name.length && name[i] === typed[j]) {
i++;
} else if (j === 0 || typed[j] !== typed[j - 1]) {
return false;
}
j++;
}
return i === name.length;
};


Ставь 👍 и забирай 📚 Базу знаний
  • 👍 1
Post #2117 608
Задача: 1039. Minimum Score Triangulation of Polygon
Сложность: medium

У вас есть выпуклый n-сторонний многоугольник, каждая вершина которого имеет целочисленное значение. Вам дан целочисленный массив values, где values[i] - это значение i-й вершины (т.е. по часовой стрелке). Вы должны триангулировать многоугольник на n - 2 треугольника. Для каждого треугольника значение этого треугольника равно произведению значений его вершин, а общий балл триангуляции равен сумме этих значений для всех n - 2 треугольников в триангуляции. Верните наименьший возможный общий балл, который вы можете получить с помощью некоторой триангуляции многоугольника.

Пример:
Input: values = [1,2,3]
Output: 6


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

1⃣Инициализация:
Создаем двумерный массив dp, где dp[i][j] будет хранить минимальный возможный общий балл триангуляции многоугольника, состоящего из вершин от i до j.

2⃣Основное заполнение dp:
Проходим по всем возможным длинам подмногоугольников, начиная с треугольников (длина 3) до всего многоугольника (длина n).
Для каждого подмногоугольника находим минимальный возможный общий балл, проверяя все возможные треугольники, которые могут быть образованы из этого подмногоугольника.
Заполнение dp для каждого подмногоугольника:
Для каждого подмногоугольника от i до j, и для каждой возможной вершины k между i и j, обновляем значение dp[i][j], как сумму минимальных значений триангуляций левой и правой частей подмногоугольника, а также значения текущего треугольника, образованного вершинами i, k и j.

3⃣Возврат результата:
Ответ будет в dp[0][n-1], который хранит минимальный возможный общий балл триангуляции для всего многоугольника.

😎 Решение:
var minScoreTriangulation = function(values) {
const n = values.length;
const dp = Array.from({ length: n }, () => Array(n).fill(0));

for (let length = 2; length < n; length++) {
for (let i = 0; i < n - length; i++) {
const j = i + length;
dp[i][j] = Infinity;
for (let k = i + 1; k < j; k++) {
dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k][j] + values[i] * values[j] * values[k]);
}
}
}

return dp[0][n - 1];
};


Ставь 👍 и забирай 📚 Базу знаний
Post #2116 632
Задача: 259. 3Sum Smaller
Сложность: medium

Дан массив из n целых чисел nums и целое число target. Найдите количество троек индексов i, j, k, удовлетворяющих условию 0 <= i < j < k < n и nums[i] + nums[j] + nums[k] < target.

Пример:
Input: nums = [-2,0,1,3], target = 2
Output: 2
Explanation: Because there are two triplets which sums are less than 2:
[-2,0,1]
[-2,0,3]


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

1️⃣Отсортируйте массив nums.

2️⃣Для каждого элемента nums[i] от 0 до n-3 найдите количество пар индексов j и k (где i < j < k), таких что nums[i] + nums[j] + nums[k] < target. Используйте функцию twoSumSmaller, которая ищет количество пар с суммой меньше заданного значения.

3️⃣В функции twoSumSmaller используйте бинарный поиск для поиска верхней границы индекса k и подсчета количества подходящих пар.

😎 Решение:
class Solution {
threeSumSmaller(nums, target) {
nums.sort((a, b) => a - b)
let sum = 0
for (let i = 0; i < nums.length - 2; i++) {
sum += this.twoSumSmaller(nums, i + 1, target - nums[i])
}
return sum
}

twoSumSmaller(nums, startIndex, target) {
let sum = 0
for (let i = startIndex;


Ставь 👍 и забирай 📚 Базу знаний
  • 🤔 1
Post #2115 626
Задача: 215. Kth Largest Element in an Array
Сложность: medium

Дан целочисленный массив nums и целое число k. Верните k-й наибольший элемент в массиве.
Обратите внимание, что это k-й наибольший элемент в отсортированном порядке, а не k-й уникальный элемент.

Пример:
Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
Output: 4


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

1️⃣ Отсортируйте массив в порядке убывания:
Используйте стандартную функцию сортировки для сортировки элементов массива nums в порядке убывания. В этом случае самый большой элемент будет первым в массиве, второй по величине - вторым и так далее.

2️⃣ Найдите k-й по величине элемент:
После сортировки просто верните элемент, который стоит на позиции k-1 (учитывая, что индексация в массиве начинается с 0).

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

😎 Решение:
class Solution {
shortestPalindrome(s) {
const n = s.length;
const rev = s.split('').reverse().join('');
for (let i = 0; i < n; i++) {
if (s.substring(0, n - i) === rev.substring(i)) {
return rev.substring(0, i) + s;
}
}
return "";
}
}


Ставь 👍 и забирай 📚 Базу знаний
  • 👍 1
  • 🤔 1
Older posts →
Threads Profile ViewerView any public Threads profile without an account.Open ThreadLook →Writing with AI? Make it sound human.Metric37 rewrites AI drafts so they read naturally. Free AI detector, 1,500 words free.Try Metric37 →