Commencer à représenter le problème pas trop bêtement.

Ce coup-ci, avec une analyse des données, placées dans les bonnes structures, la seconde partie de l'exercice va se faire immédiatement après la première.

Ici on a encore un truc assez simple, et on va faire un dictionnaire avec en clé le numéro de la partie et en valeur une liste de triplets (rouge, vert, bleu), avec des zéros là où on n'a pas d'infos en entrée.
-> Normaliser les entrées, avoir une structure assez facile à analyser ensuite.

import sys
from functools import reduce
colors = {"red": 0, "green": 1, "blue": 2}
def read_cubes(cubeset):
 r = [0, 0, 0]
 for cubes in cubeset.strip().split(","):
 nb, color = cubes.strip().split(" ")
 r[colors[color]] = int(nb)
 return r
def input():
 for line in sys.stdin:
 game, cubes = line.strip().split(':')
 game = int(game.split(" ")[1])
 cubes = [read_cubes(cubeset) for cubeset in cubes.split(";")]
 yield game, cubes
datas = [x for x in input()]

Déjà, j'abuse des yields et des générateurs, c'est pas encore utile, mais ça va venir.

Pour la partie 1 on va avoir une fonction de validation, et après on fait une somme :

def test_elements(elements, constraint):
 for el in elements:
 for i in range(3):
 if el[i] > constraint[i]:
 return False
 return True
constraint = [12, 13, 14]
r = sum(
 game
 for game, elements in datas
 if test_elements(elements, constraint)
)
print(f"Possible games : {r}")

Et là, pour la seconde partie on n'a même plus besoin de fonction de validation, le calcul est immédiat, même si le code est moche. Y'aurait moyen avec des structures de données de numpy de se passer de certaines méthodes peu explicites avec directement des comparaisons de vecteurs, ou un produit vectoriel. Bah, pas encore, on reste en python chocolat, poire... Vanille !

power = sum(
 reduce(lambda x, y: x * y, [max(i) for i in zip(*elements)])
 for game, elements in datas
)
print(f"Sum of Power of games : {power}")

Le reduce sert à multiplier entre eux tous les éléments de la liste, et le zip va transformer une liste de triplets (r, v, b) en triplet de listes ([r, r, r...], [v, v, v...], [b, b, b...]).

Jusqu'ici, ya pas grand chose à déclarer, on manipule des données, on n'a même pas vraiment besoin de trop se compliquer à trouver les bonnes structures de données.

• Yth.