在两个序列之间映射的公式答案

【问题标题】：formula to map between two sequences在两个序列之间映射的公式
【发布时间】：2016-06-07 20:20:09
【问题描述】：

鉴于以下 3 个序列，我希望能够将 seqN 映射到 seq0。 seq1 映射到 seq0 和 seq2 到 seq1 通过：

seqN(i) = (seqN-1(i)*7)%27

例如，

seq1(i) = (seq0(i)*7)%27

seq0    0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27

seq1    0   7   14  21  1   8   15  22  2   9   16  23  3   10  17  24  4   11  18  25  5   12  19  26  6   13  20  27

seq2    0   22  17  12  7   2   24  19  14  9   4   26  21  16  11  6   1   23  18  13  8   3   25  20  15  10  5   27

现在，一种方法是递归地应用该函数。但这对我来说不是一个选择（这需要在硬件中实现）。我也不能保存最后一个序列的值来计算当前序列的值 - 我没有空间。

有没有办法使用数学方程（不是递归函数）将 seqN 映射到 seq0？

【问题讨论】：

Nitpick - 你的序列应该从 0 到 26 而不是 27 (27 % 27 == 0)
听起来您应该改用 LUT。
谢谢丹，伊格纳西奥。伊格纳西奥，我没有空间放 LUT...

标签： math sequences

【解决方案1】：

除了@Nitpick 指出的（27 % 27 = 0，因此您必须在 26 处停止或改用 28），您应该简单地使用幂：

seq_N(i) = (seq₀(i) * 7^N ) % 27

或者：

seq_N(i) = (seq_N-1(i) * 7) % 27 = (seq_N-2( i) * 7² ) % 27 = ... = ( seq_N-N(i) * 7^N ) % 27

【讨论】：

谢谢鲍勃！这行得通。但是“正确”的做法是使用 %28，因为我不想寻找 % 运算符的 LHS 为 27 的特殊情况，也可以用 27（而不是 0）填充输出。那么等式如何变化呢？
一个答案是：seqN(i) = ( seq0(i) * 7^N + x) % 28，其中 x 每四个 i 增加 1。但这不适用于 seq(2)
@AzemPasha 您确定这些序列是您发布的序列吗？递归关系是否有机会成为 seqN(i) = (seqN-1(i)*7)%28？序列是否只有 28 个或更多元素？因为如果你只有这些元素并且你确定数字，最好的方法是将第 28 个元素设置为 27 并计算其他元素。
序列是正确的，是的。可以有更多元素，但在这种情况下，有 28 个。我需要使用不同的数据集，以确保它可以与 % OP 的 RHS 中的 num_data - 1 一起使用。

【解决方案2】：

不确定这是否有帮助，但某些seq_N(i) -> seq_/{N+/-1}(i) 的转换完全由以下一组循环决定：

List(0)
List(1, 7, 22, 19, 25, 13, 10, 16, 4)
List(2, 14, 17, 11, 23, 26, 20, 5, 8)
List(3, 21, 12)
List(6, 15, 24)
List(9)
List(18)

如0 -> 0、1 -> 7 -> 22 -> 19 -> 25 -> ... 等

根据这些循环，您可以获取一个数字的位置并将其转换为N % length_of_cycle（仅处理循环换行）并获得原始数字。

我使用以下代码（用 Scala 编写）找到了这些循环：

val m = (0 to 26).map(x => (x, x * 7 % 27)).toMap

var cycles = (0 to 26).map(x => {
    var x_i = x
    val oot = scala.collection.mutable.ArrayBuffer(x)
    while (m(x_i) != x)
    {
        x_i = m(x_i)
        oot.append(x_i)
    }
    oot.toList
})

var filteredCycles = cycles.toArray

for (i <- (1 to 26))
{
    val cycle = filteredCycles(i)
    for (j <- (1 until cycle.size))
    {
        filteredCycles(cycle(j)) = List[Int]()
    }
}

val uniqueCycles = filteredCycles.filter(_.size != 0)

【讨论】：