将一个整数范围可逆地映射到另一个整数范围的算法？

Question

什么是一种节省时间和空间效率的算法，用于将离散的整数范围（比如区间 I1 [A..B]，其中 B>=A）线性映射到另一个更大的整数范围（比如区间I2 [C..D] 其中 D>=C)？

这里简单表示，第二个范围I2的大小被限制为大于或等于第一个范围I1，即D-C >= B-A。

因此，I1 中的每个整数都映射到 I2 中包含的一个或多个对应整数的集合（因为 I2 的大小大于 I1 的大小）。相反，I2 中的每个整数都映射回 I1 中唯一的对应整数。

所以有两种期望的算法，它们在两个提供的整数区间的域中运行：区间 I1 [A..B] 和区间 I2 [C..D]（其中 B>=A 和 D>=C 并且D-C >= B-A)

1. 算法 A1：给定 I1 中包含的整数 X，计算 I2 中相应的线性映射整数集。将此表示为 A1(I1,I2,X) = [M..N]，其中 [M..N] 是 I2 的子区间。

2. 算法 A2：给定区间 I2 中包含的整数 Y，计算 I1 中的单个对应整数。将此表示为 A2(I1,I2,Y) = X。

算法 A2 必须是 A1 的对称逆。即对于 I1 中的所有 X：A1(I1,I2,X) = [M..N]，那么对于 [M..N] 中的所有 Y：A2(I1,I2,Y) = X

显然，由于此问题仅限于整数，因此映射可能不是完全线性的。例如，如果 I1 包含三个整数 [1..3]，而 I2 包含四个整数 [4..7]，则 I1 中的两个整数将在 I2 中具有单个映射，并且 I1 中的第三个整数将具有I2 中的两个映射。 I1 中具有两个映射的特定整数无关紧要。重要的是，算法 A1 选择具有两个映射（Y 和 Y+1）的整数 (X)，然后算法 A2 必须将这两个相同的 Y 值映射回 I1 中的原始 X。

算法 A1 和 A2 应尽可能创建从 I1 到 I2 的最线性映射。换句话说，如果区间 I1 的大小为 J，而区间 I2 的大小为 K（记得 K>=J），那么 I1 的每个整数要么具有 TRUNC(K/J) 映射，要么具有 TRUNC(K/J)+1 映射进入 I2。

算法应该占用常量空间，因此由一组可能使用截断整数除法和模运算以及其他基本数学函数的代数方程组成。换句话说，算法不能为需要空间来将每个映射存储在表中的映射创建表，因为整数间隔的大小可以达到 2^64。

编辑：例如，假设区间 I1 = [0..2] 和区间 I2 = [0..4]。一种正确的解决方案可能是：

Algorithm A1                    Algorithm A2
X=0, Y=[0..1]                   Y=0, X=0
X=1, Y=[2..3]                   Y=1, X=0
X=2, Y=[4]                      Y=2, X=1
                                Y=3, X=1
                                Y=4, X=2

另一个同样正确的解决方案是：

Algorithm A1                    Algorithm A2
X=0, Y=0                        Y=0, X=0
X=1, Y=[1..2]                   Y=1, X=1
X=2, Y=[3..4]                   Y=2, X=1
                                Y=3, X=2
                                Y=4, X=2

一个不正确的解决方案是：

Algorithm A1                    Algorithm A2
X=0, Y=[0..1]                   Y=0, X=0
X=1, Y=[2..3]                   Y=1, X=1
X=2, Y=[4]                      Y=2, X=1
                                Y=3, X=2
                                Y=4, X=2

上述解决方案不正确。尽管 A1 确实将 [0..2] 线性映射到 [0..4]，并且 A2 确实将 [0..4] 线性映射回 [0..2]，但问题是 A2 不是 A1 的逆.例如，对于 X=0，A1(0) 的值之一是 Y=1，但 A2(1) 给出 X=1（而不是原始值 0）。

Answer 1

您可以使用multiplicative inverse 和偏移量轻松完成此操作。首先减去A。然后进行乘法逆计算，并通过添加C来转换结果。

要反转它，减去 D，进行乘法逆计算的逆运算，然后加上 A。

这很好用。我以前用过，效果很好。

Answer 2

我建议不要使用间隔和截断，而是使用模块化映射：只需将 i1 的元素按数字顺序映射到 i2 上，并根据需要进行换行。这是 Python 中的代码（为了清晰和通用性，有一些过于简单和冗余的分配），以及范围 [2:5] 和 [4:13] 的示例

代码：

def alg_1(x, interval_1, interval_2):
# Map X, an element of interval 1,
#   to a list of elements in interval 2.

    lo_1 = interval_1[0]
    hi_1 = interval_1[1]
    lo_2 = interval_2[0]
    hi_2 = interval_2[1]
    range_1 = hi_1 - lo_1 + 1
    range_2 = hi_2 - lo_2 + 1
    pos_1 = x - lo_1

    base_val = pos_1 + lo_2
    y = range(base_val, hi_2+1, range_1)


    return y

def alg_2(y, interval_1, interval_2):
# Map Y, an element of interval 2,
#   to its corresponding element in interval1.

    lo_1 = interval_1[0]
    hi_1 = interval_1[1]
    lo_2 = interval_2[0]
    hi_2 = interval_2[1]
    range_1 = hi_1 - lo_1 + 1
    range_2 = hi_2 - lo_2 + 1
    pos_2 = y - lo_2

    x = lo_1 + pos_2 % range_1

    return x


i1 = (2, 5)
i2 = (4, 13)

print "X  Y"

for val in range(i1[0], i1[1]+1):
    print val, alg_1(val, i1, i2)

print ""
print "Y  X"

for val in range(i2[0], i2[1]+1):
    print val, alg_2(val, i1, i2)

输出：

X  Y
2 [4, 8, 12]
3 [5, 9, 13]
4 [6, 10]
5 [7, 11]


Y  X
4 2
5 3
6 4
7 5
8 2
9 3
10 4
11 5
12 2
13 3

问题 对于 X=>Y 映射，此方法返回映射值列表。此列表的大小为|i2| / |i1|。这可以接受吗？当这个比率上升到大约 2^25 时，它会变慢。

如果你愿意，你可以返回一个 xrange 而不是一个范围；那是序列的生成器，而不是序列本身。