合并python中不同长度的两个列表并计算元素

Question

I have a list as follows: [[a,a,b,a,b,b,b],[5,5,4,5],[5,1,5],[2,5],[4,5],[5],[3],[5]]

The number of lists containing numerical values is the same as the elements in the first list (that contains letters "a" or "b"). The length of the lists containing numbers is unknown a priori.

Each letter corresponds to a list in this way:

a --> 5,5,4,5

a --> 5,1,5

b --> 2,5

a --> 4,5

b --> 5

b --> 3

b --> 5

And then, count each value by letters "a" or "b", while keeping the values, for example "a" has in total 6 "5", 2 "4", and 1 "1". "b" has in total 3 "5", 1 "2", and 1 "3".

Expected result:

"a" has in total 6 "5", 2 "4", and 1 "1".

"b" has in total 3 "5", 1 "2", and 1 "3".

Answer 1

One approach:

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})

An alternative:

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

This would be my approach:

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

My output for this:

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

Then you can use Counters, len(), etc. to get the exact output formatting you want.

Answer 3

See below ( Counter and defaultdict are the main "players")

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

It's a fun problem to solve.

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

First off, you should really be doing your own homework

... I just love a good algo problem ( adventOfCode , anyone?)

Steps:

• don't forget " around strings in the list
• create a dictionary to store counts within "a" and "b"
• iterate over lists in indices 1-n
  • get the a/b bucket from: l[0][sublist_index - 1]
  • start a count for value, if not already counted: if v not in d[bucket].keys(): d[bucket][v] = 0
  • increment the counter for v , in the appropriate bucket: 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)

and the output:

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