Алгоритмы и структуры данных
8.51K subscribers
283 photos
8 links
По всем вопросам: @altmainf

Уважаемый менеджер: @altaiface
Download Telegram
Перемешивание битов с использованием "Магических чисел"

Перемешивание битов (или Мортон-числа) — это техника, которая позволяет линейно представлять двумерные координаты в одном числе. Используя магические числа и побитовые операции, можно эффективно перемешивать биты двух 16-битных чисел в одно 32-битное число.
Оптимизированный метод определения наличия нулевого байта в 32-битном слове

Определение наличия нулевого байта в 32-битном слове — важная задача, которая часто встречается при обработке строк и других данных.

Преимущества метода
- Эффективность: Метод использует всего 4 операции, что делает его чрезвычайно быстрым.
- Компактность: Код прост и легко интегрируется в любые программы.
- Надежность: Метод точно определяет наличие нулевого байта, минимизируя количество ложных срабатываний.
Определение наличия нулевого байта в 32-битном слове

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

Иногда возникает необходимость проверить, содержит ли любое 8-битное значение в 32-битном слове определенное значение. Для этого можно использовать операцию XOR, чтобы проверить совпадение каждого байта с искомым значением, и затем определить, содержит ли результат нулевой байт.
Определение наличия байта, меньше заданного значения, в 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