Индекс списка совпадений, основанный на его значении

List_of_Inds = [0,1,4,2,2]
List_Vals = [5,4,3,2,1]
dic ={}

i = 0
for key in List_of_Inds:
    if key not in dic:
        dic[key] = 0
    dic[key] = List_Vals[i]+dic[key]
    i = i+1

output = []
for key in range(0, len(dic)+1):
    if key in dic:
        output.append(dic[key])
    else:
        output.append(0)

print(dic)
print(output)

вывод:

{0: 5, 1: 4, 4: 3, 2: 3}
[5, 4, 3, 0, 3]

Код ответа

def ans(list1,list2):
    dic={}
    ans=[]
    if not(len(list1)==len(list2)):
        return "Not Possible"
    for i in range(0,len(list1)):
        ind=list1[i]
        val=list2[i]
        if not(ind in dic.keys()):
            dic[ind]=val
        else:
            dic[ind]+=val
    val=len(list1)
    for i in range(0,val):
        if not(i in dic.keys()):
            ans.append(0)
        else:
            ans.append(dic[i])
    return ans

Для проверки:

  print(ans([0,1,4,2,2], [5,4,3,2,1]))

вывод:

  [5, 4, 3, 0, 3]

Надеюсь, это поможет

не понимаю ни одного шага

Следующий код работает по желанию. В информатике это называется «Разреженная матрица», где данные хранятся только для указанных индексов, но «виртуальный размер» структуры данных кажется большим извне.

import logging

class SparseVector:
    def __init__(self, indices, values):
        self.d = {}
        for c, indx in enumerate(indices):
            logging.info(c)
            logging.info(indx)
            if indx not in self.d:
                self.d[indx] = 0
            self.d[indx] += values[c]

    def getItem(self, key):
        if key in self.d:
            return self.d[key]
        else:
            return 0

p1 = SparseVector([0,1,4,2,2], [5,4,3,2,1])
print p1.getItem(0);
print p1.getItem(1);
print p1.getItem(2);
print p1.getItem(3);
print p1.getItem(4);
print p1.getItem(5);
print p1.getItem(6);

Это проблема группировки. Вы можете использовать collections.defaultdict для построения отображения словаря, увеличивая значения в каждой итерации. Затем используйте понимание списка:

indices = [0,1,4,2,2]
values = [5,4,3,2,1]

from collections import defaultdict
dd = defaultdict(int)
for idx, val in zip(indices, values):
    dd[idx] += val

res = [dd[idx] for idx in range(max(dd) + 1)]

## functional alternative:
# res = list(map(dd.get, range(max(dd) + 1)))

print(res)
# [5, 4, 3, 0, 3]

вы можете отсортировать индексы и значения в порядке возрастания, а затем суммировать их. Вот пример кода:

import numpy as np

ind = [0,1,4,2,2]
vals = [5,4,3,2,1]

points = zip(ind,vals)

sorted_points = sorted(points)

new_ind = [point[0] for point in sorted_points]
new_val = [point[1] for point in sorted_points]

output = np.zeros((len(new_ind)))

for i in range(len(new_ind)):
    output[new_ind[i]] += new_val[i]    

В этом коде значения индекса сортируются в порядке возрастания, а затем массив значений перестраивается в соответствии с отсортированным массивом индекса. Затем, используя простой цикл for, вы можете суммировать значения каждого существующего индекса и вычислять результат.