Генерируйте сумму хеша для нескольких целых чисел
OK. Вот как я бы подошел к этому (в соответствии с моим комментарием). Вкратце, используйте массив объектов для описания ваших карусельных панелей, а затем map над ним, создавая новую панель с каждой итерацией. К каждой панели прикреплены атрибуты данных, которые описывают текущий индекс панели и длину массива. Затем их можно использовать в обработчике кликов как часть расчета.
class Carousel extends React.Component {
constructor() {
super();
// Make sure you bind your handler
this.handleClick = this.handleClick.bind(this);
}
handleClick(e) {
// Destruct the id and length from the target dataset
const { dataset: { id, length } } = e.target;
// Here you would perform your calculation
console.log(id, length);
}
render() {
// Get the panel data we passed in
const { panels } = this.props;
// Grab the length of the panel array
const { length } = panels;
// `map` over the panels array to create a new panel with each
// iteration. Note we also use `map`'s index parameter
return panels.map((panel, index) => {
// Add the index, length as element data attributes
return (
{panel.desc} ({index} of {panels.length})
);
});
}
}
// Panel data
const panels = [{ desc: 'Panel 1' }, { desc: 'Panel 2' }, { desc: 'Panel 3' }];
ReactDOM.render(
// Pass in the panel data as props
.carouselItem {
display: inline-block;
margin-right: 1em;
padding: 0.3em;
border: 1px solid #dfdfdf;
}
.carouselItem:hover {
cursor: pointer;
}
8 ответов
Учитывая исходные данные a, b, c, и d, каждый располагающийся в значении от 0 до 30 (5 битов), следующее произведет число в диапазоне от 0 до 255 (8 битов).
bucket = ((a & 0x18) << 3) | ((b & 0x18) << 1) | ((c & 0x18) >> 1) | ((d & 0x18) >> 3)
Является ли общий подход соответствующим, зависит от того, как вопрос интерпретируется. 3 младших значащих бита отбрасываются, группируясь 0-7 в том же наборе, 8-15 в следующем, и т.д.
0-7,0-7,0-7,0-7 -> bucket 0
0-7,0-7,0-7,8-15 -> bucket 1
0-7,0-7,0-7,16-23 -> bucket 2
...
24-30,24-30,24-30,24-30 -> bucket 255
Тривиально протестированный с:
for (int a = 0; a <= 30; a++)
for (int b = 0; b <= 30; b++)
for (int c = 0; c <= 30; c++)
for (int d = 0; d <= 30; d++) {
int bucket = ((a & 0x18) << 3) |
((b & 0x18) << 1) |
((c & 0x18) >> 1) |
((d & 0x18) >> 3);
printf("%d, %d, %d, %d -> %d\n",
a, b, c, d, bucket);
}
Необходимо было бы определить то, под чем Вы подразумеваете "подобный". Хеши обычно разрабатываются для создания уникальных результатов уникального входа.
Один подход должен был бы нормализовать Ваш вход и затем генерировать хеш от результатов.
Вы могли бы хотеть попытаться использовать векторы для описания каждого набора числа как значение хэш-функции.
Править: Так как Вы не описываете, почему Вы хотите не выполнить саму функцию, я предполагаю, что это длительно. Так как Вы не описали ширину набора аргумента.
Если каждое значение ожидается затем, полная справочная таблица в базе данных могла бы быть быстрее.
Если Вы ожидаете повторенные вызовы с теми же аргументами и небольшим полным изменением, то Вы могли посмотреть на memoizing поэтому, только первый показ для набора аргумента является дорогим, и каждый дополнительный запрос быстр с меньшим количеством использования памяти.
Простое решение:
Преобразуйте целые числа в строки, разделенные запятыми, и хешируйте получившую строку с помощью общего алгоритма хеширования (md5, sha, и т.д.).
Если бы Вы действительно хотите к самокрутке, я сделал бы что-то как:
- Генерируйте большой главный P
- Генерируйте случайные числа 0 <[я] <P (для каждого размера, который Вы имеете),
Для генерации хеша вычислите: сумма ([я] * x [я]) модификация P
Вы хотите хеш-функцию, которая зависит от порядка исходных данных и где подобные наборы чисел генерируют тот же хеш? Таким образом, Вы хотите 50 5 5 10 и 5 5 10 50 генерировать различные значения, но Вы хотите 52 7 4 12 генерировать тот же хеш как 50 5 5 10? Простой способ сделать что-то вроде этого:
long hash = 13;
for (int i = 0; i < array.length; i++) {
hash = hash * 37 + array[i] / 5;
}
Это несовершенно, но должно дать Вам общее представление об одном способе реализовать то, что Вы хотите. Это будет рассматривать значения 50 - 54 как то же значение, но это будет рассматривать 49 и 50 как различные значения.
Если Вы хотите, чтобы хеш был независим от порядка исходных данных (таким образом, хеш 5 10 20 и 20 10 5 является тем же), затем один способ сделать, это должно отсортировать массив целых чисел в порядок по возрастанию прежде, чем применить хеш. Иначе должен был бы заменить
hash = hash * 37 + array[i] / 5;
с
hash += array[i] / 5;
Править: Принимая во внимание Ваши комментарии в ответ на этот ответ, это кажется, что моя попытка выше может удовлетворить Ваши потребности достаточно хорошо. Это не будет идеально, ни прекрасно. При необходимости в высокой производительности, у Вас есть некоторое исследование и экспериментирование, чтобы сделать.
Подводя итоги, порядок важен, таким образом, 5 10 20 отличается от 20 10 5. Кроме того, Вы идеально сохранили бы каждый "вектор" отдельно в Вашей хеш-таблице, но обработать пространственные ограничения Вы хотите сохранить некоторые группы значений в одной записи в таблице.
Идеальная хеш-функция возвратила бы число, равномерно распространенное через возможные значения на основе Вашего размера таблицы. Делать правильно это зависит от ожидаемого размера Вашей таблицы и на количестве и ожидаемом максимальном значении значений входного вектора. Если у Вас могут быть отрицательные величины, поскольку "координата" оценивает затем, это может влиять, как Вы вычисляете свой хеш. Если, учитывая Ваш диапазон входных значений и выбранной хеш-функции, Ваше максимальное значение хэш-функции является меньше, чем Ваш размер хеш-таблицы, то необходимо изменить хеш-функцию для генерации большего значения хэш-функции.
Генерацию той же суммы хеша называют коллизией и является плохой вещью для хеша, чтобы иметь. Это делает это менее полезным.
Если Вы хотите, чтобы подобные значения дали тот же вывод, можно разделить вход на однако близко, Вы хотите, чтобы они рассчитали. Если порядок имеет значение, используйте другой делитель для каждого числа. Следующая функция делает то, что Вы описываете:
int SqueezedSum( int a, int b, int c, int d )
{
return (a/11) + (b/7) + (c/5) + (d/3);
}
Это не хеш, но делает то, что Вы описываете.
Другой способ просмотреть мою проблему использует масштабирование multidimesional (MS). В MS мы запускаем с матрицы объектов и что мы хотим, присваивают местоположение каждого объекта к размерному пространству N. Сокращение таким образом количества размеров.
Вы хотите изучить геометрическое хеширование. В "стандарте", хеширующем Вас, хотят
- короткий ключ
- обратное сопротивление
- сопротивление коллизии
С геометрическим хешированием Вас susbtitute номер 3 с чем-то whihch почти противоположен; а именно, близкие начальные значения дают близкие значения хэш-функции.