Отображение двух целых в одно уникальным и детерминированным способом

Представьте два положительных целых числа A и B. Я хочу объединить эти два в одно целое число C.

Не может быть других целых чисел D и E, которые объединяются в C. Поэтому объединение их с помощью оператора сложения не работает. Например, 30 + 10 = 40 = 40 + 0 = 39 + 1 Не работает конкатенация. Например, «31» + «2» = 312 = «3» + «12»

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

Вы ищете биективное NxN -> Nотображение. Они используются, например, для ласточкиного хвоста . Посмотрите этот PDF для ознакомления с так называемыми функциями сопряжения . Википедия представляет особую функцию сопряжения, а именно функцию сопряжения Кантора :

Три замечания:

• Как ясно дали понять другие, если вы планируете реализовать функцию сопряжения, вскоре вы можете обнаружить, что вам нужны сколь угодно большие целые числа (bignums).
• Если вы не хотите проводить различие между парами (a, b) и (b, a), то отсортируйте a и b перед применением функции сопряжения.
• На самом деле я солгал. Вы ищете биективное ZxZ -> Nотображение. Функция Кантора работает только на неотрицательных числах. Однако это не проблема, потому что легко определить биекцию f : Z -> N, например так:
  • f (n) = n * 2, если n> = 0
  • f (n) = -n * 2 - 1, если n <0

Функция сопряжения Кантора действительно одна из лучших, учитывая ее простоту, скорость и эффективность использования пространства, но кое-что еще лучше опубликовано в Wolfram Мэтью Шудзиком, здесь . Ограничение функции сопряжения Кантора (относительно) состоит в том, что диапазон закодированных результатов не всегда остается в пределах 2Nбитового целого числа, если входные данные являются Nдвухбитными целыми числами. То есть, если мои входные данные представляют собой 16двухбитные целые числа в диапазоне от 0 to 2^16 -1, то 2^16 * (2^16 -1)возможны комбинации входных данных, поэтому, в соответствии с очевидным принципом Pigeonhole , нам нужен выход по крайней мере такого размера 2^16 * (2^16 -1), который равен 2^32 - 2^16или, другими словами, карте32битовые числа должны быть выполнимыми в идеале. Это не может иметь мало практического значения в мире программирования.

Функция сопряжения Кантора :

(a + b) * (a + b + 1) / 2 + a; where a, b >= 0

Отображение для двух максимально 16-битных целых чисел (65535, 65535) будет 8589803520, которое, как вы видите, не может быть вписано в 32 бита.

Введите функцию Шудзика :

a >= b ? a * a + a + b : a + b * b;  where a, b >= 0

Отображение для (65535, 65535) теперь будет 4294967295, которое, как вы видите, является 32-битным (от 0 до 2 ^ 32 -1) целым числом. Вот где это решение идеально, оно просто использует каждую точку в этом пространстве, поэтому ничто не может быть более эффективным.

Теперь, учитывая тот факт, что мы обычно имеем дело со знаковыми реализациями чисел различных размеров в языках / инфраструктурах, давайте рассмотрим signed 16битовые целые числа, начиная от -(2^15) to 2^15 -1(позже мы увидим, как расширить даже выходной поток, чтобы охватить диапазон со знаком). Так как aи bдолжны быть положительными, они варьируются от 0 to 2^15 - 1.

Функция сопряжения Кантора :

Отображение для двух максимальных 16-разрядных целых чисел со знаком (32767, 32767) будет 2147418112, что немного меньше максимального значения для 32-разрядного целого числа со знаком.

Теперь функция Шудзика :

(32767, 32767) => 1073741823, намного меньше ..

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

Функция сопряжения Кантора :

A = a >= 0 ? 2 * a : -2 * a - 1;
B = b >= 0 ? 2 * b : -2 * b - 1;
(A + B) * (A + B + 1) / 2 + A;

(-32768, -32768) => 8589803520, то есть Int64. 64-битный выход для 16-битных входов может быть таким непростительным !!

Функция Шудзика :

A = a >= 0 ? 2 * a : -2 * a - 1;
B = b >= 0 ? 2 * b : -2 * b - 1;
A >= B ? A * A + A + B : A + B * B;

(-32768, -32768) => 4294967295, который является 32-битным для диапазона без знака или 64-битным для диапазона со знаком, но все же лучше.

Теперь все это пока результат всегда был положительным. В мире со знаком будет еще больше экономии места, если мы сможем перевести половину вывода на отрицательную ось . Вы можете сделать это так для Шудзика:

A = a >= 0 ? 2 * a : -2 * a - 1;
B = b >= 0 ? 2 * b : -2 * b - 1;
C = (A >= B ? A * A + A + B : A + B * B) / 2;
a < 0 && b < 0 || a >= 0 && b >= 0 ? C : -C - 1;

(-32768, 32767) => -2147483648

(32767, -32768) => -2147450880

(0, 0) => 0 

(32767, 32767) => 2147418112

(-32768, -32768) => 2147483647

Что я делаю: применив вес 2к входам и пройдя через функцию, затем разделю выходной сигнал на два и перенесу некоторые из них на отрицательную ось, умножив на -1.

См. Результаты, для любого ввода в диапазоне числа 16битов со знаком, выход лежит в пределах 32целого числа битов со знаком, что здорово. Я не уверен, как сделать то же самое для функции сопряжения Кантора, но не пытался так сильно, как это не так эффективно. Кроме того, чем больше вычислений, связанных с функцией сопряжения Кантора, тем медленнее и ее .

Вот реализация C #.

public static long PerfectlyHashThem(int a, int b)
{
    var A = (ulong)(a >= 0 ? 2 * (long)a : -2 * (long)a - 1);
    var B = (ulong)(b >= 0 ? 2 * (long)b : -2 * (long)b - 1);
    var C = (long)((A >= B ? A * A + A + B : A + B * B) / 2);
    return a < 0 && b < 0 || a >= 0 && b >= 0 ? C : -C - 1;
}

public static int PerfectlyHashThem(short a, short b)
{
    var A = (uint)(a >= 0 ? 2 * a : -2 * a - 1);
    var B = (uint)(b >= 0 ? 2 * b : -2 * b - 1);
    var C = (int)((A >= B ? A * A + A + B : A + B * B) / 2);
    return a < 0 && b < 0 || a >= 0 && b >= 0 ? C : -C - 1;
}

Поскольку промежуточные вычисления могут превышать пределы 2Nцелого числа со знаком, я использовал 4Nцелочисленный тип (последнее деление на 2возвращает результат в 2N).

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

Если A и B могут быть выражены 2 байтами, вы можете объединить их в 4 байта. Поместите A в самую значительную половину, а B в самую младшую.

В языке C это дает (при условии, что sizeof (short) = 2 и sizeof (int) = 4):

int combine(short A, short B)
{
    return A<<16 | B;
}

short getA(int C)
{
    return C>>16;
}

short getB(int C)
{
    return C & 0xFFFF;
}

Это вообще возможно?
Вы объединяете два целых числа. Оба имеют диапазон от -2 147 483 648 до 2 147 483 647, но вы будете принимать только положительные результаты. Это составляет 2147483647 ^ 2 = 461169E + 18 комбинаций. Поскольку каждая комбинация должна быть уникальной И приводить к целому числу, вам понадобится какое-то магическое целое число, которое может содержать это количество чисел.

Или моя логика ошибочна?

Стандартный математический способ для натуральных чисел состоит в использовании уникальности простой факторизации.

f( x, y ) -> 2^x * 3^y

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

Вы можете изменить это, чтобы иметь дело с отрицательным xи yкодируя флаги со степенями 5 и 7 членов.

например

f( x, y ) -> 2^|x| * 3^|y| * 5^(x<0) * 7^(y<0)

Пусть число aбудет первым, bвторым. Позвольте pбыть a+1-th простое число, qбудет b+1-th простое число

Тогда результат pq, если a<b,или 2pqесли a>b. Если a=bда, то будет p^2.

Не так сложно построить отображение:

   1 2 3 4 5 используйте это отображение, если (a, b)! = (B, a)
1 0 1 3 6 10
2 2 4 7 11 16
3 5 8 12 17 23
4 9 13 18 24 31
5 14 19 25 32 40

   1 2 3 4 5 используйте это отображение, если (a, b) == (b, a) (зеркало)
1 0 1 2 4 6
2 1 3 5 7 10
3 2 5 8 11 14
4 4 8 11 15 19
5 6 10 14 19 24


    0 1 -1 2 -2 используйте это, если вам нужен отрицательный / положительный
 0 0 1 2 4 6
 1 1 3 5 7 10
-1 2 5 8 11 14
 2 4 8 11 15 19
-2 6 10 14 19 24

Выяснить, как получить значение для произвольного a, b немного сложнее.

f(a, b) = s(a+b) + a, где s(n) = n*(n+1)/2

• Это функция - она ​​детерминированная.
• Это также инъективно - f отображает разные значения для разных (a, b) пар. Вы можете доказать это, используя факт s(a+b+1)-s(a+b) = a+b+1 < a.
• Он возвращает довольно маленькие значения - хорошо, если вы собираетесь использовать его для индексации массива, так как массив не должен быть большим.
• Это удобно для кэша - если две (a, b) пары близки друг к другу, то f отображает числа, которые близки друг к другу (по сравнению с другими методами).

Я не понял, что Вы подразумеваете под:

должен всегда давать целое число на положительной или отрицательной стороне целых чисел

Как я могу написать (больше чем), (меньше чем) символы на этом форуме?

Хотя ответ Stephan202 является единственным действительно общим, для целых чисел в ограниченном диапазоне вы можете добиться большего успеха. Например, если ваш диапазон составляет 0,10 000, то вы можете сделать:

#define RANGE_MIN 0
#define RANGE_MAX 10000

unsigned int merge(unsigned int x, unsigned int y)
{
    return (x * (RANGE_MAX - RANGE_MIN + 1)) + y;
}

void split(unsigned int v, unsigned int &x, unsigned int &y)
{
    x = RANGE_MIN + (v / (RANGE_MAX - RANGE_MIN + 1));
    y = RANGE_MIN + (v % (RANGE_MAX - RANGE_MIN + 1));
}

Результаты могут помещаться в одно целое число в диапазоне до квадратного корня из числа целочисленных типов. Это упаковывает немного более эффективно, чем более общий метод Stephan202. Также значительно проще декодировать; не требующий квадратных корней, для начала :)

Для положительных целых чисел в качестве аргументов и там, где порядок аргументов не имеет значения:

1. Вот неупорядоченная функция сопряжения :

   <x, y> = x * y + trunc((|x - y| - 1)^2 / 4) = <y, x>
   

2. Для x ≠ y вот уникальная неупорядоченная функция сопряжения :

   <x, y> = if x < y:
              x * (y - 1) + trunc((y - x - 2)^2 / 4)
            if x > y:
              (x - 1) * y + trunc((x - y - 2)^2 / 4)
          = <y, x>
   

Проверьте это: http://en.wikipedia.org/wiki/Pigeonhole_principle . Если A, B и C одного типа, это невозможно сделать. Если A и B являются 16-разрядными целыми числами, а C - 32-разрядными, то вы можете просто использовать сдвиг.

Сама природа алгоритмов хеширования заключается в том, что они не могут предоставить уникальный хеш для каждого отдельного ввода.

Вот расширение кода @DoctorJ на неограниченные целые числа, основанное на методе, заданном @nawfal. Он может кодировать и декодировать. Он работает с обычными массивами и массивами numpy.

#!/usr/bin/env python
from numbers import Integral    

def tuple_to_int(tup):
    """:Return: the unique non-negative integer encoding of a tuple of non-negative integers."""
    if len(tup) == 0:  # normally do if not tup, but doesn't work with np
        raise ValueError('Cannot encode empty tuple')
    if len(tup) == 1:
        x = tup[0]
        if not isinstance(x, Integral):
            raise ValueError('Can only encode integers')
        return x
    elif len(tup) == 2:
        # print("len=2")
        x, y = tuple_to_int(tup[0:1]), tuple_to_int(tup[1:2])  # Just to validate x and y

        X = 2 * x if x >= 0 else -2 * x - 1  # map x to positive integers
        Y = 2 * y if y >= 0 else -2 * y - 1  # map y to positive integers
        Z = (X * X + X + Y) if X >= Y else (X + Y * Y)  # encode

        # Map evens onto positives
        if (x >= 0 and y >= 0):
            return Z // 2
        elif (x < 0 and y >= 0 and X >= Y):
            return Z // 2
        elif (x < 0 and y < 0 and X < Y):
            return Z // 2
        # Map odds onto negative
        else:
            return (-Z - 1) // 2
    else:
        return tuple_to_int((tuple_to_int(tup[:2]),) + tuple(tup[2:]))  # ***speed up tuple(tup[2:])?***


def int_to_tuple(num, size=2):
    """:Return: the unique tuple of length `size` that encodes to `num`."""
    if not isinstance(num, Integral):
        raise ValueError('Can only encode integers (got {})'.format(num))
    if not isinstance(size, Integral) or size < 1:
        raise ValueError('Tuple is the wrong size ({})'.format(size))
    if size == 1:
        return (num,)
    elif size == 2:

        # Mapping onto positive integers
        Z = -2 * num - 1 if num < 0 else 2 * num

        # Reversing Pairing
        s = isqrt(Z)
        if Z - s * s < s:
            X, Y = Z - s * s, s
        else:
            X, Y = s, Z - s * s - s

        # Undoing mappint to positive integers
        x = (X + 1) // -2 if X % 2 else X // 2  # True if X not divisible by 2
        y = (Y + 1) // -2 if Y % 2 else Y // 2  # True if Y not divisible by 2

        return x, y

    else:
        x, y = int_to_tuple(num, 2)
        return int_to_tuple(x, size - 1) + (y,)


def isqrt(n):
    """":Return: the largest integer x for which x * x does not exceed n."""
    # Newton's method, via http://stackoverflow.com/a/15391420
    x = n
    y = (x + 1) // 2
    while y < x:
        x = y
        y = (x + n // x) // 2
    return x

Как насчет чего-то гораздо более простого: учитывая два числа, A и B позволяют str быть конкатенацией: 'A' + ';' + «Б». Тогда пусть выводом будет хеш (str). Я знаю, что это не математический ответ, а простой скрипт на python (который имеет встроенную хэш-функцию) должен выполнить эту работу.

То, что вы предлагаете, невозможно. У вас всегда будут столкновения.

Для сопоставления двух объектов другому отдельному набору сопоставленный набор должен иметь минимальный размер числа ожидаемых комбинаций:

Предполагая 32-разрядное целое число, у вас есть 2147483647 натуральных чисел. Выбор двух из них, где порядок не имеет значения, с повторением дает 2305843008139952128 комбинаций. Это не очень хорошо вписывается в набор 32-битных целых чисел.

Однако вы можете разместить это отображение в 61 бит. Использование 64-разрядного целого числа, вероятно, проще всего. Установите старшее слово на меньшее целое и младшее слово на большее.

Скажем, у вас есть 32-разрядное целое число, почему бы просто не переместить A в первую 16-разрядную половину, а B в другую?

def vec_pack(vec):
    return vec[0] + vec[1] * 65536;


def vec_unpack(number):
    return [number % 65536, number // 65536];

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

a = vec_pack([2,4])
b = vec_pack([1,2])

print(vec_unpack(a+b)) # [3, 6] Vector addition
print(vec_unpack(a-b)) # [1, 2] Vector subtraction
print(vec_unpack(a*2)) # [4, 8] Scalar multiplication

давайте иметь два числа B и C, кодирующие их в одно число A

A = B + C * N

где

B = A% N = B

C = A / N = C

Учитывая положительные целые числа A и B, пусть D = количество цифр A имеет, а E = количество цифр B имеет. Результатом может быть объединение D, 0, E, 0, A и B.

Пример: A = 300, B = 12. D = 3, E = 2, результат = 302030012. Это использует тот факт, что единственным числом, начинающимся с 0, является 0,

Pro: Легко кодировать, легко декодировать, удобочитаемый, сначала можно сравнить значимые цифры, возможность сравнения без вычислений, простая проверка ошибок.

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

Если вы хотите больше контроля, например, выделите биты X для первого числа и биты Y для второго числа, вы можете использовать этот код:

class NumsCombiner
{

    int num_a_bits_size;
    int num_b_bits_size;

    int BitsExtract(int number, int k, int p)
    {
        return (((1 << k) - 1) & (number >> (p - 1)));
    }

public:
    NumsCombiner(int num_a_bits_size, int num_b_bits_size)
    {
        this->num_a_bits_size = num_a_bits_size;
        this->num_b_bits_size = num_b_bits_size;
    }

    int StoreAB(int num_a, int num_b)
    {
        return (num_b << num_a_bits_size) | num_a;
    }

    int GetNumA(int bnum)
    {
        return BitsExtract(bnum, num_a_bits_size, 1);
    }

    int GetNumB(int bnum)
    {
        return BitsExtract(bnum, num_b_bits_size, num_a_bits_size + 1);
    }
};

Я использую всего 32 бита. Идея здесь в том, что если вы хотите, например, чтобы первое число было до 10 бит, а второе число до 12 бит, вы можете сделать это:

NumsCombiner nums_mapper(10/*bits for first number*/, 12/*bits for second number*/);

Теперь вы можете хранить в num_aмаксимальном количестве 2^10 - 1 = 1023и в num_bмаксимальном значении 2^12 - 1 = 4095.

Чтобы установить значение для числа A и числа B:

int bnum = nums_mapper.StoreAB(10/*value for a*/, 12 /*value from b*/);

Теперь bnumвсе биты (всего 32 бита. Вы можете изменить код, чтобы использовать 64 бита). Чтобы получить число:

int a = nums_mapper.GetNumA(bnum);

Чтобы получить число б:

int b = nums_mapper.GetNumB(bnum);

РЕДАКТИРОВАТЬ: bnumможет храниться в классе. Я этого не делал, потому что для собственных нужд я поделился кодом и надеюсь, что он будет полезен.

Спасибо за источник: https://www.geeksforgeeks.org/extract-k-bits-given-position-number/ за функцию извлечения битов и спасибо также за mouvicielответ в этом посте. Используя эти источники, я смог найти более продвинутое решение.