alberic89 🐧 a écrit 191 commentaires

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

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.

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

Salut,
Le leadboard LinuxFR 2023 est-il déjà crée ou pas ?
On pourrait aussi essayer de faire comme l'année dernière, un journal par jour.

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

Et parce qu'il faut toujours rire de l'incompétence : https://grisebouille.net/reglons-le-probleme-du-chomage/

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

Petit point libriste : il existe une alternative libre à Shazam nommée Mousai qui fait partie du GNOME Circle, qui existe en version mobile et dont voilà le dépôt git.

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

Pour ceux qui ont la flemme de chercher de légers trous de mémoire, voici qui devrait vous rafraichir :

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

Gee a aussi fait une BD sur le sujet : https://grisebouille.net/foutez-la-paix-a-ma-bouffe/

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

Auto-réponse : Apache Guacamole semble pouvoir fournir un service semblable, à explorer plus en détail.

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

Le cas 1 me semble une très bonne idée, je note.
Ne serait-il pas possible, si on voulait pousser le bouchon un peu plus loin, d'imaginer qu'on héberge un service libre semblable à NoMachine chez un Chaton ou autre hébergeur dans ce style ? Je vais chercher.

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

C'est en effet une très bonne piste, mais je ne pourrais pas l'utiliser. En effet, je n'ai pas la main sur le proxy et la box derrière lesquels je suis, et l'administrateur est très très très frileux sur l'ouverture des ports.

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

Il y a une suite à l'histoire de Gee.
Mais pas de solution pour l'instant.

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

Le principal avantage est le gain de place, j'imagine que les performances restent les mêmes.

Ça peut être utile sur des environnements où l'espace disque est limité, ou bien si tu as des Go de librairies Python (coucou Numpy & Cie) et que tu veux faire du ménage.

En somme très peu utile dans le cas général. Mais ça prouve qu'on peut compiler du code Python.

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

En français, j'ai réussis à avoir les épisodes 1, 2, 4, 6, 7 et 8 de Ubunchu.
En anglais, on peut tous les avoir facilement ici et là.

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

Quelqu'un aurait-il une liste de bots qu'il est bon de bloquer, et pourquoi ?
Je vois que NixCraft en bloque une bonne tripotée, quelqu'un pourrait-il m'aider à comprendre pourquoi ?

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

Et la compilation doit-elle être prise en compte ?

Un programme en C a été compilé et donc a consommé déjà des ressources importantes avant même d'être utilisé ! Il faut donc un certain nombre d'utilisations pour amortir.

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

Surtout les fans.

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

Bonjour,
je suppose que tu as essayé d'utiliser un AppImage, mais que tu n'as pas pu.
N'essaye JAMAIS de toucher à ta glibc, à moins de vouloir tout péter sans possibilité de retour.

Tu as plusieurs solutions :
- Passer à Debian Sid (très déconseillé)
- Essayer d'utiliser l'archive webcamoid-portable-linux-9.1.1-x64.tar.xz sur la page https://github.com/webcamoid/webcamoid/releases en l'extrayant et lançant le fichier webcamoid.sh
- Compiler toi-même le logiciel en suivant les instructions à https://github.com/webcamoid/webcamoid/wiki/Build-and-install-in-GNU-Linux-and-FreeBSD (peu recommandé)

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

À ma connaissance, Zig n'inclut que ce système dans sa syntaxe, qui est mieux expliquée ici, et en quoi elle permet de faire du parallélisme : https://kristoff.it/blog/zig-colorblind-async-await/
Mais je suppose qu'il existe des tas de librairies C et bientôt des librairies Zig qui implémentent des fonctions beaucoup plus avancées.

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