Редкая матрица переменных перемещений (цифр) между 2 списками одинакового размера

Question

Я хочу создать разреженную матрицу различий между индексами двух 1D-массивов или списков цифр. Эти две строки дают нам позиции в момент времени «а», а позднее - «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.]]) 

, который является представителем этого графа я составил:

Причем первый столбец представлен список а и второго столбца, представленного списка б.

Розовый highligher указывает движение в направлении индекса 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])) 

Теперь, если мы вычитаем b_unique из a_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.

Мы перебираем список участников и находим участников ниже участника j в списке a. Затем мы получаем участников выше участника j в списке b.

Затем мы объединяем списки и находим, какие участники встречаются дважды в объединенном списке. Участниками, участвующими дважды, являются те, у кого есть выше принятый участник j, и, следовательно, столбец j в разреженной матрице будет иметь 1 место, чтобы обозначить это.

Этот процесс затем выполняется для участников, выше участников j, а затем, где j должен получить 1 от этого участника (то есть номер строки).

Любые другие вопросы не стесняйтесь спрашивать!

Миссия выполнена.