syj a écrit 630 commentaires

C'est null. D'un point de vue niveau, c'est digne des premiers jours.

Dans l'ensemble, l'ensemble les exos sont beaucoup plus simple que les autres années.

Hormis le 21, je n'ai eu aucune difficultés. Et encore, c'est de ma faute. Je me suis bloqué sur une mauvaise piste.

Je regrette qu'il n'y a eu aucun exercice avec de la 3D du niveau du 24 de 2023 ou du niveau 22 de 2021.
Pareil, on n'a pas eu de traditionnel problème de séquence de motif sur un plan 2D …
Aucun problème de plan infini.

Pour la partie 1, il suffit de suivre les instructions et valider les TU.

Pour la partie 2, je pense que je n'ai pas choisie la solution la plus rapide. Je mets environ 1min pour trouver la solution.

Je fais une fonction recursive qui va descendre à une profondeur de 44.

En gros, je vais valider l'addition de 2 entiers en commençant par les bits de poids faible jusqu'au bit de poids fort.
Quand j'identifie une erreur j'applique une permutation de sortie.

Pour valider, l'addition de 2 entiers, je ne considère pas tous les entiers 2^44. çà serait trop long.
Je construits des additions particulières en binaires qui vont valider toutes les retenus à la profondeur ou je suis. A chaque addition , je valide la commutativité de mon addition.
Par exemple , à la profondeur 3
1
1

1
11

1
111

Mais je vais aussi valider le merge de nombre binaire sans retenu et je vérifie encore la commutativité.
1
0

10
101

---

Bien paramétré cette fonction de validation a été déterminant car c'est elle qui garantit qu'au fur et à mesure de l'exploration des combinatoire possible , je n'engendre pas de régression dans les chiffres et çà me permet de déterminer rapidement une impasse dans le choix de la permutation

L'autre point important, c'est quand on détecte une anomalie, je vais déterminer les bits concernés et en déduire les portes éligibles à la permutation.
çà limite mon exploration.

    public static long wrongBit(long expected , long result) {
        return (expected ^ result);
    }

    public static long isOk(long current) {
        report.start("isOk");
        long wrong = 0;
        long mask = current;

        long x = 0;
        long r ;
        while(current > 0) {
            long expectedAddOne = 1l + current;         
            r = evaluateNetwork(1l, current);
            if(r < 0) {
                return -1;
            }
            wrong = wrong | wrongBit(expectedAddOne, r);
            r = evaluateNetwork( current, 1l);
            if(r < 0) {
                return -1;
            }
            wrong = wrong | wrongBit(expectedAddOne, r);
            r = evaluateNetwork( current, 0l);
            if(r < 0) {
                return -1;
            }
            wrong = wrong | wrongBit(current, r);

            r = evaluateNetwork( 0l, current);
            if(r < 0) {
                return -1;
            }
            wrong = wrong | wrongBit(current, r);

            long a = 1l << x;
            long b = mask - a;
            r = evaluateNetwork( a, b);
            if(r < 0) {
                return -1;
            }
            wrong = wrong | wrongBit(mask, r);

            r = evaluateNetwork( b, a);
            if(r < 0) {
                return -1;
            }
            wrong = wrong | wrongBit(mask, r);

            current = current >> 1l;
            x++;
        }

        report.end("isOk");
        return mask & wrong;



    }



    private static void recurseFixGates(Set<String> validated, int x) {

        if(x > maxDepth) {
            System.out.println(x + " " + validated.size() );
            maxDepth = x;
        }
        if(validated.size() % 2 == 1) {
            System.out.println("Whats");
        }
        if (x == 44) {      

            if(validate()) {                        
                String resultsAsString = validated.stream().sorted().collect(Collectors.joining(","));
                if (!availablesResults.contains(resultsAsString)) {
                    availablesResults.add(resultsAsString);
                    System.out.println(resultsAsString);
                }
                System.exit(0);
            }

            return;

        }
        if(validated.size() > 8) {
            return;
        }

        long right = 1l << (x+1);


        // System.out.println(x + ":" + left.toString(2) + " + " + right.toString(2) + "
        // =>" + z.toString(2));
        long wrong = isOk(right);
        if(wrong < 0) {
            System.out.println("There is a loop : " +x);
            return;
        }

        if (wrong != 0) {

            // System.out.println("Need fix to get " + expect.toString(2));
            Set<Gate> changes = computeRelated(wrong);

            for (Gate a : changes) {
                if (validated.contains(a.wireOutput)) {
                    continue;
                }
                for (Gate b : gates) {
                    if (a.equals(b) || validated.contains(b.wireOutput) || lessZ(b.wireOutput, x)) {
                        continue;
                    }

                    String tmp = b.wireOutput;
                    b.wireOutput = a.wireOutput;
                    a.wireOutput = tmp;
                    try {
                        if (isOk(right) == 0l || (x <= 2 && isOk(right) == -1)) {
                            validated.add(a.wireOutput);
                            validated.add(b.wireOutput);

                            recurseFixGates(validated, x + 1);
                            validated.remove(a.wireOutput);
                            validated.remove(b.wireOutput);

                            if(validated.size() % 2 == 1) {
                                System.out.println("Whats");
                            }
                        }
                    } finally {
                        tmp = b.wireOutput;
                        b.wireOutput = a.wireOutput;
                        a.wireOutput = tmp;
                    }

                }
            }
        } else {
            recurseFixGates(validated, x + 1);
        }
    }

    private static boolean validate() {

        for(long x=0;x < 43;x++) {
            long a = (1l << x)-1;
            long b = 13;            
            if((a+b) != evaluateNetwork(a, b)) {
                return false;
            }
        }
        return true;
    }

    public static boolean lessZ(String name, int x) {
        if(! name.startsWith("z")) {
            return false;
        }

        return Integer.valueOf(name.substring(1)) <= x;
    }

    public static Gate findByOutput(String name) {
        return gates.stream().filter(g->g.wireOutput.equals(name)).findFirst().orElse(null);
    }

    private static Set<Gate> computeRelated(long wrong) {
        if(wrong == -1) {
            return new HashSet<Aoc2024s24p2.Gate>(gates);
        }
        Set<Gate> related = new HashSet<Aoc2024s24p2.Gate>();
        for(int x=0;x < 45;x++) {
            long mask = 1l << x;
            if((wrong & mask)> 0) {
                Gate gate = findByOutput(zindex(x));
                recurseRelated(related, gate);                                                                  
            }
        }

        return related;
    }

    private static void recurseRelated(Set<Gate> related, Gate gate) {
        if(related.contains(gate) || gate == null) {
            return;
        }
        related.add(gate);              
        recurseRelated(related, findByOutput(gate.wireLeft.name));
        recurseRelated(related, findByOutput(gate.wireRight.name));


    }

    private static long evaluateNetwork(Long left, Long right) {
        report.start("evaluateNetwork");
        if(left != null) {
            initiate("x", left);
        }
        if(right != null) {
            initiate("y", right);
        }

        Map<Gate, AtomicInteger> updated = new HashMap<Aoc2024s24p2.Gate, AtomicInteger>();
        /*for(Wire wire : wireByName.values()) {
            if(! (wire.name.startsWith("x") || wire.name.startsWith("y"))) {
                wire.state = null;
            }
        }*/
        boolean haveUpdate = false;
        do {
            haveUpdate = false;

            for (Gate gate : gates) {
                if (gate.update()) {

                    int count = updated.computeIfAbsent(gate, k->new AtomicInteger()).incrementAndGet();                                        
                    if (count > 2) {
                        report.end("evaluateNetwork");
                        return -1;
                    }
                    haveUpdate = haveUpdate || true;                    
                }

            }
        } while (haveUpdate);

        int x = 0;

        long z = 0;
        while(wireByName.get(zindex(x)) != null) {
            //System.out.println(x + " => " + wireByName.get(zindex(x)).state );
            Wire wire = wireByName.get(zindex(x));
            if(wire.state != null && wire.state) {
                long v =  1l << x;

                //System.out.println(v);
                z = z + v;
            }
            x++;
        }

        report.end("evaluateNetwork");
        return z;
    }

    private static void initiate(String s, long left) {

        for (long x = 0; x < 45; x++) {
            long mask = 1l << x;
            if ((mask & left) > 0) {
                wireByName.get(index(s, x)).state = true;
            } else {
                wireByName.get(index(s, x)).state = false;
            }
        }

    }

    public static String index(String s, long x) {
        return (x < 10 ? s + "0" : s) + x;

    }

    public static String zindex(long x) {
        return (x < 10 ? "z0" : "z") + x;
    }

Ce n'est vraiment pas terrible comme performance :)

En gros à la lecture, je charge mes map & mes liens.
Puis, je regroupe mes éléments.
A la fin, je filtre pour trouver le plus gros groupe.

    public static Map<String, Node> nodesByCode = new HashMap<>();
    public static Map<Node, List<Link>> linksByNodes = new HashMap<>();

    public record Node(String name) implements Comparable<Node> {
          //...
        }

        public record Link(Node left, Node right) {
          // ...
    }

        public record Group(TreeSet<Node> members) {
         // ...
        }

        public void main() {
         //...


         Set<Group> groups = new HashSet<>();
         for (Map.Entry<Node, List<Link>> entry : linksByNodes.entrySet()) {
                  Node a = entry.getKey();
                  TreeSet<Node> members = new TreeSet<>();
                  recurseGroup(members, a);
                  if (members.size() > 3) {
                           groups.add(new Group(members));
                  }
         }
     /* Chercher le plus grand groups */
        }

        private static void recurseGroup(TreeSet<Node> members, Node a) {
        for (Node n : members) {

            if (linksByNodes.get(a).stream().filter(l -> l.match(n)).count() == 0) {
                return;
            }

        }

        members.add(a);
        for (Link link : linksByNodes.get(a)) {
            Node b = link.getOther(a);
            if (members.contains(b)) {
                continue;
            }

            recurseGroup(members, b);
        }

    }

Je fais 215ms
et si je répète l'opération plusieurs fois , je descends à 15ms pour le même traitement.

Il n’était pas vraiment intéressant.
Pareil, j’ai suivi les instructions. J’ai été dessus quand je me suis rendu compte que le but de la deuxième partie n’était pas de trouver le secret initial ou un truc du genre.

Je n’ai pas cherché à optimiser, j’ai tout stocker dans un new long[2500][2001]

Puis, j’ai distribué dans une map

Map<Sequence, Map<Integer, SequenceResult>> firstGainsByBuyerBySequence;
public record Sequence(int[] fours){}
public record SequenceResult(int buyer, long endNumber, int[] fours){}

J'ai lutté sur celui-ci… presque 9h.

Pour la partie 1, j'ai tenté trouver un ordre dans les mouvements qui était toujours valide via un sort.
Finalement, je m'étais rabattu sur une fonction qui donnait tous les mouvements possibles.

Pour la partie 2, mon code de la partie 1 explosait même pour un chiffre à profondeur de 4.
Je me suis donc douté qu’il fallait faire un min. J’ai rapidement résolut ce problème avec un cache pour la programmation dynamique.
Par erreur, je pensai que çà exploserai en temps. Si je considérai tous les mouvements d’une case à l’autre.
Donc, j’ai tenté de chercher une distribution qui marchait dans tous les cas. J’ai réussi à trouver une combinaison qui valider pour la profondeur 2 et 3 pour les 2 jeux de test (j’ai obtenu la validation à 3 avec mon code de la partie 1) mais bien sûr, çà ne fonctionnait pas en profondeur 25. Il y a un cas non optimum qui doit apparaitre.
J’ai finalement tenté d’envisager tous les chemins possibles et j’ai été surpris de voir que cela marchait.
Comme quoi, quand on part sur une mauvaise piste, on bloque dessus.

    private static long processDoors(List<String> doors) {
        long sum = 0;
        for(String door : doors) {
            long messageLength = 0;
            String previous = "A";

            for(char c : door.toCharArray()) {  
                messageLength += recurse(0, handleNumPad.get(previous + c));
                previous = String.valueOf(c);
            }

            System.out.println(door + ":" +  messageLength);
            sum += messageLength * Long.valueOf(door.substring(0, door.length()-1));
        }
        return sum;
    }

    private static long recurse(int i, List<String> paths) {
        long sum = 0;

        Seek seek = new Seek(i, paths);
        Long cached = cacheResult.fromCache(seek);

        if(cached != null) {
            return cached;
        }

        if(i <= LIMIT) {
            long minPath = Long.MAX_VALUE;
             for(String path: paths) {
                 char previous = 'A';
                 long currentPath = 0;
                 for(char c: path.toCharArray()) {                   
                     currentPath += recurse(i + 1, handleArrowPad.get("" + previous + c));                   
                     previous = c;
                 }
                 if(currentPath < minPath) {
                     minPath= currentPath;
                 }
             }
             sum+= minPath;
        } else {
            sum = 1;
        }
        cacheResult.setInCache(seek, Long.valueOf(sum));
        return sum;
    }

Pour la première partie, j ai fait un simmle dijkstra.
Pour la deuxième partie, j ai brute force ce dernier à chaque pixel. J étais un peu déçu car je m attendais à une deuxième bien plus complexe.

Si le problème de performance aurait été plus complexe. En demultipliant la map d input. J aurai probablement tenter. De conserver le path dans mon dijkstra. De cette manière, j aurai pu déterminer rapidement les cases à mettre en jour quand c est dernier sont affecté par la mise à jour…

Hello,

J'ai procédé de cette manière pour la partie 2.

Ce matin pendant le travail, j'ai tenté de brute-force, je suis monté à plusieurs milliard de possibilité testé :O)

Ce midi:
J'ai modifié mon Engine pour qu'elle affiche le code Java équivalent à chaque opération.

Sur la base du code Java et l'impression du résultat en binaire
Que le bit de A était consommé progressivement par le programmme pour construire la sortie.
J'ai alors compris que le programme avançait par paquet de 3 à 6 bits.

J'avais presque la réponse ce midi. Je trouvais un A qui me donnait le bon résultat un chiffre de plus ",2" :)

Ce soir:
J'ai revu plein de fois de mon algo pour m’apercevoir que j'avais merdé un <= en < dans ma fonction de contrôle progressif.
Résultat, il me trouvait toujours un resultat matchant avec un chiffre de plus :O)

Ce n'est pas un simple Dijkstra.

Perso , j'ai du combiner le déplacement & la rotation.
Au final même pour simplifier la partie 2, j'ai revu mon algo pour considérer la rotation comme un mouvement.

Ensuite pour la partie 2, j'utilise la map de poids de la partie 1.

Je pars du start et je parcours en profondeur ma map de poids.

Je passe d'un poids à l'autre récursivement , si le poids d déplacement ou une rotation correspond au poids minimum que j'avais constaté.

Pour la partie 2, j'ai opté pour un algo simple.

Je compte le nombre de sapin avec au moins un autre adjacent.

Ce nombre change à chaque tour. A chaque fois que je trouvai un maximum. J'affiche la carte.

A un momemt le premier maximum affiche le sapin.

Aujourd'hui, je me suis dit que c'était le bon jour pour essayer une IA. Voir ce que cela donnerai.

Je l'ai fait d'abord en Java en utilisant un Mistral (medium) car j'étais persuadé qu'il arriverait à me donner la bonne réponse.
Après 10min à debug le code, j'avais la bonne réponse pour la première partie.

Pour la deuxième partie , je lui ai demandé d'utiliser Apache Commons Math. En soit ,le code était correcte.
Il y avait juste < 100 qui était resté, et il y avait un problème de cast à la sortie Apache Commons Math , où on sort des Double qu'il faut arrondir et non trunc.

Vu que j'étais persuadé que j'aurai été plus vite avec Python. J'ai fait aussi l'exercice en python avec numpy :)
J'ai aussi utilisé une IA pour voir et çà fonctionne.
Par contre, bizarrement, il gérait encore plus mal la lecture des données que j'ai du aussi réecrire complétement.

def solve_for_machine(xA, yA, xB, yB, xPrize, yPrize):
    # Set up the matrix and vectors
    coefficients = np.array([[xA, xB], [yA, yB]])
    constants = np.array([xPrize, yPrize])

    try:
        # Solve the system of equations
        solution = np.linalg.solve(coefficients, constants)
        a, b = solution

        a = round(a)
        b = round(b)

        verifyX = a*xA + b*xB
        verifyY = a*yA + b*yB

        # Check if the solution is valid
        if 0 <= a and 0 <= b and verifyX == xPrize and verifyY == yPrize:
            return int(3 * a + b)
    except np.linalg.LinAlgError:
        pass

    return -1  # No valid solution found

193ms première évaluation
1,3ms pour la 100ème évaluation (Java , c'est du Diesel)

compter le nombre de cotés revient à compter le nombre de coins.

Je n'y avais pas pensé. J'ai utilisé une méthode différentes

J'identifie les pièces sous forme d'un Set.

Pour identifier les côtés, je détermine la bordure & la direction qui a servi à déterminer cette bordure. Cela me donne un Set

Je regroupe les éléments de ce Set par exploration des adjacents de même directions. Le nombre groupe identifié correspond à mon nombre de côté.

    private static int computeSides(Set<Point> pieces) {
        Set<SidePart> set = new HashSet<>();
        int sides = 0;
        for (Point p : pieces) {
            for (Point d : Point.DIRECTIONS) {
                Point i = p.add(d);
                if (!pieces.contains(i)) {
                    set.add(new SidePart(p, d));
                }
            }
        }

        Set<SidePart> counted = new HashSet<>();
        for (SidePart sidePart : set) {
            if (counted.contains(sidePart)) {
                continue;
            }

            Set<SidePart> groups = new HashSet<>();
            buildGroup(set, sidePart, groups);

            counted.addAll(groups);
            sides++;
        }
        return sides;
    }

    private static void buildGroup(Set<SidePart> set, SidePart sidePart, Set<SidePart> groups) {
        if (!set.contains(sidePart)) {
            return;
        }

        if (groups.contains(sidePart)) {
            return;
        }
        groups.add(sidePart);

        Point direction = sidePart.direction;
        Point source = sidePart.source;
        if (direction.x != 0) {
            buildGroup(set, new SidePart(source.add(new Point(0, 1)), direction), groups);
            buildGroup(set, new SidePart(source.add(new Point(0, -1)), direction), groups);
        } else {
            buildGroup(set, new SidePart(source.add(new Point(1, 0)), direction), groups);
            buildGroup(set, new SidePart(source.add(new Point(-1, 0)), direction), groups);
        }

    }

    record SidePart(Point source, Point direction) {
    }

En fait, c'est moi qui avait du faire un cast en Int. Cela tenait bien dans un Long.

u64, c'est pour unsigned 64 ?
Car en Java, j'ai été obligé de passer tout en BigInteger car j'avais un dépassement et j'obtenais des chiffres négatifs

Mais bon Java , tu ne peux pas faire de unsigned … donc peut être qui me manquait uniquement le 2⁶⁴ :)

Si je l'avais fait en python. Je pense que j'aurai été plus vite environ 40min.
J'ai été obligé de repasser tout en BigInteger pour la 2ème partie.

La partie 2 : je mets 191ms pour trouver la solution ;-)

Hier, je l'ai pris de travers :)
J'ai fait un dijkstra pour résoudre la première partie.

Ce qui n'était pas du tout adapté à la partie 2, j'ai du repasser en récursion basique ensuite.
Si j'avais pris ce choix, je pense que je faisais les 2 parties en moins de 20min

Pour la partie 2 : 134ms (jvm lancé)

Hello,
J'ai une imprimante en wifi sur mon réseau.
Est-ce qu'il y a moyen de tester si l'imprimante réseau est sujette à cette faille ?

Perso, je trouve que c'est très bien pour les juniors ou quand tu découvres un nouveau framework/nouvelle techno.

Par contre pour mon usage, c'est contre productif. Les suggestions autre que les choses simple me coupe dans mon file de pensée. Ça me fait comme une sorte d'interruption et ça me perturbe plus qu'autre choses.
Résultat, c'est l'inverse. Ça me rend moins productif.

Après, je ne l'utilise pas au quotidien. Je l'utilise en général quand je travaille à quatre main sur le poste d'un junior. Donc peut-être que c'est un manque de pratique.

J'ai bien aimé la première partie du prechall.
Cela m'a rappelé l'époque où pour tricher dans les jeux. On allait modifier la mémoire ou le code.

La deuxième partie est en python. Et c est ce qui m a fait perdre beaucoup de temps.
C'est un classique des challenges de programmation mais je l'ai pris de travers…

Les catégories introduction sont en général à la portée de tous.

En général, les 1 étoiles me prennent en général 1 à 4h.
Au-dessus, les 2 étoiles, j arrive à en avoir quelques une

Les 3 étoiles, je ne suis pas sûr d en avoir eu une pendant le concours mais je suis toujours très intéressé de découvrir les write-up une fois le concours terminé.

Je confirme , je me suis trompé.
Je fais en général beaucoup fautes mais c'est encore pire que je suis énervé.

Trop tard pour changer.

20 M€ c'est le coup du dev.
La maintenance annuelle, elle est à combien ?

Je suis du même avis.
On arrive sur ce genre de phase où il y a une restructuration de l'activité.
Mais ça ne va pas durer.

Il faudra probablement apprendre à revaloriser ses compétences ou revoir ses préférences techniques.

Mais dans l'ensemble l'IA va augmenter la taille des SI et leur complexité.
Résultat, on va passer moins de temps à coder et plus de temps en réunions de coordination.
Les véritables compétences à revaloriser. Ça va être :
- Les softskills: organisation, la motivation, la communication et le sens du service
- la modélisation système
- L'administration système.

Pour le dernier jour, j'ai tenté plusieurs solutions naïve avant de chercher un algorithme qui pouvait répondre à mon problème.

Je suis tombé sur l'algorithme de Karger qui me semblait relativement simple à implémenter.

https://fr.wikipedia.org/wiki/Algorithme_de_Karger

Je trouve que ma condition de sortie est un peu moisie mais dans l'ensemble.
En gros, j'arrête le programme quand j'arrive à une contraction à 2 noeud avec 3 lien qui sont les 3 liens à couper.
C'était la solution attendu. Je n'ai pas cherché plus loin.

package aoc2023;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Aoc2023s25 {
    final static Random random = new Random(0);

    public static class Link {

        String srcName;
        String dstName;

        public Link(String srcName, String dstName) {
            this.srcName = srcName;
            this.dstName = dstName;
        }

        @Override
        public String toString() {
            return dstName + "/" + srcName;
        }

        public boolean match(String name) {
            return name.equals(srcName) || name.equals(dstName);
        }

        public String otherName(String name) {
            return srcName.equals(name) ? dstName : srcName;
        }

        public Link replace(String left, String right, String b) {
            String nsrc = srcName;
            if (nsrc.equals(left) || nsrc.equals(right)) {
                nsrc = b;
            }

            String ndst = dstName;
            if (ndst.equals(left) || ndst.equals(right)) {
                ndst = b;
            }

            return new Link(nsrc, ndst);
        }

    }

    public static class Node {
        String name;

        public Node(String s) {
            this.name = s;

        }

        @Override
        public String toString() {
            return "Node [name=" + name + "]";
        }

        @Override
        public int hashCode() {
            return Objects.hash(name);
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Node other = (Node) obj;
            return Objects.equals(name, other.name);
        }
    }

    public static void main(String[] args) {
        try (Scanner in = new Scanner(Aoc2023s25.class.getResourceAsStream("res/t25.txt"))) {

            Map<String, Node> nodeByName = new HashMap<>();
            List<Link> links = new ArrayList<>();
            while (in.hasNext()) {
                String row = in.nextLine();

                String[] fields = row.split(":");
                Node n = new Node(fields[0].trim());
                nodeByName.put(n.name, n);

                links.addAll(Arrays.stream(fields[1].trim().split(" ")).map(String::trim)
                        .map(d -> new Link(n.name, d)).toList());
            }

            for (Link a : links) {
                nodeByName.computeIfAbsent(a.dstName, k -> new Node(k + ": "));
            }

            while (true) {
                Map<String, Node> clone = new HashMap<>(nodeByName);
                algorithmKarger(clone, new ArrayList<>(links));
            }
        }

    }

    private static void algorithmKarger(Map<String, Node> nodeByName, List<Link> links) {

        while(nodeByName.size() > 2) {
            Link link = links.get(random.nextInt(links.size()));

            String leftName  = link.srcName;
            String rightName = link.dstName;
            String contractName = leftName + "," + rightName;

            nodeByName.remove(leftName);
            nodeByName.remove(rightName);
            nodeByName.put(contractName,new Node(contractName));

            List<Link> intLinks = links.stream()
                .filter(l -> !(l.match(leftName) && l.match(rightName)))
                .map(l->l.replace(leftName, rightName, contractName))
                .toList();

            links =intLinks;


        }

        System.out.println(nodeByName.size());
        System.out.println(links.size());
        for(Node n : nodeByName.values()) {
            System.out.println(n.name + " => " + n);
        }
        if(links.size() == 3) {
            int prod = 1;
            for(String n :  nodeByName.keySet()) {
                String[] keys = n.split(",");
                System.out.println(keys.length);
                prod *= keys.length;
            }
            System.out.println(prod);
            System.out.println(links);
            System.exit(0);
        }

    }
}

Je viens de voir que j'avais oublié de corriger le problème de séparation des bloques

`eqs.push(x.add(t298.mul(vx)).eq(t298.mul(vpx).add(px)));
eqs.push(y.add(t298.mul(vy)).eq(t298.mul(vpy).add(py)));
eqs.push(z.add(t298.mul(vz)).eq(t298.mul(vpz).add(pz)));
px = 401753783270176;
py = 450367245750257;
pz = 441634222195088;
vpx = -161;
vpy = -312;
vpz = -187;


eqs.push(x.add(t299.mul(vx)).eq(t299.mul(vpx).add(px)));
eqs.push(y.add(t299.mul(vy)).eq(t299.mul(vpy).add(py)));
eqs.push(z.add(t299.mul(vz)).eq(t299.mul(vpz).add(pz)));

il faut le lire. il manque un saut ligne est un commentaire.

`eqs.push(x.add(t298.mul(vx)).eq(t298.mul(vpx).add(px)));
eqs.push(y.add(t298.mul(vy)).eq(t298.mul(vpy).add(py)));
eqs.push(z.add(t298.mul(vz)).eq(t298.mul(vpz).add(pz)));

// Hailstone 299
px = 401753783270176;
py = 450367245750257;
pz = 441634222195088;
vpx = -161;
vpy = -312;
vpz = -187;
eqs.push(x.add(t299.mul(vx)).eq(t299.mul(vpx).add(px)));
eqs.push(y.add(t299.mul(vy)).eq(t299.mul(vpy).add(py)));
eqs.push(z.add(t299.mul(vz)).eq(t299.mul(vpz).add(pz)));

(En espérant que c'est plus clair)