🚲 Tanguy Ortolo a écrit 12285 commentaires

En particulier, même pour les gens qui font attention, le dernier item devient incontournable après 5 ou 6 ans, puisque tu vas récupérer gratuitement les téléphones de ton entourage, plus performants que le tien, qui autrement iraient à la poubelle.

Et dont tu vas devoir changer la batterie, à mon avis le point le plus important.

Pouvoir changer l'écran, c'est bien, mais c'est cher et ça ne s'use pas vraiment naturellement, ça se casse en faisant tomber le téléphone. Dommage. Mais la batterie, ça s'use vraiment pour le coup, et pouvoir la changer sans effort n'est pas un luxe, c'est juste la base. L'écran, à côté, c'est secondaire.

Si au bout de 10 ans tu as remplacé toutes les parties de ton téléphone, c'est pareil que d'avoir acheté un nouveau smartphone (voire pire, puisqu'il n'y a eu aucune économie d'échelle sur le transport, le stockage, l'emballage des pièces, etc., et que les coûts écologiques du marché des pièces détachées ne sont pas petits (comme la surproduction des pièces de rechange qui peuvent partir à la déchetterie par cartons entier à la fin de la vie du produit).

Tu fais pareil avec ta bicyclette ? Ce n'est pas un exemple anodin, la bicyclette est à mon avis le meilleur exemple actuel de machine parfaitement réparable pièce par pièce. Perso, quand j'ai une pièce usée ou cassée, je ne change que ça, pas le vélo entier. Au bout de dix ans, j'ai presque tout remplacé :
- cintre (bon, pas parce qu'il était usé mais parce que je n'aimais pas sa forme),
- roues,
- pneus (plusieurs fois),
- chaîne (plusieurs fois), pignons (plusieurs fois) et plateaux,
- galets de dérailleur,
- pédales,
- câbles et gaines de dérailleur et de frein,
- leviers de dérailleur et de frein,
- patins de frein,
- sonnette et feux (bon, seulement parce que j'ai trouvé plus performant que ceux d'origine),
- selle,
- porte-bagage,
- garde-boues.

Il ne reste d'origine que le cadre, les manivelles, les dérailleurs, le moyeu-dynamo de roue avant, la fourche, la tige et le chariot de selle, si je ne m'abuse. Les pièces détachées ne sont pas spécialement données, donc ces remplacements successifs m'ont sans aucun doute coûté plus cher que le vélo neuf, pourtant je ne regrette pas d'avoir procédé ainsi. Et j'aimerais pouvoir faire de même avec mon téléphone.

C'est amusant, l'AoC regorge d'exemples de choses qui sont évidentes pour un humain, mais assez ou très difficiles à mettre en algorithme, qui sera d'ailleurs fort différent de la pensée humaine.

Deux beaux exemples cette année :

• Comment trouver les trous dans une pierre ponce (ou un emmental, ou une éponge) ? Facile, ça se voit ! Et en algorithme ? Euh, inondation depuis l'extérieur, ça ne remplit pas les trous, qu'on peut déterminer ensuite par différence, par exemple.
• Comment relier et orienter les faces d'un patron de cube ? Facile, on découpe et on plie ! Et comme algorithme ? Euh, c'est compliqué !

Bon, aucun problème pour la première partie, en revanche pour la seconde, j'y renonce… pour le moment.

L'intérêt de Avent du Code est entre autres, pour moi, dans la satisfaction d'avoir implémenté des algorithmes originaux, astucieux, élégants, etc. Dans ce cas, en particulier, coder en dur la disposition particulière de mes données d'entrée serait très insatisfaisant. Quant à coder un algorithme qui implémente la modélisation des faces d'un cube à partir d'un patron arbitraire, je n'ai trouvé pour cela aucun moyen qui ne soit pas très, très fastidieux à écrire.

Donc, pour le moment, je laisse tomber. J'y reviendrai peut-être plus tard dans l'année.

On limite le nombre de robot de chaque type au coût maximal d'un robot pour ce type de ressources.

Ce n'est pas empirique ça, c'est prouvable. Comme on ne peut construire qu'un robot par tour, récolter plus d'unités de n'importe quelle ressource que la quantité qu'on peut en dépenser ne sert à rien.

Bon, fait maison, c'est à dire sans eval ni bibliothèque externe. On construit un arbre, pour la première partie on calcule récursivement la valeur du singe racine. Pour la deuxième partie, on force la valeur du singe racine, ce qui force récursivement la valeur des singes en-dessous, jusqu'à forcer la valeur de l'humain.

from __future__ import annotations

import re

from collections import defaultdict
from enum import Enum
from typing import Callable, Dict, Iterable, Optional, Sequence, Set, Tuple


class Operation(Enum):
    ADD = '+'
    SUB = '-'
    MUL = '*'
    DIV = '/'

    @property
    def op(self) -> Callable[[int, int], int]:
        if self is self.ADD:
            return int.__add__
        if self is self.SUB:
            return int.__sub__
        if self is self.MUL:
            return int.__mul__
        if self is self.DIV:
            return int.__floordiv__
        assert False  # we covered all cases

    @property
    def rev1(self) -> Callable[[int, int], int]:
        """Given a and b, return x so self.op(x, a) = b"""
        if self is self.ADD:
            return int.__sub__
        if self is self.SUB:
            return int.__add__
        if self is self.MUL:
            return int.__floordiv__
        if self is self.DIV:
            return int.__mul__
        assert False  # we covered all cases

    @property
    def rev2(self) -> Callable[[int, int], int]:
        """Given a and b, return x so self.op(a, x) = b"""
        if self is self.ADD:
            return int.__sub__
        if self is self.SUB:
            return lambda v, a: a - v
        if self is self.MUL:
            return int.__floordiv__
        if self is self.DIV:
            return lambda v, a: a // v
        assert False  # we covered all cases


class Monkey:
    monkeys: Dict[str, Monkey] = {}

    def __init__(self, name: str,
                 value: Optional[int] = None,
                 others: Optional[Sequence[str]] = None,
                 operation: Optional[Operation] = None) -> None:
        if (others is None) != (operation is None):
            raise ValueError(
                    "others and operation must be both None or both defined")
        if (value is None) == (others is None):
            raise ValueError(
                    "value xor (others and operation) must be defined")
        self.name = name
        self._value = value
        self.others = others
        self.operation = operation
        # Register self in class directory
        self.monkeys[name] = self

    @property
    def value(self) -> int:
        if self._value is not None:
            return self._value
        if self.others is None or self.operation is None:
            raise ValueError(
                    "cannot compute value of a monkey w/o others or operation")
        return self.operation.op(
                *[self.monkeys[other].value for other in self.others])

    @value.setter
    def value(self, v: int) -> None:
        if self._value is not None:
            # This monkey has a fixed value
            raise ValueError("cannot change value of a valued monkey")
        if self.others is None or self.operation is None:
            # This monkey has a free value, we just have to set it
            self._value = v
            return
        # The free monkey is somewhere under self
        a: Optional[int] = None  # value of first sub-monkey
        b: Optional[int] = None  # value of second sub-monkey
        try:
            a = self.monkeys[self.others[0]].value
        except ValueError:
            # This failed because the value-free monkey is here, not a problem
            pass
        try:
            b = self.monkeys[self.others[1]].value
        except ValueError:
            # This failed because the value-free monkey is here, not a problem
            pass
        if a is None and b is not None:
            a = self.operation.rev1(v, b)
            self.monkeys[self.others[0]].value = a
            return
        if a is not None and b is None:
            b = self.operation.rev2(v, a)
            self.monkeys[self.others[1]].value = b
            return
        # We do not expect to have two or no value-free monkey under us
        assert False

    _monkey_re = re.compile(r"^(\w+): (.*)\n?$")
    _operation_re = re.compile(r"^(\w+) ([-+/*]) (\w+)\n?$")

    @classmethod
    def import_line(class_, line: str) -> Monkey:
        match = class_._monkey_re.match(line)
        if match is None:
            raise ValueError("invalid monkey description '{}'".format(line))
        name = match.group(1)
        line = match.group(2)
        if line.isdigit():
            value = int(line)
            return class_(name, value=value)
        match = class_._operation_re.match(line)
        if match is None:
            raise ValueError("invalid monkey operation '{}'".format(line))
        others = (match.group(1), match.group(3))
        op = Operation(match.group(2))
        return class_(name, others=others, operation=op)


def solve_both(lines: Iterable[str]) -> Tuple[int, int]:
    """Solve both parts of today's puzzle"""
    for line in lines:
        _ = Monkey.import_line(line)
    root = Monkey.monkeys['root']
    humn = Monkey.monkeys['humn']
    # Get original root monkey value
    result1 = root.value
    # Correct root monkey operation
    root.operation = Operation.SUB
    # Unset our own value so it becomes the free one
    humn._value = None
    # Force root monkey value: this will cascade to eventually set
    # our value
    root.value = 0
    result2 = humn.value
    return result1, result2

a) Tu n'as en rien la maitrise de ton système. Tu crois l'avoir, cela s'arrète là

À ce compte-là, personne ne maîtrise rien. Sérieusement, je pense qu'un utilisateur averti d'un système libre maîtrise justement beaucoup mieux ce qui se passe sur son ordinateur, que l'entreprise ne maîtrise ce qui se passe sur ses ordinateurs.

Joli, du coup j'ai honte de montrer ma solution avec liste chaînée maison. Mais je la montre quand même, allez :

from __future__ import annotations

import io

from typing import Iterable, Iterator, Optional


class Chain:
    def __init__(self, *elts: Element) -> None:
        self._len = len(elts)
        self.first = elts[0]
        last = elts[-1]
        prev: Optional[Element] = None
        for elt in elts:
            if prev is not None:
                prev.attach(elt)
            prev = elt
        last.attach(self.first)

    def __len__(self):
        return self._len

    def __getitem__(self, index: int) -> Element:
        index = index % len(self)
        current = self.first
        for _ in range(index):
            current = current.next
        return current

    def get_elt(self, base_elt: Element, index: int) -> Element:
        index = index % len(self)
        current = base_elt
        for _ in range(index):
            current = current.next
        return current

    def __iter__(self) -> Iterator[Element]:
        current = self.first
        for _ in range(self._len):
            yield current
            current = current.next

    def extract(self, index: int) -> Element:
        elt = self[index]
        elt.detach()
        self._len -= 1
        return elt

    def extract_elt(self, elt: Element) -> None:
        # WARNING: not checking that elt is part of self
        elt.detach()
        self._len -= 1

    def insert(self, index: int, elt: Element) -> None:
        prev = self[index]
        next_ = prev.next
        # Attach (prev and elt) and (elt and next_)
        prev.attach(elt)
        elt.attach(next_)
        self._len += 1

    def insert_elt(self, base: Element,
                   shift: int, elt: Element) -> None:
        # WARNING: not checking that elt is part of self
        shift %= self._len
        prev = base
        for _ in range(shift):
            prev = prev.next
        next_ = prev.next
        # Attach (prev and elt) and (elt and next_)
        prev.attach(elt)
        elt.attach(next_)
        self._len += 1

    def __str__(self):
        result = io.StringIO()
        result.write('(')
        for elt in self:
            result.write('{}, '.format(elt.value))
        result.write(')')
        return result.getvalue()


class Element:
    def __init__(self, value: int) -> None:
        self.value = value
        self.prev = self
        self.next = self

    def attach(self, other: Element) -> None:
        self.next = other
        other.prev = self

    def detach(self) -> None:
        prev = self.prev
        next_ = self.next
        # Detach self
        self.prev = self
        self.next_ = self
        # Attach prev and next_
        prev.attach(next_)


def solve1(lines: Iterable[str]) -> int:
    """Solve part 1 of today's puzzle"""
    elts = [Element(int(line)) for line in lines]
    seq = Chain(*elts)
    zero: Optional[elt] = None
    for elt in elts:
        if zero is None and elt.value == 0:
            zero = elt
        prev = elt.prev
        seq.extract_elt(elt)
        seq.insert_elt(prev, elt.value, elt)
    if zero is None:
        raise ValueError("invalid input without a zero value")
    return (seq.get_elt(zero, 1000).value
            + seq.get_elt(zero, 2000).value
            + seq.get_elt(zero, 3000).value)


def solve2(lines: Iterable[str]) -> int:
    """Solve part 2 of today's puzzle"""
    key = 811589153
    elts = [Element(key * int(line)) for line in lines]
    seq = Chain(*elts)
    zero: Optional[elt] = None
    for _ in range(10):
        for elt in elts:
            if zero is None and elt.value == 0:
                zero = elt
            prev = elt.prev
            seq.extract_elt(elt)
            seq.insert_elt(prev, elt.value, elt)
    if zero is None:
        raise ValueError("invalid input without a zero value")
    return (seq.get_elt(zero, 1000).value
            + seq.get_elt(zero, 2000).value
            + seq.get_elt(zero, 3000).value)

À noter que c'est pas mal plus lent qu'avec des listes Python en fait… :-(

Au temps pour moi, il me semblait que l'utilisation de la marque Android pour décrire un système d'exploitation impliquait d'y inclure des trucs comme les Google Play Services, mais en fait non.

LineageOS et compagnie sont bien des sytèmes Android, et il serait faux de prétendre que l'Identité Numérique La Poste fonctionne bien « sous Android ». Ça fonctionne sous certaines distributions Android répondant à leurs critères, pour le reste on doit bidouiller.

Je n'ai pas encore commencé, mais vu l'énoncé de la première partie, je dirais que l'incrément de hauteur doit se répéter au bout du PPCM du nombre de formes et du nombre de d'instructions de direction du vent.

Avec la première série de tant de blocs qui doit monter un petit peu plus haut puisqu'elle est posée sur un sol plat et non sur une tour qui sommet irrégulier.

Bon, alors effectivement, mon titre était un peu trompeur : ce n'est pas le démarcheur lui-même que je cherche à piéger, mais son commanditaire en fait.

La boîte de rénovation qui me fait appeler a bien une existence en France, et si je peux contribuer à les mettre en difficulté, ce sera toujours une bonne action de faite, au profit de leurs concurrents plus honnêtes. Pareil pour les boîtes de formation professionnelle.

En fait, quand on se montre intéressé, on nous passe rapidement quelqu'un qui n'est plus un démarcheur mais un conseiller de la boîte malhonnête.

En tout cas, des boulots dans des secteurs qui recrutent, ça n'est pas difficile à trouver : employé dans la restauration, aide-soignante, infirmière, conducteur d'autobus ou de train…

Certains demandent de la formation, mais la pénurie de main d'œuvre est telle que les employeurs peuvent aller jusqu'à la prendre en charge.

Ce sont des métiers contraignants, mais aujourd'hui, pour travailler à faire des trucs pénibles, nuisibles et illicites à longueur de journée, il faut le vouloir.

Pour tous ces logiciels, c'est assez paradoxal, mais le meilleur moyen de les faire fonctionner dans qu'ils détectent que votre téléphone utilise un système non Android, c'est de le rooter avec Magisk, d'activer Zygisk, d'installer Universal SafetuNet Fix et de les ajouter à la liste d'exclusion.

Avec un peu d'explication :
- Magisk, c'est un /bin/su et des possibilités techniques de changer des tas de trucs à ce que vient les logiciels qu'on lance ;
- Zygisk, c'est une option de Magisk, plus liée à l'intérieur des processus applicatifs eux-mêmes si j'ai bien compris, et c'est nécessaire pour…
- Universal SafetyNet Fix (USF), in module Magisk qui permet de passer la validation SafetyNet malgré un système non Android et rooté ;
- la liste d'exclusion, c'est un réglage de Magisk, qui indique à quels logiciels la présence de /bin/su doit être masquée, et qui est aussi utilisée par USF.

Bilan tout de même, grâce à ces contraintes de « sécurité », pour utiliser ces logiciels, on passe d'un système normal mais juste pas Android, à un système rooté et bidouillé pour mentir à gogo… On n'arrête pas le progrès.

Un peu désolé, ou pas en fait. Des boulots de merde, il y en a d'autres aussi, qui ont l'avantage de ne pas considérer à commettre des infractions en série.

À un moment il faut donner un numéro de téléphone, mais ça ne change rien si c'est celui de quelqu'un d'autre.

Tiens, je n'avais pas pensé à Pypy. Pour info, ma solution termine la seconde partie – ligne par ligne, avec calcul d'unions d'intervalles – en 2,7 s sous Pypy.

J'y ai réfléchi cette nuit, on peut faire encore mieux. Premièrement parce qu'il n'est pas vraiment nécessaire de considérer les intersections de droites, mais seulement celles des segments qui délimitent les zones de chaque capteur (enfin, les segments juste un point plus loin en fait).

Mais surtout parce que le point cherché est soit :

• dans un coin du terrain et sur un segment ;
• sur un bord du terrain et à l'intersection de deux segments ;
• n'importe où ailleurs, mais à l'intersection de quatre segments.

Bref, in n'a plus qu'à tester si un coin ne se trouverait pas sur un segment, et sinon, si on construit la liste des intersections, on n'a plus qu'à chercher si on ne trouve pas dedans :

• un point qui serait sur un bord ;
• un point qui s'y trouverait quatre fois.

Je ne réponds pas à un numéro qui n'est pas dans mon annuaire perso (même si c'est un livreur, un commerçant ou un artisan qui m'appelle pour un truc important, figurez-vous qu'il va me laisser un mot sur le répondeur !!! dingue non ?)

Quand on a une messagerie vocale, oui. J'ai volontairement désactivé la mienne, et les fournisseurs divers risqueraient de moyennement apprécier le fait que je leur demande de laisser un SMS sans possibilité de laisser un message vocal…

Ça, c'est bien quand on supporte les messages vocaux. Personnellement, je déteste ça, et après des années d'hésitation, j'ai finalement désactivé ma messagerie vocale. J'ai juste un message d'absence qui invite à laisser un SMS. Le genre de truc qu'un démarcheur ne fera jamais depuis son poste fixe d'ailleurs.

Il me semble que c'est un brin plus nuancé. Je ne suis pas certain qu'il soit illégal d'enregistrer un appel qu'on reçoit dans le consentement de l'interlocuteur. Mais même si ça l'était, s'il ne l'apprend jamais il ne pourra pas s'en plaindre, en attendant c'est bien pratique pour vérifier le nom qu'à donné le démarcheur par exemple.

Rendre public cet enregistrement, ça pourrait peut-être bien être risqué en revanche. Et ça pourrait bien ne pas être recevable comme preuve en effet.

Farpaitement !

Et j'y ai aussi découvert les dataclasses. Très pratique ça, avec en plus l'option congélateur, ça va me simplifier la vie la prochaine fois que j'aurai affaire à des coordonnées.

Euh, ça dépend lesquels. J'ai affaire à une boîte particulièrement coriace, leur nom, en tout cas le nom qu'ils prétendent avoir, est en deux mots, ça commence par Habitat et ça finit par Fermeture. Reçu peut-être une dizaine d'appels, genre un par mois depuis un an. Ils sont ma prochaine cible.

Je viens de tomber sur une solution que je trouve assez géniale : https://github.com/JakubDotPy/aoc2022/blob/master/day15/part2.py

La solution sera forcément à une intersection de frontières de zones couvertes par les capteurs. Bon, pas forcément, elle pourrait être dans un coin, mais c'est plus que douteux. On pourrait quand même tester.

Bref, entre les intersections et les quatre coins de la grille, il n'est pas difficile de vérifier si l'un de ces points ne serait pas par hasard hors de portée de tous les capteurs…

Comment prouver qu'il y eu démarchage abusif ?

Plusieurs possibilités :

• Je suis sur Bloctel. Ce n'était pas un de mes fournisseurs, ni une association, ni un journal. L'appel était donc forcément abusif.
• C'est pour vendre une formation CPF : ce genre de démarchage est interdit tout court, donc forcément abusif.
• C'est pour vendre de la rénovation énergétique : ce genre de démarchage est interdit tout court, donc forcément abusif.

Pour ce qui est de prouver que j'ai été appelé, lorsque je fais un signalement, je laisse mes coordonnées, donc au besoin je peux fournir mon journal d'appels et un enregistrement de la conversation.

Et si la DGCCRF décide de lancer des poursuites, ils demanderont à la police ou à la gendarmerie d'enquêter, et mon opérateur pourra sans problème confirmer que j'ai bien reçu l'appel en question.

C'était quand? On en parlait récemment après un article; et après une recherche rapide, j'ai pu confirmer qu'il y a une loi qui interdit tout démarchage pour une formation CPF, adoptée ce 8 décembre, avec 375 000 euros d'amende pour une personne morale (donc l'organisme de formation, mais aussi le sous-traitant? Ou l'un d'eux paye pour les 2? Ou ils partagent l'amende?).

Peut-être les deux. Mais pour répondre à la question, c'était avant cette loi, dont je ne pouvais pas me prévaloir. Sauf que je suis sur Bloctel, donc sauf quelques domaines bien précis dont la formation professionnelle ne fait pas partie, il est de toute façon interdit de me démarcher pour me vendre des trucs.

Vu la réaction du type que j'avais en face, ils avaient l'air plutôt conscients d'être hors-la-loi, ce qui suggère qu'ils l'étaient bel et bien. D'ailleurs ça me rappelle un peu mieux la fin du dialogue. Je n'avais pas raccroché aussi sec :

• Vous n'étiez pas intéressé par la formation ?
• Non, désolé, j'avais juste besoin d'informations pour le signalement.
• Pour signaler quoi ?
• Eh bien, votre appel illégal.
• Mais ça n'a rien d'illégal Monsieur !
• Dites, vous avez entendu parler de Bloctel ?
• Oui, bien sûr, et nous vérifions les gens que nous appelons.
• Ben non. J'y suis, sur Bloctel justement, donc vous n'aviez pas le droit de m'appeler.
• Mais si notre appel vous dérangeait, vous n'aviez qu'à dire que vous n'étiez pas intéressé. Pourquoi avez-vous fait croire que ça vous intéressait, vous nous avez tendu un piège ?
• C'est ça. Ça vous a plu ?
• Mais c'est dégueulasse ce que vous faites !
• Ah non, moi j'aide à faire respecter la loi. Ce que vous faites en revanche, c'est illégal. Si j'ai besoin d'une formation, je suis assez grand pour aller la chercher tout seul. Allez, bonne journée.

Si ce n'est pas en vigueur, quelle est la base pour dire que c'est illicite? C'est parce que tu es sur Bloctel (le cas "automatiquement illicite" que tu cites)? Parce qu'hormis cela, il faudrait par exemple prouver qu'ils ont eu ton numéro de manière illicite (c'est à dire qu'un organisme leur a donné alors que tu avais explicité refusé, ou simplement rien accepté; mais comment prouver cela?).

Bloctel en effet. Mais pour aller plus loin, lorsqu'on fait l'objet d'un traitement de données, et le démarchage téléphonique inclut évidemment un traitement de données, au minimum les numéros de téléphone, on a le droit d'accéder à ces données, qui doivent inclure leur origine. Une boîte qui refuse de fournir les données qu'elle a sur celui qui le demande, ou qui refuse de préciser d'où ils les tiennent, est déjà en violation de la loi.

Sinon similairement à ǝpɐןƃu∀ nǝıɥʇʇɐW-ǝɹɹǝıԀ plus bas, il y a aussi la question de savoir s'ils auront vraiment une amende. Ils pourraient se retourner en disant qu'ils n'ont jamais appelé (c'est alors une parole contre une autre). Pour vérifier les dires, il faudrait qu'un juge acte pour avoir accès aux appels téléphoniques, mais le feraient-ils sur le signalement d'une personne seulement (je doute malheureusement que beaucoup signalent et au final, chaque organisme a probablement un ou 2 signalements à peine à leur actif)?

Alors pour la preuve, j'ai mon journal d'appel, et au besoin un enregistrement de la conversation. Ah oui, j'oubliais de le préciser, j'enregistre. Sans le dire, sinon ils raccrochent direct, donc c'est un peu limite comme preuve, mais la jurisprudence évolue un peu sur le sujet.

Pour les plaintes à propos de démarchage au CPF, ça peut aussi se faire directement sur cette plate-forme, et je suppose qu'ils en tiennent un peu compte quand même, vu le niveau d'arnaques qu'il y a eu. Mais autrement, c'est vrai, je n'ai aucune certitude que ce sera suivi d'effets. La seule certitude que j'ai, c'est que si personne ne signale les abus, ils ne seront jamais sanctionnés.

J'ai un dernier cas: des fois, on reçoit des appels et quand on répond, il n'y a rien. Personne parle. Ça m'arrive de temps en temps. Mais je ne saurais pas classer cela.

Ça vient de robots d'appels. Le principe, c'est que la boîte de démarchage a un vrai centre d'appel dédié à cela, et un robot qui appelle des gens à un rythme calculé selon la disponibilité des esclaves employés. Lorsque quelqu'un répond, il lui passe le premier troufion disponible, mais parfois il n'y en a pas, et l'appelé se retrouve en attente.

Il va sans dire que je ne suis pas pleinement satisfait de la recherche en semi-force brute pour la deuxième étape, intellectuellement parlant.

Mais bon, la flemme de concevoir et d'implémenter un algorithme d'union de parallélogrammes. Il y a des tas de cas, et autant avec des rectangles ça se fait bien en itérant sur chaque coordonnée, autant avec les parallélogrammes, c'est compliqué.