Блог

У меня есть следующий список: [[a,a,b,a,b,b,b],[5,5,4,5],[5,1,5],[2,5],[4,5],[5],[3],[5]]

Количество списков, содержащих числовые значения, такое же, как и элементов в первом списке (который содержит буквы «a» или «b»). Длина списков, содержащих числа, априори неизвестна.

Таким образом, каждая буква соответствует списку:

a —> 5,5,4,5

a —> 5,1,5

b —> 2,5

a —> 4,5

b —> 5

b —> 3

b —> 5

А затем подсчитайте каждое значение по буквам «a» или «b», сохраняя при этом значения, например, «a» имеет в общей сложности 6 «5», 2 «4», и 1 «1». «b» имеет в общей сложности 3 «5», 1 «2», и 1 «3».

Ожидаемый результат:

«а» имеет в общей сложности 6 «5», 2 «4», и 1 «1».

«б» имеет в общей сложности 3 «5», 1 «2», и 1 «3».

Один подход:

 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)
 

Выход

 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)
 

Выход

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

Это был бы мой подход:

 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
 

Мой вывод для этого:

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

Затем вы можете использовать счетчики, len () и т.д., Чтобы получить точное форматирование вывода, которое вы хотите.

Смотрите ниже ( 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}')
 

выход

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

Это забавная проблема, которую нужно решить.

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

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

Во-первых, вы действительно должны делать свою собственную домашнюю работу

… Мне просто нравится хорошая проблема с альго ( 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)
 

и результат:

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