对于作为参数的正整数和参数顺序无关的情况:

下面是一个无序配对函数: < x, y > = x * y + trunc ((x - y | | - 1) ^ 2 / 4) = < y、x > 对于x≠y，这里有一个唯一的无序配对函数: <x, y> = if x < y: X * (y - 1) + trunc((y - X - 2)²/ 4) 如果x > y: (x - 1) * y + trunc((x - y - 2)^2 / 4) = <y, x>

正整数的标准数学方法是利用质因数分解的唯一性。

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

缺点是，图像往往跨越相当大的整数范围，因此当涉及到在计算机算法中表示映射时，您可能会在为结果选择适当的类型时遇到问题。

你可以修改它来处理负x和负y，通过编码一个5和7次幂项的标志。

e.g.

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

Cantor pairing function is really one of the better ones out there considering its simple, fast and space efficient, but there is something even better published at Wolfram by Matthew Szudzik, here. The limitation of Cantor pairing function (relatively) is that the range of encoded results doesn't always stay within the limits of a 2N bit integer if the inputs are two N bit integers. That is, if my inputs are two 16 bit integers ranging from 0 to 2^16 -1, then there are 2^16 * (2^16 -1) combinations of inputs possible, so by the obvious Pigeonhole Principle, we need an output of size at least 2^16 * (2^16 -1), which is equal to 2^32 - 2^16, or in other words, a map of 32 bit numbers should be feasible ideally. This may not be of little practical importance in programming world.

康托配对函数:

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

两个最大最多16位整数(65535,65535)的映射将是8589803520，正如您所看到的，它不能适合32位。

进入Szudzik函数:

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

(65535, 65535)的映射现在将是4294967295，正如您所看到的，这是一个32位(0到2^32 -1)整数。这就是这个解决方案的理想之处，它只是利用了空间中的每一个点，所以没有什么比空间效率更高了。

---

现在考虑到我们通常在语言/框架中处理各种大小的数字的有符号实现，让我们考虑从-(2^15)到2^15 -1的有符号16位整数(稍后我们将看到如何扩展输出以跨越有符号范围)。因为a和b必须是正的它们的取值范围是0到2^15 - 1。

康托配对函数:

两个最大最多的16位有符号整数(32767,32767)的映射将是2147418112，这恰好小于32位有符号整数的最大值。

现在是Szudzik函数:

(32767, 32767) => 1073741823, many small ..

让我们考虑负整数。我知道这超出了最初的问题，但只是详细说明，以帮助未来的游客。

康托配对函数:

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位输入可能是如此不可原谅!!

Szudzik的函数：

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位，但仍然更好。

现在所有这些输出都是正的。在有符号的世界中，如果我们能将输出的一半转移到负轴上，将会更加节省空间。对于Szudzik's，你可以这样做:

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的权重并遍历函数后，然后将输出除以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)。

我提供的替代解决方案的链接很好地描绘了利用空间中的每一个点的函数图。令人惊讶的是，你可以将一对坐标可逆地唯一编码为一个数字!神奇的数字世界!!

假设你有一个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

如果你想要更多的控制，比如为第一个数字分配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的最大值。

设置num A和num B的值。

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

现在bnum是所有的位(总共32位)。您可以将代码修改为使用64位) 要得到num a:

int a = nums_mapper.GetNumA(bnum);

要得到num b:

int b = nums_mapper.GetNumB(bnum);

编辑: Bnum可以存储在类中。我做这件事不是因为我自己的需要 我分享了代码，希望对您有所帮助。

感谢来源: https://www.geeksforgeeks.org/extract-k-bits-given-position-number/ 对于函数提取位，也感谢mouviciel在这篇文章中的回答。 利用这些资源，我可以找出更先进的解决方案

你的建议是不可能的。总会有碰撞。

为了将两个对象映射到另一个单独的集合，映射的集合必须具有预期组合数量的最小大小:

假设有一个32位整数，则有2147483647个正整数。选择其中两个顺序无关紧要且具有重复的组合，将得到2305843008139952128个组合。这并不适合32位整数的集合。

不过，你可以把这个映射压缩成61位。使用64位整数可能是最简单的。将高的字设置为较小的整数，低的字设置为较大的整数。