假设我们有两个数字B和C，把它们编码成一个数字A

A = b + c * n

在哪里

B= a % n = B

C= a / n = C

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

下面是一个无序配对函数: < 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（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, b)对彼此接近，那么f将彼此接近的数字映射到它们(与其他方法相比)。

我不明白您所说的:

应该总是产生一个整数 不管是积极的还是消极的 整数的边

我如何在这个论坛写(大于)，(小于)字符?

看看这个:http://en.wikipedia.org/wiki/Pigeonhole_principle。如果A, B, C是同一类型，就不能做。如果A和B是16位整数，而C是32位整数，那么您可以简单地使用移位。

哈希算法的本质是它们不能为每个不同的输入提供唯一的哈希。

如果你想要更多的控制，比如为第一个数字分配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在这篇文章中的回答。 利用这些资源，我可以找出更先进的解决方案

假设我们有两个数字B和C，把它们编码成一个数字A

A = b + c * n

在哪里

B= a % n = B

C= a / n = C