Определение наличия байта, меньше заданного значения, в 32-битном слове

Этот метод проверяет, содержит ли 32-битное слово байт с значением, которое меньше заданного числа n, используя всего 4 операции. Он эффективен и быстро выполняет задачу путем вычитания маскированного значения, инвертирования исходного слова и маскирования старших битов.

Подсчет количества байтов, меньше заданного значения

Макрос countless предназначен для подсчета количества байтов в 32-битном слове, значение которых меньше заданного числа n. Этот макрос выполняет задачу с использованием 7 арифметических и логических операций. Он позволяет эффективно обрабатывать данные, минимизируя количество операций и, следовательно, увеличивая производительность.

Определение наличия байта, больше заданного значения, в 32-битном слове

Для проверки, содержит ли слово x байт со значением, превышающим n, можно использовать макрос hasmore. Он использует всего 3 арифметических/логических операции, если n является константой.

Предполагается, что x ≥ 0 и 0 ≤ n ≤ 127.

Подсчет количества байтов, больше заданного значения

Для подсчета количества байтов в x, значение которых больше n, можно использовать макрос countmore, который использует 6 операций.

Определение, содержит ли слово байт со значением между m и n

Когда m < n, следующая техника позволяет проверить, содержит ли слово x байт со значением, таким образом, что m < значение < n. Эта техника использует 7 арифметических/логических операций, если n и m являются константами.

Однако, иногда может давать ложные срабатывания (false positives), т.е. оно может сообщить, что значение находится в диапазоне, когда это не так.

Точное определение нахождения байта со значением между m и n

Этот макрос использует побитовые и арифметические операции для проверки, содержит ли слово x байт со значением между m и n. hasbetween дает точный результат, но использует больше операций для достижения этого по сравнению с макросом likelyhasbetween.

Подсчет количества байтов между m и n

Макрос countbetween предназначен для подсчета количества байтов в слове x, которые находятся в диапазоне m < значение < n. Он использует макрос hasbetween, чтобы сначала найти все байты, которые удовлетворяют этому условию, а затем подсчитывает их количество.

Вычисление лексикографически следующей битовой перестановки

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

Например, если задано 3 бита и текущее расположение битов:
00010011,
то следующими будут:
00010101,
00010110,
00011001,
00011010,
00011100,
00100011 и так далее.

*Функция __builtin_ctz(v) компилятора GNU C для процессоров x86 возвращает количество замыкающих нулей. Для компиляторов Microsoft для x86 используется intrinsic _BitScanForward. Обе функции генерируют инструкцию bsf, но могут быть доступны эквиваленты для других архитектур. Если их нет, можно использовать один из методов подсчета подряд идущих нулевых битов.

Повторяющееся целое число

Проблема: Дан целочисленный массив array. Необходимо реализовать алгоритм, который возвращает true, если какое-либо значение встречается в массиве более одного раза, в противном случае возвращается false.

Пример 1:
Input: nums = [1, 2, 3, 3]
Output: true

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

Анаграмма

Проблема: Даны две строки s и t. Необходимо реализовать алгоритм, который возвращает true, если эти две строки являются анаграммами друг друга, в противном случае верните false.

Анаграмма — это строка, содержащая те же символы, что и другая строка, но порядок символов может быть другим.

Пример 1:
Input: s = "racecar", t = "carrace"
Output: true

Пример 2:
Input: s = "jar", t = "jam"
Output: false

Два целых числа

Проблема: Дан массив целых чисел nums и целочисленный target. Необходимо реализовать алгоритм, который вернет индексы i и j такие, что nums[i] + nums[j] == target и i != j. Можно предположить, что каждый input имеет ровно одну пару индексов i и j, удовлетворяющих условию. Сначала верните ответ с меньшим индексом.

Пример 1:
Input: nums = [3,4,5,6], target = 7
Output: [0,1]


Пример 2:
Input: nums = [-3,4,3,90], target=0
Output: [0,2]

Группы анаграмм

Проблема: Дан массив строк strs. Необходимо реализовать алгоритм, который сгруппирует все анаграммы в подгруппы. Можно вернуть вывод в любом порядке.

Анаграмма — это строка, содержащая те же символы, что и другая строка, но порядок символов может быть другим.

Пример 1:
Input: strs = ["act","pots","tops","cat","stop","hat"]
Output: [["hat"],["act", "cat"],["stop", "pots", "tops"]]

Пример 2:
Input: strs = ["x"]
Output: [["x"]]

"K" элементов в списке

Проблема: Дан целочисленный массив nums и целое число k. Необходимо реализовать алгоритм, который вернет k наиболее часто встречающихся элементов массива. Можно вернуть вывод в любом порядке.

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

Пример 2:
Input: nums = [7,7], k = 1
Output: [7]

Произведения всех элементов массива, кроме текущего

Проблема: Дан целочисленный массив nums. Необходимо реализовать алгоритм, который вернет массив, где iый элемент является произведением всех элементов nums, кроме nums[i] (каждое произведение гарантированно умещается в 32-битное целое число).

Для решения задачи без использования операции деления и за O(n) времени, можно использовать метод предварительного вычисления произведений. Идея заключается в том, чтобы использовать два прохода по массиву: один для вычисления произведений слева от текущего элемента и другой для вычисления произведений справа от текущего элемента.

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

Допустимая доска Sudoku

Проблема: Дана доска для судоку размером 9 x 9. Доска судоку действительна, если соблюдаются следующие правила:
- Каждая строка должна содержать цифры от 1 до 9 без дубликатов.
- Каждый столбец должен содержать цифры 1–9 без дубликатов.
- Каждый из девяти подполей сетки размером 3х3 должен содержать цифры от 1 до 9 без дубликатов.

Необходимо реализовать алгоритм, который вернет true, если доска судоку действительна, в противном случае вернет false (чтобы считаться допустимой, доска не обязательно должна быть заполненной или разрешимой).

Пример:
Input:

board = [["1","2",".",".","3",".",".",".","."],
["4",".",".","5",".",".",".",".","."],
[".","9","1",".",".",".",".",".","3"],
["5",".",".",".","6",".",".",".","4"],
[".",".",".","8",".","3",".",".","5"],
["7",".",".",".","2",".",".",".","6"],
[".",".",".",".",".",".","2",".","."],
[".",".",".","4","1","9",".",".","8"],
[".",".",".",".","8",".",".","7","9"]]

Output: false

Самая длинная последовательность

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

Самая длинная последовательность — это последовательность элементов, в которой каждый элемент ровно на 1 больше предыдущего элемента.

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

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

Сумма трёх целых чисел

Проблема: Дан целочисленный массив nums. Необходимо реализовать алгоритм, который вернет все тройки [nums[i], nums[j], nums[k]], где nums[i] + nums[j] + nums[k] == 0, и индексы i, j и k различны.

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

Пример 1:
Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]
Объяснение:
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0.
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0.
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0.

Пример 2:
Input: nums = [0,0,0]
Output: [[0,0,0]]

Контейнер для воды

Проблема: Дан целочисленный массив heights, где heights[i] представляет высоту i-ой колонки.

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

function maxArea(heights) {
    left = 0
    right = length(heights) - 1
    max_area = 0

    while left < right {
        height = min(heights[left], heights[right])
        width = right - left
        current_area = height * width
        max_area = max(max_area, current_area)

        if heights[left] < heights[right] { 
            left += 1 
        }
        else { right -= 1 }
    }
    return max_area
}

Улавливание дождевой воды

Проблема: Дан массив высот неотрицательных целых чисел, которые представляют карту высот. Каждое значение heights[i] представляет высоту полосы, ширина которой равна 1.

В результате должно вернуться максимальная площадь воды, которая может задерживаться между решетками.

Покупка и продажа крипты

Проблема: Дан целочисленный массив цен, где prices[i] — цена AlgoCoin на i-й день. Можно выбрать один день для покупки одного AlgoCoin и выбрать другой день в будущем для его продажи.

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

Пример 1:
Input: prices = [10,1,5,6,7,1]
Output: 6
Пояснение: купить за prices[1] и продать по prices[4]. В итоге, прибыль = 7 – 1 = 6.

Пример 2:
Input: prices = [10,8,7,5,2]
Output: 0
Пояснение: Невозможно совершить прибыльные сделки, поэтому максимальная прибыль равна 0.