alberic89 🐧 a écrit 171 commentaires

Aujourd'hui, je considère ma carte comme une grille avec 0,0 en haut à gauche, puis je cherche les lignes/colonnes vides, puis l'emplacement des galaxies que j'associe par paires.

Je cherche ensuite la distance entre les paires de galaxies, et ajoute à ces distances le nombre de lignes/colonnes vides comprises entre les deux galaxies multiplié par un facteur (1 pour la 1^er partie, 1000000-1 pour la 2^e ).

Le code :

#!/bin/python3

def getVoid(puzzle):
    void_lines = []
    for i, line in enumerate(puzzle):
        if all([e == "." for e in line]):
            void_lines.append(i)
    void_columns = []
    for col in range(len(puzzle[0])):
        if all([l[col] == "." for l in puzzle]):
            void_columns.append(col)
    return void_lines, void_columns

def getGalaxies(puzzle):
    galaxies = []
    for i, line in enumerate(puzzle):
        for j, space in enumerate(line):
            if space == "#":
                galaxies.append((j,i))
    return galaxies

def getPairs(galaxies):
    pairs = []
    for i in range(len(galaxies)):
        for p in range(i):
            pairs.append((galaxies[i],galaxies[p]))
    return pairs

def getSpaceBetween(pair, void_lines, void_columns, space_void):
    spacex = abs(pair[1][0] - pair[0][0])
    spacex += sum([space_void if i in void_columns else 0 for i in range(min([pair[0][0],pair[1][0]]),max(pair[0][0],pair[1][0]))])
    spacey = abs(pair[1][1] - pair[0][1])
    spacey += sum([space_void if i in void_lines else 0 for i in range(min([pair[0][1],pair[1][1]]),max(pair[0][1],pair[1][1]))])
    return spacex+spacey

def solve1(puzzle,testing=False):
    s=0
    void_lines, void_columns = getVoid(puzzle)
    galaxies = getGalaxies(puzzle)
    pairs = getPairs(galaxies)
    for p in pairs:
        s += getSpaceBetween(p,void_lines,void_columns,1)
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    void_lines, void_columns = getVoid(puzzle)
    galaxies = getGalaxies(puzzle)
    pairs = getPairs(galaxies)
    for p in pairs:
        s += getSpaceBetween(p,void_lines,void_columns,1000000-1)
    if testing:
        print(s)
    return s

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Quand j'ai vu que l'énoncé nous demandait de définir une boucle fermée, j'ai tout de suite senti qu'on allait devoir en calculer l'aire dans la partie suivante.
Je ne me suis pas trompé.
Dans la partie une, une récursion sur toute la boucle suffit (en augmentant la limite de récursion).
Ma logique pour la partie deux est que certains motifs nous font entrer ou sortir de la boucle, il suffit de les repérer en parcourant toute la carte.
Et beaucoup de gestion d'erreur pour repérer les erreurs de logique quand on code ou pour ne pas avoir à tester les longueurs des chaînes.
Voici mon code :

#!/bin/python3
import sys

sys.setrecursionlimit(10000)

def getStart(puzzle):
    for i,l in enumerate(puzzle):
        for j,p in enumerate(l):
            if p == "S":
                return [i,j]

def initLoop(puzzle,countpipes=True,get_connections=False):
    start = getStart(puzzle)
    direction = ""
    connections = ""
    go_away = [0,0]
    try:
        if puzzle[start[0]-1][start[1]] in ["F","7","|"]:
            direction = "H"
            connections += direction
            go_away = [-1,0]

    except IndexError:
        pass
    try:
        if puzzle[start[0]][start[1]-1] in ["F","L","-"]:
            direction = "G"
            connections += direction
            go_away = [0,-1]
    except IndexError:
        pass
    try:
        if puzzle[start[0]][start[1]+1] in ["J","7","-"]:
            direction = "D"
            connections += direction
            go_away = [0,1]
    except IndexError:
        pass
    try:
        if puzzle[start[0]+1][start[1]] in ["J","L","|"]:
            direction = "B"
            connections += direction
            go_away = [1,0]
    except IndexError:
        pass
    start = [start[0]+go_away[0],start[1]+go_away[1]]
    if get_connections:
        return connections
    if countpipes:
        pipes.append(start)
    return round((browseLoop(puzzle, start, direction,countpipes)+1)/2)

def browseLoop(puzzle, start, direction, countpipes=True):
    here = puzzle[start[0]][start[1]]
    if here == "-":
        if direction == "D":
            start = [start[0],start[1]+1]
        elif direction == "G":
            start = [start[0],start[1]-1]
        else:
            raise ValueError
    elif here == "|":
        if direction == "H":
            start = [start[0]-1,start[1]]
        elif direction == "B":
            start = [start[0]+1,start[1]]
        else:
            raise ValueError
    elif here == "L":
        if direction == "B":
            start = [start[0],start[1]+1]
            direction = "D"
        elif direction == "G":
            start = [start[0]-1,start[1]]
            direction = "H"
        else:
            raise ValueError
    elif here == "F":
        if direction == "H":
            start = [start[0],start[1]+1]
            direction = "D"
        elif direction == "G":
            start = [start[0]+1,start[1]]
            direction = "B"
        else:
            raise ValueError
    elif here == "7":
        if direction == "D":
            start = [start[0]+1,start[1]]
            direction = "B"
        elif direction == "H":
            start = [start[0],start[1]-1]
            direction = "G"
        else:
            raise ValueError
    elif here == "J":
        if direction == "D":
            start = [start[0]-1,start[1]]
            direction = "H"
        elif direction == "B":
            start = [start[0],start[1]-1]
            direction = "G"
        else:
            raise ValueError
    else:
        raise ValueError
    if countpipes:
        pipes.append(start)
    if puzzle[start[0]][start[1]] == "S":
        return 1
    else:
        return browseLoop(puzzle,start,direction)+1

def areConnected(somepipes):
    if somepipes[0] not in ["F","L"]:
        return False
    if not all([i=="-" for i in somepipes[1:-1]]):
        return False
    if somepipes[-1] not in ["7","J"]:
        return False
    if somepipes[0] == "F" and somepipes[-1] == "J":
        return True
    if somepipes[0] == "L" and somepipes[-1] == "7":
        return True
    return False

def floodPipes(puzzle):
    initLoop(puzzle,countpipes=True)
    connections = initLoop(puzzle,get_connections=True)
    start = getStart(puzzle)
    restart = ""
    if all([c in "HB" for c in connections]):
        restart = "|"
    elif all([c in "GD" for c in connections]):
        restart = "-"
    elif all([c in "HD" for c in connections]):
        restart = "L"
    elif all([c in "BD" for c in connections]):
        restart = "F"
    elif all([c in "HG" for c in connections]):
        restart = "J"
    elif all([c in "BG" for c in connections]):
        restart = "7"
    else:
        print(connections)
        raise ValueError

    puzzle[start[0]] = puzzle[start[0]].replace("S",restart)
    inloop = False
    surface = 0
    for i, l in enumerate(puzzle):
        inloop == False
        for j, p in enumerate(l):
            if [i,j] in pipes:
                if puzzle[i][j] == "|":
                    inloop = not inloop
                elif puzzle[i][j] in ["J","7"]:
                    r = puzzle[i][j]
                    iterator = j
                    try:
                        while puzzle[i][iterator] not in ["F","L"]:
                            iterator -= 1
                            r = puzzle[i][iterator] + r
                    except IndexError:
                        pass
                    if areConnected(r):
                        inloop = not inloop

            elif inloop:
                surface += 1

    return surface

def solve1(puzzle,testing=False):
    s=0
    s = initLoop(puzzle)
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    global pipes
    pipes = []
    s = 0
    s = floodPipes(puzzle)
    if testing:
        print(s)
    return s

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Je ne connaissais pas moi-même la fonction all, j'ai fait au plus simple avec une fonction codée par mes soins. Mais c'est vrai qu'on pourrait gagner en efficacité.

Et avec des nombres négatifs, il doit sûrement y avoir des nombres négatifs, ce qui explique que sum retourne 0.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Un exercice étonnamment simple aujourd'hui, mais les explications me semblent un peu embrouillées, est-ce fait exprès ?
Quoi qu'il en soit, voici mon code :

def parse_input(puzzle):
    r = []
    for p in puzzle:
        if p == "":
            continue
        p = p.split()
        p.reverse()
        r.append([int(i) for i in p])
    return r

def parse_input_not_reversed(puzzle):
    r = []
    for p in puzzle:
        if p == "":
            continue
        r.append([int(i) for i in p.split()])
    return r

def are_null(suite):
    for n in suite:
        if n != 0:
            return False
    return True

def find_number(suite):
    suivant = []
    for i,n in enumerate(suite[:-1]):
        suivant.append(n-suite[i+1])
    if are_null(suivant):
        return suite[0]
    else:
        return find_number(suivant)+suite[0]

def solve1(puzzle,testing=False):
    s=0
    for l in parse_input(puzzle):
        s += find_number(l)
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    for l in parse_input_not_reversed(puzzle):
        s += find_number(l)
    if testing:
        print(s)
    return s

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Ma solution aurait pu être mieux optimisée pour la lisibilité et la redondance, mais elle fonctionne. Je définis une classe pour les nœuds, surcharge quelques opérateurs, prétraite quelques données, et trouve le ppcm en utilisant le module math de Python.

#!/bin/python3

from math import lcm

class Nodon:
    def __init__(self,name,left,right):
        self.name = name
        self.right = right
        self.left = left

    def __repr__(self):
        return self.name

    def __eq__(self,stringnode):
        if self.name == stringnode:
            return True
        return False

    def endswith(self,letter):
        if self.name[2] == letter:
            return True
        return False

    def go(self,direction):
        if direction == "R":
            return self.right
        if direction == "L":
            return self.left
        raise ValueError


def parse_node(puzzle):
    direction = puzzle[0]
    nodes = []
    for line in puzzle[1:]:
        if line == "":
            continue
        nodes.append(Nodon(line[:3],line[7:10],line[12:15]))
    return direction, nodes

def run(direction, nodes):
    now = nodes[nodes.index("AAA")]
    nb = 0
    while now != "ZZZ":
        for d in direction:
            now = now.go(d)
            nb += 1
            if now == "ZZZ":
                break
    return nb

def nodesendswith(nodes, l):
    for n in nodes:
        if n.endswith(l) == False:
            return False
    return True

def beforerun(nodes):
    for n in nodes:
        n.right = nodes[nodes.index(n.right)]
        n.left = nodes[nodes.index(n.left)]
    return nodes

def runboth(direction, nodes):
    now = []
    for n in nodes:
        if n.endswith("A"):
            now.append(n)
    nb = 0
    ends = []
    while len(now) != 0:
        for d in direction:
            nb += 1
            for i in range(len(now)):
                now[i] = now[i].go(d)
                if now[i].endswith("Z"):
                    ends.append(nb)
                    now[i] = None
            for i in range(now.count(None)):
                now.remove(None)
            if len(now) == 0:
                break
    return lcm(*ends)

def solve1(puzzle,testing=False):
    s=0
    d, nodes = parse_node(puzzle)
    s = run(d, tuple(beforerun(nodes)))
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    d, nodes = parse_node(puzzle)
    s = runboth(d, tuple(beforerun(nodes)))
    if testing:
        print(s)
    return s

test1 = """RL

AAA = (BBB, CCC)
BBB = (DDD, EEE)
CCC = (ZZZ, GGG)
DDD = (DDD, DDD)
EEE = (EEE, EEE)
GGG = (GGG, GGG)
ZZZ = (ZZZ, ZZZ)
"""
result1 = 2
test2 = """LR

11A = (11B, XXX)
11B = (XXX, 11Z)
11Z = (11B, XXX)
22A = (22B, XXX)
22B = (22C, 22C)
22C = (22Z, 22Z)
22Z = (22B, 22B)
XXX = (XXX, XXX)
"""
result2 = 6

# for cli invocation

def solve(short=False,one=True,two=True):

    s1, s2 = False , False

    if one:
        print("----Part 1----")
        if short == False:
            if solve1(test1.split("\n"),testing=True) != result1:
                print("Not working.")
                return False
            else :
                print("Maybe working?")
        with open("input.txt",'r') as file:
            lines = file.read().split("\n")
            s1 = solve1(lines)
            print(s1)

    if two:
        print("----Part 2----")
        if short == False:
            if solve2(test2.split("\n"),testing=True) != result2:
                print("Not working.")
                return False
            else :
                print("Maybe working?")
        with open("input.txt",'r') as file:
            lines = file.read().split("\n")
            s2 = solve2(lines)
            print(s2)

    return s1, s2

if __name__ == "__main__":

    from sys import argv

    s = False
    one = True
    two = True

    if len(argv) >= 2:

        if "-s" in argv or "--summary" in argv or "--short" in argv:
            s = True
        if "1" in argv:
            two = False
            one = True
        elif "2" in argv:
            one = False
            two = True
        if "2" in argv:
            two = True

    solve(short=s,one=one,two=two)

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

C'est très très très louche : on est un jour impair et la difficulté est raisonnable. Nous sommes trahis.
POur aujourd'hui, j'ai défini deux classes Hand et HandJoker très semblables et qui ont certains opérateurs surchargés pour pouvoir utiliser la fonction sorted().
Après les avoir triés dans des listes par catégories, ont les tris et on récupère le score.

#!/bin/python3

cardlist = {
    "A" : 14,
    "K" : 13,
    "Q" : 12,
    "J" : 11,
    "T" : 10,
}

cardlistjoker = {
    "A" : 14,
    "K" : 13,
    "Q" : 12,
    "J" : 1,
    "T" : 10,
}

class Hand:
    def __init__(self, cardstring, points, cardlist):
        self.points = points
        self.cards = []
        for i in cardstring:
            if i in cardlist.keys():
                self.cards.append(cardlist[i])
            else:
                self.cards.append(int(i))
        self.computecat()

    def computecat(self):
        r = {}
        for i in range(2,15):
            r.update({i:self.cards.count(i)})
        if 5 in r.values():
            self.cat = 0
        elif 4 in r.values():
            self.cat = 1
        elif 3 in r.values() and 2 in r.values():
            self.cat = 2
        elif 3 in r.values():
            self.cat = 3
        elif 2 in r.values() and list(r.values()).count(2) == 2:
            self.cat = 4
        elif 2 in r.values():
            self.cat = 5
        else:
            self.cat = 6

    def __lt__(self, otherhand): # self > otherhand
        for i, c in enumerate(self.cards):
            if c > otherhand.cards[i]:
                return True
            elif c < otherhand.cards[i]:
                return False
        raise ValueError

    def __gt__(self, otherhand): # self < otherhand
        for i, c in enumerate(self.cards):
            if c < otherhand.cards[i]:
                return True
            elif c > otherhand.cards[i]:
                return False
        raise ValueError

class HandJoker(Hand):

    def computecat(self):
        r = {}
        j = self.cards.count(1)
        for i in range(2,15):
            r.update({i:self.cards.count(i)})
        if (5 in r.values()) or (4 in r.values() and j == 1) or (3 in r.values() and j == 2) or (2 in r.values() and j == 3) or (j >= 4):
            self.cat = 0
        elif (4 in r.values()) or (3 in r.values() and j == 1) or (2 in r.values() and j == 2) or (j == 3):
            self.cat = 1
        elif (3 in r.values() and 2 in r.values()) or (2 in r.values() and list(r.values()).count(2) == 2 and j == 1):
            self.cat = 2
        elif (3 in r.values()) or (2 in r.values() and j == 1) or (j == 2):
            self.cat = 3
        elif (2 in r.values()) and (list(r.values()).count(2) == 2):
            self.cat = 4
        elif (2 in r.values()) or (j == 1):
            self.cat = 5
        else:
            self.cat = 6


def parse_hand(puzzle,joker=False):
    hands = []
    for h in puzzle:
        if h == "":
            continue
        if joker:
            hands.append(HandJoker(h.split()[0], int(h.split()[1]),cardlistjoker))
        else:
            hands.append(Hand(h.split()[0], int(h.split()[1]), cardlist))
    return hands

def classify(hands):
    rhands =[[],[],[],[],[],[],[],]
    for h in hands:
        rhands[h.cat].append(h)
    hands = []
    for c in rhands:
        for h in sorted(c):
            hands.append(h)
    return hands


def solve1(puzzle,testing=False):
    s=0
    hands = classify(parse_hand(puzzle))
    hands.reverse()
    for i, h in enumerate(hands):
        s+= (i+1)*h.points
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    hands = classify(parse_hand(puzzle,joker=True))
    hands.reverse()
    for i, h in enumerate(hands):
        s+= (i+1)*h.points
    if testing:
        print(s)
    return s

test1 = """32T3K 765
T55J5 684
KK677 28
KTJJT 220
QQQJA 483
"""
result1 = 6440
test2 = test1
result2 = 5905

# for cli invocation

def solve(short=False,one=True,two=True):

    s1, s2 = False , False

    if one:
        print("----Part 1----")
        if short == False:
            if solve1(test1.split("\n"),testing=True) != result1:
                print("Not working.")
                return False
            else :
                print("Maybe working?")
        with open("input.txt",'r') as file:
            lines = file.read().split("\n")
            s1 = solve1(lines)
            print(s1)

    if two:
        print("----Part 2----")
        if short == False:
            if solve2(test2.split("\n"),testing=True) != result2:
                print("Not working.")
                return False
            else :
                print("Maybe working?")
        with open("input.txt",'r') as file:
            lines = file.read().split("\n")
            s2 = solve2(lines)
            print(s2)

    return s1, s2

if __name__ == "__main__":

    from sys import argv

    s = False
    one = True
    two = True

    if len(argv) >= 2:

        if "-s" in argv or "--summary" in argv or "--short" in argv:
            s = True
        if "1" in argv:
            two = False
            one = True
        elif "2" in argv:
            one = False
            two = True
        if "2" in argv:
            two = True

    solve(short=s,one=one,two=two)

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Très clairement un exos de math qui pourrait être donné à des secondes, il fallait que ça tombe le jour où je n'avais pas le temps avant le soir.
Ma solution :

#!/bin/python3

from math import sqrt

def parse_input(puzzle):
    return [[int(i) for i in puzzle[0].split(":")[1].split()], [int(i) for i in puzzle[1].split(":")[1].split()]]

def parse_input2(puzzle):
    time = int(''.join(puzzle[0].split(":")[1].split()))
    dist = int(''.join(puzzle[1].split(":")[1].split()))
    return [time,dist]

def solve_equ(time,dist):
    x1 = int((time-sqrt(time**2-4*dist))/2)+1
    x2 = (time+sqrt(time**2-4*dist))/2
    if int(x2) == x2:
        x2 = int(x2)-1
    else:
        x2 = int(x2)
    return [x1,x2]

def solve1(puzzle,testing=False):
    s=0
    game = parse_input(puzzle)
    sol = []
    for i,t in enumerate(game[0]):
        p = solve_equ(t,game[1][i])
        sol.append(p[1]-p[0]+1)
    s=sol[0]
    for n in sol[1:]:
        s *= n
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    game = parse_input2(puzzle)
    p = solve_equ(game[0],game[1])
    s = p[1]-p[0]+1
    if testing:
        print(s)
    return s

test1 = """Time:      7  15   30
Distance:  9  40  200"""
result1 = 288
test2 = test1
result2 = 71503

# for cli invocation

def solve(short=False,one=True,two=True):

    s1, s2 = False , False

    if one:
        print("----Part 1----")
        if short == False:
            if solve1(test1.split("\n"),testing=True) != result1:
                print("Not working.")
                return False
            else :
                print("Maybe working?")
        with open("input.txt",'r') as file:
            lines = file.read().split("\n")
            s1 = solve1(lines)
            print(s1)

    if two:
        print("----Part 2----")
        if short == False:
            if solve2(test2.split("\n"),testing=True) != result2:
                print("Not working.")
                return False
            else :
                print("Maybe working?")
        with open("input.txt",'r') as file:
            lines = file.read().split("\n")
            s2 = solve2(lines)
            print(s2)

    return s1, s2

if __name__ == "__main__":

    from sys import argv

    s = False
    one = True
    two = True

    if len(argv) >= 2:

        if "-s" in argv or "--summary" in argv or "--short" in argv:
            s = True
        if "1" in argv:
            two = False
            one = True
        elif "2" in argv:
            one = False
            two = True
        if "2" in argv:
            two = True

    solve(short=s,one=one,two=two)

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Au début, je m'étais dit naïvement :

Faisons un dictionnaire qui indiquera toutes les valeurs à modifier pour passer du début à la fin, en lui appliquant toutes les étapes, pour toutes les valeurs qui peuvent être modifiée. !

Après m'être fait rappeler à l'ordre par mon OOM Killer, j'ai mis en place une solution plus simple qui applique directement les modifications aux numéros de graine et se souvenant s'il a déjà modifié cette valeur (pour éviter de changer 3 fois par étape les numéros).

La partie 2 m'a donnée beaucoup plus de fil à retordre, car ce n'est pas simplement :

Bon bah je génère une liste avec tous les numéros des graines et hop ! je les passe à la même fonction que la partie 1 !

Mais l'OOM Killer proteste encore une fois, m'obligeant à finalement essayer de gérer des intervalles plutôt que des valeurs. Après beaucoup de débuggage et d'arrachage de cheveux, j'ai fini par trouver la recette qui s'exécute instantanément.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Une solution dont je ne suis pas peux fier, puisqu’elle est économe en ressource et prend moins d'une seconde à terminer. Et j'ai enfin commencé à utiliser la POO :

#!/bin/python3

class Range:

    def __init__(self,start,end,pas=0):
        if end <= start:
            raise ValueError
        self.start = start
        self.end = end
        self.pas = pas

    def contain(self, n):
        if type(n) == Range:
            if self.start <= n.start and self.end >= n.end:
                return True
            return False
        if self.start <= n and n < self.end:
            return True
        return False

    def ins(self, thisrange):
        if thisrange.contain(self.start) and thisrange.contain(self.end-1):
            return True
        return False

    def before(self, thisrange):
        if thisrange.contain(self.start) == False and thisrange.contain(self.end-1):
            return True
        return False

    def after(self, thisrange):
        if thisrange.contain(self.start) and thisrange.contain(self.end-1) == False:
            return True
        return False

    def not_ins(self, thisrange):
        if thisrange.contain(self.start) == False and thisrange.contain(self.end-1) == False and thisrange.contain(self) == False:
            return True
        return False

    def apply(self, thisrange):
        if self.pas == 0:
            return ValueError
        thisrange.start = thisrange.start + self.pas
        thisrange.end = thisrange.end + self.pas
        return thisrange



def get_seeds(seeds):
    seeds = seeds.split(":")[1].split()
    for s in range(len(seeds)):
        seeds[s] = int(seeds[s])
    return seeds

def get_seeds_range(seeds):
    seeds_range = []
    seeds = get_seeds(seeds)
    for i in range(0,len(seeds),2):
        seeds_range.append(Range(seeds[i],seeds[i]+seeds[i+1]))
    return seeds_range

def mapping(almanac,seedlist):
    changed = [False for i in range(len(seedlist))]
    almanac = almanac.split(":")[1].split("\n")[1:]
    for c in almanac:
        if c == "" :
            continue
        c = c.split()
        c = [int(i) for i in c]
        for i, s in enumerate(seedlist):
            if s >= c[1] and s < c[1]+c[2] and changed[i] == False:
                newvalue = c[0]+s-c[1]
                seedlist[i] = newvalue
                changed[i] = True

    return seedlist

def mapping_range(almanac, seedrange):
    almanac = almanac.split(":")[1].split("\n")[1:]
    ranges = []
    for c in almanac:
        if c == "" :
            continue
        c = c.split()
        c = [int(i) for i in c]
        ranges.append(Range(c[1],c[1]+c[2],c[0]-c[1]))
    iterations = 0
    while iterations < len(seedrange):
        changed = [False for i in range(len(seedrange))]
        for i in range(iterations,len(seedrange)):
            s = seedrange[i]
            for r in ranges:
                if changed[i]:
                    continue
                if s.ins(r):
                    seedrange[i] = r.apply(s)
                    changed[i] = True

                elif s.before(r):
                    seedrange.append(Range(s.start,r.start))
                    seedrange[i] = r.apply(Range(r.start, s.end))
                    changed[i] = True

                elif s.after(r):
                    seedrange.append(Range(r.end,s.end))
                    seedrange[i] = r.apply(Range(s.start, r.end))
                    changed[i] = True

                elif s.contain(r):
                    seedrange.append(Range(s.start,r.start))
                    seedrange.append(Range(r.end, s.end))
                    seedrange[i] = r.apply(Range(r.start, r.end))
                    changed[i] = True


                elif s.not_ins(r):
                    pass
                else:
                    print("Maybe Error with range",r.start,r.end,r.pas,"and seedrange",s.start,s.end)
            iterations += 1

    return seedrange

def solve1(puzzle,testing=False):
    s=0
    seeds = get_seeds(puzzle[0])

    for changes in puzzle[1:]:
        seeds = mapping(changes, seeds)
    s = min(seeds)
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    seeds = get_seeds_range(puzzle[0])

    for changes in puzzle[1:]:
        seeds = mapping_range(changes, seeds)
    s = seeds[0].start
    for r in seeds:
        if r.start < s:
            s = r.start
    if testing:
        print(s)
    return s

test1 = """seeds: 79 14 55 13

seed-to-soil map:
50 98 2
52 50 48

soil-to-fertilizer map:
0 15 37
37 52 2
39 0 15

fertilizer-to-water map:
49 53 8
0 11 42
42 0 7
57 7 4

water-to-light map:
88 18 7
18 25 70

light-to-temperature map:
45 77 23
81 45 19
68 64 13

temperature-to-humidity map:
0 69 1
1 0 69

humidity-to-location map:
60 56 37
56 93 4
"""
result1 = 35
test2 = test1
result2 = 46

def solve(short=False):

    print("----Part 1----")
    if short == False:
        if solve1(test1.split("\n\n"),testing=True) != result1:
            print("Not working.")
            return False
        else :
            print("Maybe working?")
    with open("input.txt",'r') as file:
        lines = file.read().split("\n\n")
        s1 = solve1(lines)
        print(s1)

    print("----Part 2----")
    if short == False:
        if solve2(test2.split("\n\n"),testing=True) != result2:
            print("Not working.")
            return False
        else :
            print("Maybe working?")
    with open("input.txt",'r') as file:
        lines = file.read().split("\n\n")
        s2 = solve2(lines)
        print(s2)

    return s1, s2

if __name__ == "__main__":

    from sys import argv

    try:
        if argv[1] == "--summary" or argv[1] == "-s":
            solve(short=True)
    except IndexError:
        solve()

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

J'ai vérifié avant et avait fais quelques tests dans la première partie, il n'y a pas de zéro. Et si c'était le cas, il suffirait d'ajouter une ligne au dictionnaire.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Une solution simple mais efficace :

#!/bin/python3

def game_number(game):
    return int(game.split(":")[0][5:])

def find_winning(game):
    game = game.split(":")[1].split("|")[0].split(" ")
    w = []
    for n in game:
        if n != "":
            w.append(int(n))
    return w

def nb_winning(game, winning):
    game = game.split(":")[1].split("|")[1].split(" ")
    nb = 0
    for n in game:
        if n != "":
            if int(n) in winning:
                nb += 1
    return nb

def solve1(puzzle,testing=False):
    s=0
    for game in puzzle:
        if game == "":
            continue
        nb = nb_winning(game, find_winning(game))
        if nb == 0:
            continue
        points = 1 * (2 ** (nb-1))
        if testing:
            print(game,"had", points, "points beacause of", nb, "winning numbers.")
        s += points
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    for i in range(puzzle.count("")):
        puzzle.remove("")
    wons = [1 for i in range(len(puzzle))]
    for game in puzzle:
        num = game_number(game)
        nb = nb_winning(game, find_winning(game))
        if testing:
            print("You had", wons[num-1], "cards", num, "who give you", nb, "cards.")
        for i in range(nb):
            wons[num+i] += wons[num-1]
    s = sum(wons)
    if testing:
        print(s)
    return s

test1 = """Card 1: 41 48 83 86 17 | 83 86  6 31 17  9 48 53
Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19
Card 3:  1 21 53 59 44 | 69 82 63 72 16 21 14  1
Card 4: 41 92 73 84 69 | 59 84 76 51 58  5 54 83
Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36
Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11
"""
result1 = 13
test2 = test1
result2 = 30

def solve(short=False):

    print("----Part 1----")
    if short == False:
        if solve1(test1.split("\n"),testing=True) != result1:
            print("Not working.")
            return False
        else :
            print("Maybe working?")
    with open("input.txt",'r') as file:
        lines = file.read().split("\n")
        s1 = solve1(lines)
        print(s1)

    print("----Part 2----")
    if short == False:
        if solve2(test2.split("\n"),testing=True) != result2:
            print("Not working.")
            return False
        else :
            print("Maybe working?")
    with open("input.txt",'r') as file:
        lines = file.read().split("\n")
        s2 = solve2(lines)
        print(s2)

    return s1, s2

if __name__ == "__main__":

    from sys import argv

    try:
        if argv[1] == "--summary" or argv[1] == "-s":
            solve(short=True)
    except IndexError:
        solve()

J'ai trouvé le problème étonnamment simple, j'y suis arrivé du premier coup pour les deux parties.

Et contrairement à beaucoup de monde ce jour-là, cette solution est presque instantanée à l'exécution, de l'ordre de 0.01 sec.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Voici ma solution du jour :

#!/bin/python3

def intlen(nb):
    l = 0
    while nb >= 1:
        nb = nb / 10
        l +=1
    return l

def ispart(puzzle,line,col,n):
    try :
        if puzzle[line][col-1].isdigit():
            return 0
    except IndexError:
        pass
    try :
        for i in range(1,5):
            if puzzle[line][col+i].isdigit():
                n = n*10 + int(puzzle[line][col+i])
            else:
                break
    except IndexError:
        pass
    for j in [1,-1]:
        for i in range(-1,intlen(n)+1):
            try :
                if puzzle[line+j][col+i].isdigit() == False and puzzle[line+j][col+i] != ".":
                    return n
            except IndexError:
                pass
    for i in [-1,intlen(n)]:
        try :
            if puzzle[line][col+i].isdigit() == False and puzzle[line][col+i] != ".":
                return n
        except IndexError:
            pass
    return 0

def isgear(puzzle,line,col,j):
    try:
        if puzzle[line][col].isdigit() == False:
            return 0
    except IndexError:
        return 0
    if j != -1:
        try:
            if puzzle[line][col-1].isdigit():
                return 0
        except IndexError:
            pass
    start = 0
    for i in range(-1,-5,-1):
        try:
            if puzzle[line][col+i].isdigit():
                start -= 1
            else:
                break
        except IndexError:
            break
    p = ispart(puzzle, line, col+start, int(puzzle[line][col+start]))
    return p

def solve1(puzzle,testing=False):
    s=0
    for line in range(len(puzzle)):
        for col in range(len(puzzle[line])):
            if puzzle[line][col] == ".":
                continue
            elif puzzle[line][col].isdigit():
                p = ispart(puzzle,line,col,int(puzzle[line][col]))
                s += p
                if testing and p!=0:
                    print("The part ", p," at ", line, ";", col, " is ok.")
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    for line in range(len(puzzle)):
        for col in range(len(puzzle[line])):
            if puzzle[line][col] == "*":
                ng = 0
                g = [0,0,0]
                for i in [1,0,-1]:
                    for j in [1,0,-1]:
                        g[ng] = isgear(puzzle,line+i,col+j,j)
                        if g[ng] != 0:
                            ng += 1
                        if ng == 3:
                            break
                    if ng == 3:
                            break
                if ng == 2:
                    if testing:
                        print("Gear at ",line,";",col," with parts ",g[0],";",g[1])
                    s += g[0] * g[1]
                elif testing:
                    print("Gear at ",line,";",col," but with ",ng," parts.")
    if testing:
        print(s)
    return s

test1 ="""
467..114..
...*......
..35..633.
......#...
617*......
.....+.58.
..592.....
......755.
...$.*....
.664.598.."""
result1 = 4361
test2 = test1
result2 = 467835

def solve(short=False):

    print("----Part 1----")
    if short == False:
        if solve1(test1.split("\n"),testing=True) != result1:
            print("Not working.")
            return False
        else :
            print("Maybe working?")
    with open("input.txt",'r') as file:
        lines = file.read().split("\n")
        s1 = solve1(lines)
        print(s1)

    print("----Part 2----")
    if short == False:
        if solve2(test2.split("\n"),testing=True) != result2:
            print("Not working.")
            return False
        else :
            print("Maybe working?")
    with open("input.txt",'r') as file:
        lines = file.read().split("\n")
        s2 = solve2(lines)
        print(s2)

    return s1, s2

if __name__ == "__main__":

    from sys import argv

    try:
        if argv[1] == "--summary" or argv[1] == "-s":
            solve(short=True)
    except IndexError:
        solve()

J'ai passé beaucoup de temps à essayer de comprendre pourquoi diable les test fonctionnaient mais pas l'input ! La réponse était dans ma fonction pour récupérer la taille d'un entier :

def intlen(nb):
    l = 0
    while nb > 0:
        nb = nb / 10
        l +=1
    return l

Avec while nb > 0 au lieu de while nb >= 1. Mais les données de test fonctionnaient, c'était incompréhensible.

Et oui, je suis un grand adepte du try ... except quand je code vite et crade.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Ma solution en Python :

#!/bin/python3

maxvalues = {
    "red":12,
    "green":13,
    "blue":14,
}

def number(game):
    return int(game.split(":")[0][5:])

def possible(game):
    gamelist = game.split(":")[1].split(";")
    for g in gamelist:
        colorlist = g.split(",")
        for c in colorlist:
            n = int(c.split(" ")[1])
            color = c.split(" ")[2]
            if n > maxvalues[color]:
                return False
    return True

def power(game):
    minimum = {
        "red":0,
        "green":0,
        "blue":0,
    }
    gamelist = game.split(":")[1].split(";")
    for g in gamelist:
        colorlist = g.split(",")
        for c in colorlist:
            n = int(c.split(" ")[1])
            color = c.split(" ")[2]
            if n > minimum[color]:
                minimum[color] = n
    return minimum["red"]*minimum["blue"]*minimum["green"]

def solve1(testinput,testing=False):
    s = 0
    for line in testinput:
        if line == "" :
            continue
        p = possible(line)
        if testing:
            print(line, "=", p, ";Number=", number(line))
        if p:
            s += number(line)
    if testing:
        print(s)
    return s

def solve2(testinput,testing=False):
    s = 0
    for line in testinput:
        if line == "" :
            continue
        p = power(line)
        if testing:
            print(line, ";Power=", p)
        s += p
    if testing:
        print(s)
    return s

test1 = """Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green
Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue
Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red
Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red
Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green"""
result1 = 8
test2 = test1
result2 = 2286

def solve(short=False):

    print("----Part 1----")
    if short == False:
        if solve1(test1.split("\n"),testing=True) != result1:
            print("Not working.")
            return False
        else :
            print("Maybe working?")
    with open("input.txt",'r') as file:
        lines = file.read().split("\n")
        s1 = solve1(lines)
        print(s1)

    print("----Part 2----")
    if short == False:
        if solve2(test2.split("\n"),testing=True) != result2:
            print("Not working.")
            return False
        else :
            print("Maybe working?")
    with open("input.txt",'r') as file:
        lines = file.read().split("\n")
        s2 = solve2(lines)
        print(s2)

    return s1, s2

if __name__ == "__main__":

    from sys import argv

    try:
        if argv[1] == "--summary" or argv[1] == "-s":
            solve(short=True)
    except IndexError:
        solve()

C'était presque simple aujourd'hui, c'est suspect.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Ma solution :

#!/bin/python3

replaces = {
    "one":1,
    "two":2,
    "three":3,
    "four":4,
    "five":5,
    "six":6,
    "seven":7,
    "eight":8,
    "nine":9,
}

def extract(word):

    fd = 0
    ld = 0

    for l in word:
        n = 0
        if l.isdigit():
            n = int(l)
        if n != 0:
            if fd == 0:
                fd = n
            ld = n
    return fd*10+ld

def digitalize(word):

    fd = 0
    ld = 0

    for i in range(len(word)):
        n = 0
        if word[i].isdigit():
            n = int(word[i])
        else:
            for k in replaces.keys():
                if word[i:].replace(k,str(replaces[k]))[0].isdigit():
                    n = replaces[k]
                    break
        if n != 0:
            if fd == 0:
                fd = n
            ld = n
    return fd*10+ld

def solve1(testinput,testing=False):
    s = 0
    for line in testinput:
        d = extract(line)
        if testing:
            print(line, "=", d)
        s += d
    if testing:
        print(s)
    return s

def solve2(testinput,testing=False):
    s = 0
    for line in testinput:
        d = digitalize(line)
        if testing:
            print(line, "=", d)
        s += d
    if testing:
        print(s)
    return s

test1 = """1abc2
pqr3stu8vwx
a1b2c3d4e5f
treb7uchetn"""
result1 = 142

test2 = """two1nine
eightwothree
abcone2threexyz
xtwone3four
4nineeightseven2
zoneight234
7pqrstsixtee"""
result2 = 281

def solve(short=False):

    print("----Part 1----")
    if short == False:
        if solve1(test1.split("\n"),testing=True) != result1:
            print("Not working.")
            return False
        else :
            print("Maybe working?")
    with open("input.txt",'r') as file:
        lines = file.read().split("\n")
        s1 = solve1(lines)
        print(s1)

    print("----Part 2----")
    if short == False:
        if solve2(test2.split("\n"),testing=True) != result2:
            print("Not working.")
            return False
        else :
            print("Maybe working?")
    with open("input.txt",'r') as file:
        lines = file.read().split("\n")
        s2 = solve2(lines)
        print(s2)

    return s1, s2

if __name__ == "__main__":

    from sys import argv

    try:
        if argv[1] == "--summary" or argv[1] == "-s":
            solve(short=True)
    except IndexError:
        solve()

Après quelques essais en remplaçant avant de traiter, je me suis rendu compte que le plus simple était de reprendre intégralement la logique de la partie 1 en vérifiant une chaine plutôt qu'un nombre.

Et c'est plutôt propre.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.