合並python中不同長度的兩個列表並計算元素

Question

我有一個列表如下：[[a,a,b,a,b,b,b],[5,5,4,5],[5,1,5],[2,5],[4 ,5],[5],[3],[5]]

包含數值的列表的數量與第一個列表（包含字母“a”或“b”）中的元素相同。 包含數字的列表的長度是先驗未知的。

每個字母以這種方式對應一個列表：

一個 --> 5,5,4,5

一 --> 5,1,5

b --> 2,5

一個 --> 4,5

b --> 5

b --> 3

b --> 5

然后，將每個值按字母“a”或“b”計數，同時保留值，例如“a”共有 6 個“5”、2 個“4”和 1 個“1”。 “b”一共有3個“5”，1個“2”，1個“3”。

預期結果：

“a”一共有6個“5”，2個“4”，1個“1”。

“b”一共有3個“5”，1個“2”，1個“3”。

Answer 1

一種方法：

from collections import Counter, defaultdict

lst = [["a", "a", "b", "a", "b", "b", "b"], [5, 5, 4, 5], [5, 1, 5], [2, 5], [4, 5], [5], [3], [5]]

result = defaultdict(Counter)
head, *tail = lst

for key, values in zip(head, tail):
    result[key] += Counter(values)

for key, counts in result.items():
    print(key, counts)

Output

a Counter({5: 6, 4: 2, 1: 1})
b Counter({5: 3, 2: 1, 3: 1})

替代：

head, *tail = lst
counts = Counter((key, value) for key, values in zip(head, tail) for value in values)

result = defaultdict(dict)
for (key, value), count in counts.items():
    result[key][value] = count

for key, value in result.items():
    print(key, value)

Output

a {5: 6, 4: 2, 1: 1}
b {2: 1, 5: 3, 3: 1}

Answer 2

這將是我的方法：

inputs = [['a','a','b','a','b','b','b'],[5,5,4,5],[5,1,5],[2,5],[4,5],[5],[3],[5]]
counts = {}

for k, v in zip(inputs[0], inputs[1:]):
     if k in counts.keys():
          counts[k] += v
     else:
          counts[k] = v

我的 output 為此：

{'a': [5, 5, 4, 5, 5, 1, 5, 4, 5], 'b': [2, 5, 5, 3, 5]}

然后你可以使用計數器、len() 等來獲得你想要的精確 output 格式。

Answer 3

見下文（ Counter和defaultdict是主要的“玩家”）

from collections import Counter,defaultdict
results = defaultdict(Counter)

data =  [['a','a','b','a','b','b','b'],[5,5,4,5],[5,1,5],[2,5],[4,5],[5],[3],[5]]
for idx,x in enumerate(data[0],1):
  results[x].update(data[idx])
for letter,counter in results.items():
  print(f'{letter} -> {counter}')

output

a -> Counter({5: 6, 4: 2, 1: 1})
b -> Counter({5: 3, 2: 1, 3: 1})

Answer 4

這是一個有趣的問題。

from collections import Counter

data = [['a','a','b','a','b','b','b'],[5,5,4,5],[5,1,5],[2,5],[4,5],[5],[3],[5]]

counts = { k:Counter() for k in list(set(data[0])) }

for i, k in enumerate(data[0], 1):
    counts[k].update(data[i])

print(counts)
# {'a': Counter({5: 6, 4: 2, 1: 1}), 'b': Counter({5: 3, 2: 1, 3: 1})}

Answer 5

l = [["a","a","b","a","b","b","b"],[5,5,4,5],[5,1,5],[2,5],[4,5],[5],[3],[5]]
d = {}
for i in l[0]:
    if i not in d.keys():
        d[i] = []
for i, item in zip(l[0],l[1:]):
    d[i].append(item)
count_dict = {}

for i in d.keys():
    count_dict[i] = {}
    for j in d[i]:
        elements = set(j)
        for k in elements:
            if str(k) not in count_dict[i].keys():
                count_dict[i][str(k)] = j.count(k)
            else:
                count_dict[i][str(k)] += j.count(k)
for i,j in count_dict.items():
    print('{} has {}'.format(i,j))
        

Answer 6

首先，你真的應該自己做功課

...我只是喜歡一個好的算法問題（ adventOfCode ，有人嗎？）

腳步：

• 不要忘記"在列表中的字符串周圍
• 創建一個字典來存儲"a"和"b"中的計數
• 迭代索引 1-n 中的列表
  • 從以下位置獲取 a/b 桶： l[0][sublist_index - 1]
  • 開始計算值，如果尚未計算： if v not in d[bucket].keys(): d[bucket][v] = 0
  • 在適當的存儲桶中增加v的計數器： d[bucket][v] += 1

l = [["a","a","b","a","b","b","b"],[5,5,4,5],[5,1,5],[2,5],[4,5],[5],[3],[5]]
d = {"a": {}, "b": {}}

for sublist_index in range(1, len(l)):
    bucket = l[0][sublist_index - 1]
    for v in l[sublist_index]:
        if v not in d[bucket].keys():
            d[bucket][v] = 0
        d[bucket][v] += 1

print(d)

和 output：

{'a': {5: 6, 4: 2, 1: 1}, 'b': {2: 1, 5: 3, 3: 1}}