🚲 Tanguy Ortolo a écrit 12507 commentaires

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é.

Voilà, avec une implémentation des unions d'intervalles sécants.

from __future__ import annotations

import re

from collections import namedtuple
from typing import Tuple, Iterable, List, Optional, Type

import aoc


Coords = Tuple[int, int]


class Point(namedtuple('Point', ['x', 'y'])):
    __slots__ = ()

    def __str__(self) -> str:
        return "({},{})".format(self.x, self.y)

    def dist(self, other: Point) -> int:
        return abs(self.x - other.x) + abs(self.y - other.y)


class Interval:
    def __init__(self, start: int, end: int) -> None:
        if start >= end:
            raise ValueError("unsupported empty or negative interval")
        self.start = start
        self.end = end

    def __str__(self) -> str:
        return "[{},{}[".format(self.start, self.end)

    def __len__(self) -> int:
        return self.end - self.start

    def __contains__(self, value: int) -> bool:
        return value >= self.start and value < self.end

    def intersects(self, other: Interval) -> bool:
        return max(self.start, other.start) < min(self.end, other.end)

    def union_update(self, other: Interval) -> bool:
        if not self.intersects(other):
            return False
        self.start = min(self.start, other.start)
        self.end = max(self.end, other.end)
        return True


class Sensor:
    def __init__(self, position: Point, beacon: Point):
        self.position = position
        self.beacon = beacon
        self.range = position.dist(beacon)

    def covers(self, y: int) -> bool:
        dist = abs(y - self.position.y)
        return dist <= self.range

    def coverage(self, y: int) -> Optional[Interval]:
        if not self.covers(y):
            return None
        else:
            dist = abs(y - self.position.y)
            return Interval(self.position.x - self.range + dist,
                            self.position.x + self.range + 1 - dist)

    re_line = re.compile(r'^Sensor at x=(-?\d+), y=(-?\d+): '
                         + r'closest beacon is at x=(-?\d+), y=(-?\d+)\n?$')

    @classmethod
    def import_line(class_, line: str) -> Sensor:
        match = class_.re_line.match(line)
        if match is None:
            raise ValueError("invalid sensor description")
        position = Point(int(match.group(1)), int(match.group(2)))
        beacon = Point(int(match.group(3)), int(match.group(4)))
        return class_(position, beacon)


class SensorArray:
    def __init__(self, sensors: Iterable[Sensor]):
        self.sensors = list(sensors)

    @classmethod
    def import_lines(class_, lines: Iterable[str]) -> SensorArray:
        return class_(Sensor.import_line(line) for line in lines)

    def coverage(self, y: int) -> List[Interval]:
        intervals: List[Interval] = []
        for sensor in self.sensors:
            if not sensor.covers(y):
                continue
            new_interval = sensor.coverage(y)
            if new_interval is None:
                continue
            new_intervals: List[Interval] = []
            for interval in intervals:
                if not new_interval.union_update(interval):
                    # new_interval did not absorb interval
                    new_intervals.append(interval)
            new_intervals.append(new_interval)
            intervals = new_intervals
        return intervals


def solve1(lines: Iterable[str]) -> int:
    """Solve part 1 of today's puzzle"""
    array = SensorArray.import_lines(lines)
    beacons = {sensor.beacon for sensor in array.sensors}
    y = 2000000
    coverage = array.coverage(y)
    total = 0
    for interval in coverage:
        total += len(interval)
        total -= sum((beacon.y == y and beacon.x in interval)
                     for beacon in beacons)
    return total


def solve2(lines: Iterable[str]) -> int:
    """Solve part 2 of today's puzzle"""
    array = SensorArray.import_lines(lines)
    position: Optional[Point] = None
    for y in range(4000000):
        if y % 100000 == 0:
            print(y)
        coverage = array.coverage(y)
        if len(coverage) < 2:
            continue
        return min(interval.end for interval in coverage) * 4000000 + y
    raise ValueError("no solution found")

Un détail tout de même, ça semble évident mais ça peut demander un peu de concentration pour ne pas l'oublier en court de route : tant que vous n'êtes pas arrivé à vos fins, c'est à dire que vous n'avez pas assez d'informations, il ne faut pas donner le moindre indice qui laisserait soupçonner que vous n'appréciez pas ce démarchage.

Éviter par exemple des phrases comme « Au fait, comment avez-vous eu mon numéro de téléphone ? » Si votre interlocuteur commence à soupçonner que son appel vous dérange, il risque de ne pas vous croire si vous vous prétendez intéressé, et l'appel ne durera pas longtemps. Pas assez longtemps pour obtenir les infos que vous souhaitez en tout cas.

Ces démarcheurs savent très bien que ce qu'ils font est illégal, même s'ils prétendent parfois le contraire. Et sachant qu'ils peuvent être poursuivis, ou avoir diverses emmerdes comme être radiés de la plate-forme CPF, ils commencent à être assez méfiants.

L'autre jour, j'ai oublié ce principe et demandé directement à une démarcheuse où elle travaillait. Elle m'a fait répéter la question, et après avoir compris ma demande, elle a raccroché sans y mettre la moindre forme. Ni refus, ni excuse, ni au-revoir, juste raccroché. Si ce n'est pas de la méfiance, ça…

À titre d'exemple, j'ai pu piéger une entreprise de formation professionnelle qui se livrait au démarchage téléphonique. Sans doute sous-traité, mais ce n'est pas mon problème, les agissements d'un sous-traitant engagent évidemment la responsabilité de son donneur d'ordre.

Je me suis montré intéressé par une formation en langue anglaise, très utile pour mon travail. Le démarcheur m'a alors fait rappeler par un responsable des inscriptions, et je m'attendais au pire, c'est à dire à ce qu'il me demande mon numéro de sécurité sociale et qu'il réinitialise avec mon aide mon mot de passe pour accéder lui-même à mon compte CPF et m'inscrire à sa formation. Ç'aurait été une arnaque selon les règles, mais non, c'était un peu plus honnête, il m'a juste demandé mon adresse électronique, celle inscrite sur le compte CPF, ce qui lui a suffit à me pré-inscrire à des formations.

Vérification faite, les formations apparaissaient bien comme des propositions à valider, avec un organisme de formation tout à fait identifiable, en tout cas par la plate-forme CPF. J'en avais assez, et la fin de la discussion téléphonique a été assez intéressante :

• C'est bon, je vois bien les formations. Je vous remercie, j'ai toutes les informations qu'il me faut.
• Attendez, je peux vous expliquer la façon dont les formations vont se passer.
• Ce ne sera pas nécessaire, vraiment, j'ai tout ce qu'il me faut.
• Non, je ne vous ai pas expliqué…
• Si si, j'en sais assez je vous dit.
• Assez pour quoi ?
• Assez pour signaler votre démarchage illicite.
• Vous n'étiez pas intéressé par la formation ?
• Non, désolé, j'avais juste besoin d'informations pour le signalement.
• Vous nous avez tendu un piège alors ?
• 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.