guitou a écrit 115 commentaires

J'ai p-e profere une anerie, j'ai pense Debian, donc Grub, mais sur Pi, c'est pas dit… dsl

Je viens de voir https://forums.raspberrypi.com/viewtopic.php?t=394580&start=25

Tu peux essayer de reboot sur le precedent noyau pour voir si tu es dans un cas similaire

Hello,

peut-etre une alim un peu legere?

Si t'as des peripheriques pas indispensables, essaie de redemarrer apres les avoir debranches, au cas ou

++
Gi)

J'avoue que c'est tentant, mais en meme temps (serais-je macroniste a l'insu de mon plein gre?) faut pas non plus aller trop vite dans la surenchere, sinon, apres c'est le materiel qui va plus suivre: c'est fini la loi de More maintenant, ma bonne dame!

… mais avec quelques ameliorations a suivre en attendant, peut-etre de quoi justifier une depeche alors.

Quelques pistes, si besoin:

• remplacer l'input name par un select avec les identifiants pre remplis et prevoir bien sur une page pour editer la liste avec le role admin (perso, alzheimer me guette, ca pourrait se reveler utile)
• qui dit admin dit responsabilites, donc authentification triple facteur quand admin: il faut alors une case a cocher supplementaire quand on choisit ce role. La securite c'est du serieux !
• rajouter un peu de rot13 avant le base64, ou apres, voire les 2 pour encore plus de securitay !!
• passer aussi les valeurs des checkbox dans le token et renvoyer vers une erreur si pas cochees, ceinture et bretelles !!!

Je proposerais bien aussi la declinaison en versions pour divers langages et frameworks, le site web qui va bien avec instructions d'install en mode curl https://mon-site-revolutionnaire.com/install.sh | sh -c, version pro payante avec ta version propre de JWT supportant ton systeme de chiffrement proprietaire ultra securise, mais ca risque d'etre delicat a finaliser dans l'echeance… quoique, avec une IA, ca doit pouvoir se faire, en toute securite, mais autant garder ca pour la creation de start up et la levee de fonds.

Pour ma part, j'ai toute confiance ^ ^

Comme dirait une ex presque premiere dame, merci pour ce moment.

++
Gi)

J'avoue que, moi aussi, j'ai un peu tique a la lecture du dit article, ils nous ont habitue a mieux. Mais il n'en reste pas moins que le sujet aborde est problematique.
Le systeme anterieur posait probleme, car le cout de la validation excluait de fait toute petite structure du marche, entre le prix, le delai et le fait que le moindre changement de code oblige a repasser par cette etape.
Le systeme actuel pose aussi probleme, avec l'auto-attestation, c'est carrement la fete a neuneu pour la fraude. Et oui, le LL est malheureusement indirectement en cause (meme si on peut, de fait, ergoter sur la distinction entre LL et open source): ce sera tjs plus facile pour un margoulin de produire une version verolee d'un programme dont il peut aisement obtenir les sources, ou d'y trouver un faille a exploiter, que d'avoir a decompiler de l'assembleur ou dechiffrer des E/S.
Personnellement, je doute que revenir en arriere ou maintenir le systeme en place soit une bonne idee, mais je n'ai pas d'alternative a proposer.

++
Gi)

J'aurai bien traine aussi ce soir pour plier le bouzin, en partie pour cause de boulettes a traquer, puis pour polish ensuite et reiterer sur la partie boulette.
Au final, rien de bien original (mais promis, j'ai pas copie):

from __future__ import annotations
from functools import reduce
from itertools import combinations, count
from operator import mul
from typing import NamedTuple


class SpaceCoord(NamedTuple):
    x: int
    y: int
    z: int

    def square_distance(self, other: SpaceCoord) -> int:
        return pow(other.x - self.x, 2) + pow(other.y - self.y, 2) + pow(other.z - self.z, 2)

    @classmethod
    def from_data(cls, data: str) -> SpaceCoord:
        return cls(*map(int, data.split(',')))

class Junction:
    def __init__(self, data: list[str]) -> None:
        self.boxes = [SpaceCoord.from_data(line) for line in data]
        self.ordered_pairs = sorted(combinations(self.boxes, 2), key=lambda t: t[0].square_distance(t[1]))

    def _join(self, steps: int|None = None) -> tuple[list[int],tuple[SpaceCoord,SpaceCoord]]:
        groups: list[list[SpaceCoord]] = []
        length = len(self.boxes)

        def in_group(box: SpaceCoord) -> int|None:
            for i, g in enumerate(groups):
                if box in g:
                    return i
            return None

        for i in count():
            b1, b2 = self.ordered_pairs[i]
            g1 = in_group(b1)
            g2 = in_group(b2)
            match g1, g2:
                case None, None:
                    groups.append([b1, b2])
                case None, int():
                    groups[g2].append(b1)
                case int(), None:
                    groups[g1].append(b2)
                case _:
                    if g2 != g1:
                        groups[g1] += groups[g2]
                        groups.remove(groups[g2])
            if steps and i == steps -1:
                break
            elif len(groups) == 1 and len(groups[0]) == length:
                break
        return ([len(g) for g in groups], (b1, b2)) # pyright: ignore[reportPossiblyUnboundVariable]

    def join_steps(self, steps: int) -> list[int]:
        return sorted(self._join(steps)[0], reverse=True)

    def join_all(self) -> tuple[SpaceCoord,SpaceCoord]:
        return self._join()[1]

def exo1(data: list[str], steps: int) -> int:
    lengths = Junction(data).join_steps(steps)
    return reduce(mul, lengths[:3])

def exo2(data: list[str]) -> int:
    b1, b2 = Junction(data).join_all()
    return b1.x * b2.x

++
Gi)

Rien de bien complique ajd, mais j'ai quand meme perdu un peu de temps sur la premiere partie, faute de tenir compte du fait qu'un splitter devait voir passer un beam pour etre active… Ce qui donne

from typing import Iterable, NamedTuple


class Position(NamedTuple):
    x: int
    y: int


class Manifolder:
    def __init__(self, data: list[str]) -> None:
        self.grid = data
        self.height = len(self.grid)
        self.width = len(self.grid[0])

    def is_divider(self, pos: Position) -> bool:
        return self.grid[pos.y][pos.x] == '^'

    def divisions(self) -> Iterable[int]:
        beams = {self.grid[0].index('S')}
        for y in range(2, self.height, 2):
            splitters = [p for p in map(lambda x: Position(x, y), range(self.width)) if self.is_divider(p) and p.x in beams]
            beams |= {p.x-1 for p in splitters}
            beams |= {p.x+1 for p in splitters}
            beams -= {p.x for p in splitters}
            yield len(splitters)

    def timelines(self) -> int:
        timelines = { i: int(self.grid[0][i] == 'S') for i in range(self.width)}
        for y in range(2, self.height, 2):
            splitters = [p for p in map(lambda x: Position(x, y), range(self.width)) if self.is_divider(p) and p.x in timelines.keys()]
            for s in splitters:
                v = timelines[s.x]
                timelines[s.x] = 0
                timelines[s.x-1] += v
                timelines[s.x+1] += v
        return sum(timelines.values())

def exo1(data: list[str]) -> int:
    return sum(Manifolder(data).divisions())

def exo2(data: list[str]) -> int:
    return Manifolder(data).timelines()

++
Gi)

Hello.

Assez d'accord avec les jugements precedents: pas de difficulte ajd, mais une transformation prealable des donnees pour la partie 2 un peu delicate (la seule fonction a ne pas faire 1 ou 2 lignes).

from __future__ import annotations
from functools import reduce
import operator
import re
from typing import Iterable

RE_OP = re.compile(r'([+*]) +')

class Operation:
    operations = {
        '+': sum,
        '*': lambda l: reduce(operator.mul, l)
    }

    def __init__(self, operator: str, operands: Iterable[int]):
        self.operator = operator
        self.operands = operands

    @classmethod
    def from_data_1(cls, data: tuple[str]) -> Operation:
        return cls(data[-1], map(int, data[:-1]))

    def operate(self) -> int:
        return self.operations[self.operator](self.operands)


def parse_input_1(data: str) -> Iterable[tuple[str]]:
    return zip(*[line.split() for line in data.strip('\n').split('\n')])

def parse_input_2(data: str):
    def to_numbers(lines: list[str]) -> Iterable[int]:
        for i in range(len(lines[0])):
            if n := ''.join([l[i] for l in lines]).replace(' ', ''):
                yield int(n)

    lines = data.strip('\n').split('\n')
    ops = lines[-1]
    lines = lines[:-1]
    for m in RE_OP.finditer(ops):
        yield Operation(m.group(1), to_numbers(list(map(lambda s: s[::-1], map(lambda l: l[m.start():m.end()][::-1], lines)))))

def exo1(data: str) -> int:
    operations = map(Operation.from_data_1, parse_input_1(data))
    return sum(map(lambda o: o.operate(), operations))

def exo2(data: str) -> int:
    operations = parse_input_2(data)
    return sum(map(lambda o: o.operate(), operations))

++
Gi)

Hello

Perso, j'ai trouve l'exercice de ce jour presque plus facile que ceux des jours precedents.
Je me suis bien embourbe un peu a vouloir gerer ca avec des sets, donc le plus long ce fut de kill mon process python pendant que sa conso memoire mettait mon systeme a mal.
Au final, une solution assez similaire aux deux proposees plus haut a ceci pres que:

• plus lourd car decompose en fonctions, dont parse_input et is_fresh qui sont lourdingues

• usage de range plutot que tuple, pas sur que ca fasse une grande difference, si ce n'est que ca deplace la gestion des +1

• un test un poil plus efficace pour l'exo 2 (a <= c ou t[0] <= r[0] sont inutiles, la liste etant triee :p)

Ce qui donne:

def parse_input(data: list[str]) -> tuple[list[range],list[int]]:
    fresh = []
    ingredients = []
    first = True
    for line in data:
        if line:
            if first:
                low, high = map(int, line.split('-'))
                fresh.append(range(low, high+1))
            else:
                ingredients.append(int(line))
        else:
            first = False
    return (fresh, ingredients)

def is_fresh(ingredient: int, known_fresh: list[range]) -> bool:
    for r in known_fresh:
        if ingredient in r:
            return True
    return False

def exo1(data: list[str]) -> int:
    fresh, check = parse_input(data)
    return sum([is_fresh(i, fresh) for i in check])

def exo2(data: list[str]) -> int:
    fresh, _ = parse_input(data)
    fresh.sort(key=lambda r: (r.start, r.stop), reverse=True)
    r = fresh.pop()
    count = 0
    while fresh:
        next_r = fresh.pop()
        if next_r.start > r.stop:
            count += len(r)
            r = next_r
        else:
            r = range(r.start , max([r.stop, next_r.stop]))
    return count + len(r)

++
Gi)

Bien traine encore ajd, un peu sur la partie 1 pour cause de boulette tellement plus grosse que moi que j'ai peine a mettre la main dessus, puis sur la partie 2 quand j'ai realise que du bete parcours de tableau, ca peut etre looooooooooooooooong, ce qui m'a valu de tt refacto.

Au final, mes 2 fonctions:

    def count_reachable_rolls(self) -> int:
        return len(self._reachable_rolls(self.rolls))

    def count_removable_rolls(self) -> int:
        rolls = self.rolls.copy()
        while rem := self._reachable_rolls(rolls):
            rolls -= rem
        return len(self.rolls) - len(rolls)

Et l'integralite ici

Pour Ubuntu, je ne connais pas vraiment, mais il y' a apparemment un ppa qui permet de gerer ca simplement.

Pour Debian, a ma connaissance tu peux utiliser pyenv notamment, ou pour suivre la mode rust uv (au revoir l'enfer des dependances python, bonjour l'enfer des dependances rust :p)

++
Gi)

Hello.

Un peu bataille jour 1, a trop vouloir resoudre mathematiquement pour la partie 2 (alors que mes souvenirs sur le sujet commencent a se faire vieux, comme moi) et j'ai fini par me resoudre au mode bourrin. Un peu traine hier, mais sans difficulte pour autant, et aujourd'hui, en effet rien de complique.
Ma solution partielle (en python), dans la meme veine que les premieres propositions:

    def joltage(self, batteries: int) -> int:
        s = ''
        idx = 0
        for i in range(batteries - 1, -1, -1):
            subi, nc = max([t for t in enumerate(self.batteries[idx:-i if i else None])], key=lambda t: (t[1], -t[0]))
            s += nc
            idx += subi + 1
        return int(s)

Et si je puis me permettre un peu d'auto-promotion, la solution complete ici

++
Gi)

Hello.

J'ai bien aime les defs 5, 7, 10, 16 et 18, simples et efficaces.

J'ai moins aime:
- 24 j'aurais cherche moins bateau (reputee pour sa beauté?)
- 14 probablement parce que j'avais oublie que ca avait existe (quitte a faire dans l'informatique, j'aurais plutot mis: fait du liant sur commande)
- 28V le rapport m'echappe encore

J'ai appris un mot avec la 13

Lachez rien!

++
Gi)

Un peu depite d'avoir loupe la def originale pour la 24, j'aime bien l'humour grincant… tant pis pour moi.
Sinon, reste encore une petite coquille: def 13, il manque un T, non?

++
Gi)

Reponse a moi-meme: me suis plante lamentablement, c'est le numero 4 que je visais!

Hello.

2 erreurs se sont glissees dans la grille:
- defs 19 et 20: c'aurait du etre une seule et meme def pour une solution en 2 mots
- defs 16 et 17: coquille, ou modification de la grille en derniere minute et oubli d'adaptation des defs?

Pour le coup, ca m'a donne un peu de fil a retordre.

Je critique, je critique… mais j'insiste encore sur le fait que c'est quand meme de la belle ouvrage (autrement dit pour les auteurs, pas de honte a avoir) !

++
Gi)

En effet ^{^}

Faut pas avoir honte: elles sont vraiment pas si pires ces grilles.

Petite question de curiosite: production personnelle ou collegiale?

Pfiou, je peine moi-meme a me relire!

Le grand classique des mots croises c'est le 27!

Hello,

Pour le 7, c'est un grand classique des mots croises, tu risques de le retrouver souvent si tu prends gout au jeu.
Personnellement, c'est sur le 7 que j'ai peine! Et pourtant, une fois trouve, ca tombe sous le sens (jolie definition, de fait!).
Et pour le procede douteux, n'est pas Scipion qui veut, d'ailleurs lui-meme pouvait parfois recourir a tel artifice.

Mon avis personnel: grille moins equilibree que la precedente (plus on voit grand, plus c'est delicat), mais definitions globalement plus travaillees. Ca fait plaisir de voir le progres du Lama dans l'exercice depuis ses debuts.

++
Gi)

En toute sincerite, je la trouve plutot bien cette grille :)

Hello.

Y'a 2 defs (8 et 12) qui m'ont completement laisse perplexe, meme avec la solution sous les yeux.
Par contre, mention TB pour la palme… on la lui decernerait.

++
Gi)

En guise de vagues, on est proche du tsunami dans le bassin d'Arcachon!

Mais trèves de billevesées. Si j'ai tout bien lu, les lignes et entre, le consensus semble plutôt s'établir autour du statu quo: les choses sont bien comme elles sont et les vaches seront bien gardées. Ca me va aussi.

++
Gi)

C'est cornelien. Etant grenoblois, je serais presque tente de me "devouer" pour te debarrasser, mais je redoute tant, le cas echeant, de me retrouver au final avec un gros bouzin qui prend la poussiere inutilement, que je vais passer mon tour.

Bravo toutefois pour l'initiative.

++
Gi)