alberic89 🐧 a écrit 205 commentaires

Nous avons identifié que le problème était thermique, lié à des condensateurs chimiques ayant séché avec le temps et perdant de leur capacité à basse température. Un coup de sèche-cheveux a permis de redémarrer l'ordinateur de la surface.

C'est marrant, j'ai eu le même problème avec une télévision ! Elle ne fonctionnait correctement que l'été, il fallait faire des manipulations complexes pour la faire démarrer à la mi-saison, et impossible d'en tirer quoi que ce soit en hiver.

Ç'a l'air d'être malheureusement d'être un problème assez répandu.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

[...] client lourd comme Thunderbird [...]

Comment ça Thunderbird est « lourd » ??!!?!

C'est absolument faux !!! Il est simplement un peu packagé.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Heureusement, il y a toujours le pétulant Achille Talon de Greg pour remonter tout ça.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

La plupart des liseuses ont des écrans à encre électronique, dont pas de lumière bleue, pas de soucis !

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Le paquet deb a un problème de dépendance sur Debian 12, il faut le compiler soi-même, ou utiliser l'AppImage pour Xorg.

Mais sinon, j'approuve complètement.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Le jeu Battle Tanks (btanks) a aussi mis sa décoration de Noël !

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Il y avait eu aussi https://linuxfr.org/users/alberic89/liens/bloquons-le-demarchage-telephonique-par-gee

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Voici ma solution, elle est rapide, mais elle m'a pris beaucoup de temps pour une et une seule raison : dans la première partie, j'ai codé une fonction qui calcule le poids si on bougeait les pierres vers le nord (en fait l'est puisque j'ai renversé le puzzle, je préfère les lignes aux colonnes).
Dans ma deuxième partie, je me dis ; « Réutilisons gaiement cette fonction après avoir effectivement fait rouler les pierres ! » 😔

#!/bin/python3
from functools import cache
def rotate90(lines):
 columns = [""]*len(lines[0])
 for i in range(len(lines[0])):
 columns[i] = "".join(reversed([ _[i] for _ in lines ]))
 return columns
@cache
def getWeight(rang,nb):
 return sum(range(rang-nb+1,rang+1))
@cache
def getLoad(line):
 count = 0
 total = 0
 for i, _ in enumerate(line):
 if _ == "#":
 total += getWeight(i,count)
 count = 0
 elif _ == "O":
 count += 1
 total += getWeight(len(line),count)
 return total
@cache
def getActualLoad(line):
 total = 0
 for i, _ in enumerate(line):
 if _ == "O":
 total += i+1
 return total
@cache
def fallLine(line):
 count = 0
 result = ""
 for i, _ in enumerate(line):
 if _ == "#":
 while len(result) < i - count:
 result += "."
 result += "O"*count + "#"
 count = 0
 elif _ == "O":
 count += 1
 while len(result) < len(line) - count :
 result += "."
 result += "O"*count
 return result
def cycle(puzzle,step):
 if step == 0:
 return puzzle, sum([getActualLoad(_) for _ in rotate90(puzzle)])
 return cycle([fallLine(_) for _ in rotate90(puzzle)],step-1)
def solve1(puzzle,testing=False):
 s=0
 s = sum([getLoad(_) for _ in rotate90(puzzle)])
 if testing:
 print(s)
 return s
def solve2(puzzle,testing=False):
 s = 0
 pastresult = []
 now = puzzle
 pastresult.append(now)
 i=1
 while True:
 now, r = cycle(now,4)
 if now in pastresult:
 i = pastresult.index(now)
 tosum = ((1000000000 - i ) % (len(pastresult) - i)) + i
 s = sum([getActualLoad(_) for _ in rotate90(pastresult[tosum])])
 break
 pastresult.append(now)
 i+= 1
 if testing:
 print(s)
 return s

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Ce problème aurait dû être simple. Mais sinon ce ne serait pas un problème.

J'ai mis bien du temps à comprendre que je ne pouvais construire une liste vide de 256 listes vides juste avec [[],]*256 car alors toutes les listes sont liées, et la modification d'une seule entraine la modification de toutes les autres. Sigh. Moi qui espérais pouvoir rattraper mon léger retard, c'est mal parti, et ce n'est pas ce week-end que ça va s'arranger.

Un code néanmoins simple, et je l'espère facile à comprendre :

#!/bin/python3
def asciiHash(word):
 r = 0
 for l in word:
 r = ((r + ord(l)) * 17) % 256
 return r
def getPower(box):
 r = 0
 for i,b in enumerate(box):
 for index,lens in enumerate(b):
 r += lens[1]*(index+1)*(i+1)
 return r
def getEmptyList(nb):
 return [[] for _ in range(nb)]
def focusingPower(sequence):
 box = getEmptyList(256)
 for s in sequence:
 if s[-1] == "-":
 for index, lens in enumerate(box[asciiHash(s[:-1])]):
 if lens[0] == s[:-1]:
 box[asciiHash(s[:-1])].remove(lens)
 break
 else:
 c = False
 for index, lens in enumerate(box[asciiHash(s.split("=")[0])]):
 if lens[0] == s.split("=")[0]:
 box[asciiHash(s.split("=")[0])][index] = (s.split("=")[0], int(s.split("=")[1]))
 c = True
 break
 if not c:
 box[asciiHash(s.split("=")[0])].append((s.split("=")[0], int(s.split("=")[1])))
 return getPower(box)
def solve1(puzzle,testing=False):
 s=0
 s = sum([asciiHash(_) for _ in puzzle[0].split(",")])
 if testing:
 print(s)
 return s
def solve2(puzzle,testing=False):
 s = 0
 s = focusingPower(puzzle[0].split(","))
 if testing:
 print(s)
 return s

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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)

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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)

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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)

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

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.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès