2 个相同大小的列表之间可变移动（数字）的稀疏矩阵

Question

我想创建一个稀疏矩阵，表示两个一维数组或数字列表的索引之间的差异。这两行为我们提供了时间 'a' 和稍后时间 'b'.

的位置

a = [6,3,10,2,5,7,4,11,8,9]
b = [10,3,6,5,11,2,7,8,9,4]

如您所见，“6”已从索引 0 移至索引 2。 '3' 从索引 1 到索引 1。 '10' 从索引 2 到索引 0。 '2' 从索引 3 到索引 5。等等...

我想将此运动映射到稀疏的 n*n 矩阵。每行和每列都按照从 2 开始的数字顺序排列：

>>>sorted(a)
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

下面是我想要的最终结果（运动的稀疏矩阵）

array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
   [ 0.,  0.,  0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.],
   [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
   [ 1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
   [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
   [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
   [ 0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
   [ 0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
   [ 0.,  1.,  0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.],
   [ 1.,  0.,  1.,  0.,  0.,  1.,  0.,  0.,  0.,  0.]])

这是我画的这张图的代表：

其中第一列由列表 a 表示，第二列由列表 b 表示。

粉红色的荧光笔表示向索引 0（向上）移动。黄色荧光笔表示向下移动。没有荧光笔意味着位置没有变化。

这是我的：

>>>import numpy as np
>>>sparse = np.zeros((len(a),len(a)))
>>>sparse.shape
(10, 10)
>>>a_unique = np.unique(np.array(b), return_index=True)
>>>b_unique = np.unique(np.array(b), return_index=True)
>>>a_unique
(array([ 2,  3,  4,  5,  6,  7,  8,  9, 10, 11]), array([3, 1, 6, 4, 0, 5, 8, 9, 2, 7]))
>>>b_unique
(array([ 2,  3,  4,  5,  6,  7,  8,  9, 10, 11]), array([5, 1, 9, 3, 2, 6, 7, 8, 0, 4]))

现在，如果我们从 a_unique 中减去 b_unique，则得到以下结果：

>>> a_unique[1]-b_unique[1]
array([-2,  0, -3,  1, -2, -1,  1,  1,  2,  3])

^ 负数在稀疏矩阵中垂直（作为一列）表示为给定其他数字的位置（即数字已从列表 a 向下移动到列表 b，即黄色荧光笔）。

^ 一个正数在稀疏矩阵中水平（作为一行）表示为从其他数字接收到的位置（即该数字已从列表 a 向上移动到列表 b，即粉红色荧光笔）。

我不确定如何继续解决这个问题，因此我需要帮助。

Answer 1

睡了一觉就解决了这个问题

def seq_movement(a,b):
    import numpy as np
    def counter(items):
    counts = dict()
    for i in items:
        counts[i] = counts.get(i, 0) + 1
    return counts

    def find_2(dic):
        return [k for k, v in dic.items() if v ==2]

    sort = sorted(a)
    sparse = np.zeros([len(sort)]*2)

    while sorted(a) == sorted(b):
        for i,j in enumerate(sort):
                ai = a.index(j)
                bi = b.index(j)
                abovea = a[:ai]
                belowb = b[bi:]
                receiving = find_2(counter(belowb + abovea)) #row
                for row_ele in receiving:
                    sparse[i][sort.index(row_ele)] = 1
                belowa = a[ai:]
                aboveb = b[:bi]
                giving = find_2(counter(belowa + aboveb)) #column
                for col_ele in giving:
                    sparse[:,i][sort.index(col_ele)] = 1
         break     
    return sparse

它像示例中一样接受 a 和 b 的输入。首先，我们要确保列表 a 和 b 中的参与者相同。

我们遍历参与者列表，找到列表a中参与者j下面的参与者。然后我们得到列表b中参与者j以上的参与者。

然后我们将列表连接在一起，找出哪些参与者在合并后的列表中出现了两次。出现两次的参与者是接替参与者 j 的参与者，因此稀疏矩阵中 j 的列将有 1 来表示。

然后为参与者 j 以上的那些参与者完成此过程，随后 j 将从该参与者那里收到 1（即行号）。

如有任何其他疑问，请随时提出！

任务完成。

2 个相同大小的列表之间可变移动（数字）的稀疏矩阵

Sparse matrix of variable movement (digits) between 2 same sized lists

python

numpy

linear-algebra

scipy

sparse-matrix