syj a écrit 630 commentaires

Environ 4h-4h30 effectif dessus.
La première partie est fastidieuse, mais çà se code bien (~2h)

La deuxième partie est encore plus fastidieuse.
J'ai opté pour une classe "Arrete" agrégeant 2 segments caractérisés par une direction.

Si on est dans un de ces 2 segments en matchant la direction de ce dernier, j'applique la transformation de changement d’arête.
J'ai donc pris le temps d'identifier manuellement les arêtes du jeu de test pour valider mon algo. Je me suis aidé d'un petit découpage papier
pour faciliter l'opération.

Puis, j'ai fait pareil pour mon jeu de données. C'est le plus long.

Par exemple pour le Jeu de test, elle donne ceci.
9,9->9,12L 8,8->5,8D
5,5->8,5U 9,1->9,4L
13,9->16,9U 12,8->12,5R
1,5->4,5U 12,1->9,1U
4,8->1,8D 9,12->12,12D
13,12->16,12D 1,8->1,5L
12,4->12,1R 16,9->16,12R

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;



public class A2022D22V2 {


    public static List<String> memory = new ArrayList<>();
    public static class Point  {
        int x;
        int y;

        public String toString() {
            return x + "," + y;
        }
    }

    public static class Segment {
        Point start;
        Point end;
        Direction direction;

        Segment(String part) {
            String[] points=  part.split("->");
            start = parsePoint(points[0]);
            end = parsePoint(points[1].substring(0, points[1].length()-1));

            char dir = points[1].charAt(points[1].length()-1);
            direction = Arrays.stream(Direction.values()).filter(a->a.name().charAt(0) == dir).findAny().orElse(null);
        }

        public Point parsePoint(String point) {

            String[] coords = point.split(",");
            Point p = new Point();
            p.x = Integer.valueOf(coords[0]);           
            p.x -= 1 ;

            p.y = Integer.valueOf(coords[1]);
            p.y -= 1;

            return p;
        }

        public String toString() {
            return start + " -> " + end + " " + direction;
        }

        public boolean include(int s, int v, int e) {
            if(s > e) {
                int t = s;
                s = e;
                e = t;
            }
            return s <= v && v <= e;
        }

        public boolean include(A2022D22V2.Point p) {
            return include(start.x, p.x, end.x)
                    && include(start.y, p.y , end.y); 
        }
    }

    public static class Arrete {
        Segment a;      
        Segment b;

        public Arrete(String row) {
            String[] part = row.split(" ");
            a = new Segment(part[0]);
            b = new Segment(part[1]);           
        }       

        public String toString() {
            return a + " <=> " + b;
        }

        public static int normalize(int dx) {
            if(dx < 0 ) {
                return -1;
            }
            if(dx == 0) {
                return 0;
            }
            return 1;
        }

        public boolean moveTo(List<String> rowMap, A2022D22V2.Segment src, A2022D22V2.Segment dst, Monkey p) {
            int dx = normalize(src.end.x - src.start.x);
            int dy = normalize(src.end.y - src.start.y);

            int sx = src.start.x;
            int sy = src.start.y;

            int i = 0;

            while (sx != p.x || sy != p.y) {
                sx += dx;
                sy += dy;
                i++;
            }

            dx = normalize(dst.end.x - dst.start.x);
            dy = normalize(dst.end.y - dst.start.y);

            sx = dst.start.x;
            sy = dst.start.y;

            while(i > 0) {
                sx += dx;
                sy += dy;
                i--;                
            }

            System.out.println("Move:" + p.x + "," + p.y);
            System.out.println("====>" + sx + "," + sy);
            if(getChar(rowMap, sx ,sy) == '#') {
                System.out.println("Blocked");
                return false;

            }
            System.out.println("Ok!");


            p.x = sx;
            p.y = sy;
            p.direction = dst.direction.left().left();

            displayMap(p, true);
            return true;
        }
    }

    public enum Direction {
        RIGHT(1, 0, "UP", "DOWN",0),
        DOWN(0, 1, "RIGHT", "LEFT", 1),
        LEFT(-1,0, "DOWN", "UP", 2),
        UP(0, -1, "LEFT", "RIGHT", 3),

        ;
        int dx;
        int dy;
        int score;

        String rotateLeft;
        String rotateRight;
        private Direction(int dx, int dy, String rotateLeft,String rotateRight, int score) {
            this.dx = dx;
            this.dy = dy;
            this.rotateLeft = rotateLeft;
            this.rotateRight = rotateRight;
            this.score =score;
        };

        Direction left() {
            return Direction.valueOf(rotateLeft);
        }

        Direction right() {
            return Direction.valueOf(rotateRight);
        }
    }


    public static class Monkey extends Point{


        Direction direction = Direction.RIGHT;

    }

    public static void main(String[] args) {
        step1();
    }

    private static void step1() {
        List<String> rowMap = new ArrayList<>();
        String path = "";
        int maxWidth = 0;
        try (Scanner in = new Scanner(A2022D22V2.class.getResourceAsStream("/res/i22V2.txt"))) {            
            while (in.hasNext()) {
                String row = in.nextLine();
                if(row.isEmpty()) {
                    path = in.nextLine();
                } else {
                    maxWidth = Math.max(maxWidth, row.length());
                    rowMap.add(row);
                }
            }
        }

        List<Arrete> arretes = new ArrayList<>();


        try (Scanner in = new Scanner(A2022D22V2.class.getResourceAsStream("/res/i22V2rf.txt"))) {
            boolean parse = false;
            while (in.hasNext()) {
                String row = in.nextLine().trim();
                if("Parse".equals(row)) {
                    parse = true;
                } else if(parse) {
                    System.out.println(row);
                    Arrete arrete  =new Arrete(row);
                    arretes.add(arrete);
                    System.out.println(arrete);
                }

            }
        }

        normalizeMap(rowMap, maxWidth);

        Monkey monkey = new Monkey();
        monkey.x = rowMap.get(0).indexOf("."); 
        monkey.y = 0;

        System.out.println(path);

        int index = 0;
        while(index < path.length() && index >= 0) {
            if(path.charAt(index) == 'L') {
                System.out.println("Left");
                monkey.direction = monkey.direction.left();
                index+=1;
            } else if(path.charAt(index) == 'R') {
                System.out.println("Right");
                monkey.direction = monkey.direction.right();
                index+=1;
            } else {

                int i = Integer.valueOf(path.substring(index).replaceAll("^([0-9]*).*", "$1"));
                System.out.println("Move " + i);
                index += (""+i).length();
                do {                    
                    if(!translateToValid(rowMap, arretes, monkey))  {
                        break;
                    }                   
                    i--;
                    displayMap(monkey, false);
                } while(i > 0);

            }
            displayMap(monkey, false);
        }
        displayMap(monkey, true);
        System.out.println(monkey.y+1);
        System.out.println(monkey.x+1);
        System.out.println(monkey.direction);
        int result = (monkey.y+1)*1000+(monkey.x+1)*4+monkey.direction.score;
        System.out.println(result);
    }

    private static void normalizeMap(List<String> rowMap, int maxWidth) {

        for(int y=0;y < rowMap.size();y++) {
            if(rowMap.get(y).length() < maxWidth) {

                String row = rowMap.get(y);
                while(row.length() < maxWidth) {
                    row += " ";
                }
                rowMap.set(y, row);
            }
            memory.add(new String(rowMap.get(y)));
        }
    }

    public static char getChar(List<String> rowMap, int sx, int sy) {
        String row = rowMap.get(sy);
        return row.charAt(sx);
    }

    private static boolean translateToValid(List<String> rowMap, List<Arrete> arretes, Monkey monkey) {     
        for(Arrete arrete: arretes) {           
            //System.out.println(arrete.a);
            if(arrete.a.include(monkey) && arrete.a.direction == monkey.direction) {
                System.out.println(arrete.a + " " + monkey.direction);
                return arrete.moveTo(rowMap, arrete.a, arrete.b, monkey);


            }


            if(arrete.b.include(monkey) && arrete.b.direction == monkey.direction) {
                System.out.println(arrete.b + " " + monkey.direction);
                return arrete.moveTo(rowMap, arrete.b, arrete.a, monkey);

            }

        }

        if(getChar(rowMap, monkey.x + monkey.direction.dx , monkey.y + monkey.direction.dy) == '#') {
            return false;
        }

        monkey.x += monkey.direction.dx;
        monkey.y += monkey.direction.dy;
        return true;
    }

    private static void displayMap(Monkey monkey, boolean print) {
        System.out.println();
        for(int y=0;y < memory.size();y++) {
            String row = memory.get(y);
            for(int x=0;x < row.length(); x++) {
                if(monkey.x == x && monkey.y== y) {
                    char c;
                    switch (monkey.direction) {
                            case UP: 
                                c = '^';
                                break;                              
                            case DOWN: 
                                c = 'u';
                                break;                  
                            case RIGHT: 
                                c = '>';
                                break;                  
                            case LEFT: 
                                c = '<';
                                break;                      
                            default:
                                throw new IllegalArgumentException("Unexpected value: " + monkey.direction);
                    }
                    if(print) System.out.print(c);
                    StringBuilder sb = new StringBuilder(row);
                    sb.setCharAt(x, c);
                    row = sb.toString();
                    memory.set(y, row);
                } else {
                    if(print) System.out.print(row.charAt(x));
                }

            }
            if(print) System.out.println();
        }
    }

}

J'ai mis grosso modo 1h15.
Pour faire l'éval, j'ai utilisé un parser JEXL. Le problème est qu'il travaille en double & qu'il m'a fallut passer en BigDecimal pour éviter les pertes de précisions du au double.
Résultat, j'ai été obligé de transformer les expression pour utiliser des BigDecimal.
çà m'a permit de trouver rapidement la première étoile.

La deuxième étoile.
J'ai déjà commencé par réduire l'arbre d'évaluation, en gros tout ce qui ne dépend pas de humn.

Puis, j'ai rapidement vu que la fonction décroissé. J'aurai pu tenter une recherche dichotomique dans l'espace d'entier.
Mais j'étais trop fatigué pour coder un truc intelligent.
Résultat, j'ai monté une boucle qui permet de suivre l'évolution, j'ai joué manuellement sur les paramétres pour trouver la valeur

C'est tellement sale que je partage mon code pour une fois :-p

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

import org.apache.commons.jexl3.JexlBuilder;
import org.apache.commons.jexl3.JexlContext;
import org.apache.commons.jexl3.JexlEngine;
import org.apache.commons.jexl3.JexlExpression;
import org.apache.commons.jexl3.MapContext;



public class A2022D21S2 {
    private static final JexlEngine jexl = new JexlBuilder().cache(512).strict(true).silent(false).create();

    public static void main(String[] args) {                
        step1();
    }

    private static void step1() {
        Map<String, String> mapMonkey = new HashMap<>();
        try (Scanner in = new Scanner(A2022D21S2.class.getResourceAsStream("/res/i21.txt"))) {

            while (in.hasNext()) {
                String row = in.nextLine();
                String[] part = row.split(":");
                if(part.length > 2) {
                    throw new RuntimeException();
                }
                if(part[0].equals( "root")) {
                    part[1] = part[1].replaceAll(" ", "").replaceAll("\\+", "-");
                    System.out.println("root:" + part[1]);
                }
                mapMonkey.put(part[0], part[1]);
            }

        }

        for (Map.Entry<String, String> entry : mapMonkey.entrySet()) {
            if (canReduce(mapMonkey, entry.getKey())) {
                BigDecimal d = evalMonkey(mapMonkey, entry.getKey());
                System.out.println("Reduce " + entry.getKey() + ":" + d.toPlainString());
                mapMonkey.put(entry.getKey(), d.toPlainString());
            }
        }

        System.out.println("=========================");

        Double previous = null;
        for(long x=3876907167000L;x < 3876907168000L;x+= 1L) {
            BigDecimal bdx = new BigDecimal(x);
            mapMonkey.put("humn", bdx.toString());
            BigDecimal currentResult = evalMonkey(mapMonkey, "root");
            if(currentResult.doubleValue() == 0.0) {
                System.out.println("Found:" + x);
                break;
            }
            System.out.println(x + "=>" + currentResult.toPlainString());
            if(previous != null) {
                System.out.println(previous > currentResult.doubleValue() ? "diminue" : "augmente");
            }
            previous = currentResult.doubleValue();
        }
    }

    private static boolean canReduce(Map<String, String> mapMonkey, String key) {
        String expr = mapMonkey.get(key);
        if(expr.matches("[ 0-9.]*")) {
            return true;
        }

        for(String other: mapMonkey.keySet()) {

            if(expr.contains(other)) {
                if("root".equals(other) || "humn".equals(other)) {
                    return false;
                } 

                boolean r = canReduce(mapMonkey, other);
                if(! r) {
                    return false;
                }                           
            }
        }
        return true;
    }

    public static final BigDecimal MINUS_ONE = BigDecimal.valueOf(-1L);
    public static final BigDecimal ZERO = BigDecimal.valueOf(0L);
    public static final BigDecimal ONE = BigDecimal.valueOf(1L);
    private static BigDecimal evalMonkey(Map<String, String> mapMonkey, String name) {
        String expr = mapMonkey.get(name);
        if(expr.matches("[ 0-9.]*")) {
            return new BigDecimal(expr.replaceAll(" " , ""));
        }

        JexlContext context = new MapContext();
        context.set("MINUS_ONE", MINUS_ONE);
        for(String other: mapMonkey.keySet()) {
            if(expr.contains(other)) {
                context.set(other, evalMonkey(mapMonkey, other));               
            }
        }
        expr = expr.replaceAll(" ", "");
        //System.out.println("Eval:" + expr);
        JexlExpression e = jexl.createExpression( expr );

        BigDecimal bdBigDecimal;

        expr = expr.replaceAll("\\+([a-z]*)", ".add($1)"); 
        expr = expr.replaceAll("\\*([a-z]*)", ".multiply($1)");
        expr = expr.replaceAll("\\/([a-z]*)", ".divide($1)");
        expr = expr.replaceAll("\\-([a-z]*)", ".add($1.mulitply(MINUS_ONE))");

        //System.out.println("Eval2:" + expr);

        Object o  =e.evaluate(context);
        if(o instanceof BigDecimal) {
            return (BigDecimal)o;
        }

        if(o instanceof Boolean) {
            return Boolean.TRUE.equals(o) ? ONE : ZERO;
        }

        throw new RuntimeException();
    }
}

J'ai pris le problème du mauvais sens, il m'a fallut plus de 3h pour comprendre qu'il ne fallait pas appliquer la transformation 3000 fois pour avoir la réponse.

J'ai réecris 3 ou 4 fois mon code. J'ai commencé par un tableau avec des modulos au final, j'ai terminé par une liste doublement chainés comme quasiment tout le monde.

J'ai remis une bonne 1h30 pour caler le modulo pour éviter d'appliquer les millions de déplacement.

Bref, un très mauvaise journée. En plus, vous êtes plein à y être arrivé avant moins résultat.
Je n'ai plus aucun espoir de rafler la seconde place.

Petite amélioration, je descends à 6s en modifiant mon DFS

L'idée est de ne pas aller jusqu'au bout si on sait déjà qu'on sera en-dessous du meilleur temps.
```
public static void executeDFS(State state) {
int leftTurn = NB_TURN_32- state.index;
int expGeode = state.geode+(NB_TURN_32-state.index) * (state.geodeRobot) + (leftTurn+1) * (leftTurn + 0) / 2;

if(bestMap.get(state.bp) != null && expGeode < bestMap.get(state.bp)) {
return;
}

if(state.index == NB_TURN_32) {
    if(bestMap.get(state.bp) == null || state.geode > bestMap.get(state.bp)) {              
        bestMap.put(state.bp, state.geode);                         
        System.out.println("Best:" + state.bp.index +";" + state.geode);                                            
    }
    return;
}
List<String> actions =state.availablesAction();
State newState = new State(state.bp);
for(String action : actions) {          
    state.copyInto(newState);
    newState.transform(action);
    executeDFS(newState);
}

}
```

Au final, J'aurai mis 35min de plus.

Le problème venait que j'avais mis une règle qui réduisait le nombre d'action possible pendant mon parcours en profondeur

Il met 1min3s pour calculer le 2ème.

Pour une fois , mon code n'est pas trop moche :)

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

public class A2022D19 {
    private static final String BUILD_ORE = "BUILD_ORE";
    private static final String BUILD_CLAY = "BUILD_CLAY";
    private static final String BUILD_OBSIDIAN = "BUILD_OBSIDIAN";
    private static final String BUILD_GEODE = "BUILD_GEODE";
    private static final String WAIT = "WAIT";

    static Map<BluePrint, Integer> bestMap = new HashMap<>();

    public static class Cost {
        int costOre;
        int costClay;
        int costObsidian;

        public String toString() {
            return costOre +";" + costClay + ";" + costObsidian;
        }                   
    }   

    public static class BluePrint {
        int index;
        Cost buildOreRobot;
        Cost buildClayRobot;
        Cost obsidianRobot; 
        Cost geodeRobot;

        public BluePrint(String row, int index) {
            this.index = index;
            String[] robots =  row.split("\\.");

            buildOreRobot = buildCost(robots[0]);
            buildClayRobot = buildCost(robots[1]);
            obsidianRobot = buildCost(robots[2]);
            geodeRobot = buildCost(robots[3]);

        }

        private Cost buildCost(String row) {
            Cost cost = new Cost();
            String regex;
            regex = ".* ([0-9]*) ore.*";
            if(row.matches(regex)) {
                String s = row.replaceAll(regex, "$1");
                cost.costOre = Integer.valueOf(s);
            }


            regex = ".* ([0-9]*) clay.*";
            if(row.matches(regex)) {
                String s = row.replaceAll(regex, "$1");
                cost.costClay = Integer.valueOf(s);
            }

            regex = ".* ([0-9]*) obsidian.*";
            if(row.matches(regex)) {
                String s = row.replaceAll(regex, "$1");
                cost.costObsidian = Integer.valueOf(s);
            }

            System.out.println(cost.toString());

            return cost;
        }
    }   

    public static class Action {
        int buildOreRobot = 0;
        int buildClayRobot = 0;
        int buildObsidianRobot = 0;
        int buildGeodeRobot = 0;
    }

    public static class State {


        BluePrint bp;
        int oreRobot = 1;
        int clayRobot = 0;
        int obsidianRobot = 0;
        int geodeRobot = 0;

        int ore = 0;
        int clay = 0;
        int obsidian = 0;
        int geode = 0;
        int index=0;

        public State(BluePrint bp) {
            this.bp = bp;
        }

        public boolean canPaid(Cost cost) {
            return ore >= cost.costOre
                && clay >= cost.costClay
                && obsidian >= cost.costObsidian;                                   
        }

        public void paid(Cost cost ) {
            ore -= cost.costOre;
            clay -= cost.costClay;
            obsidian -= cost.costObsidian;
        }

        public List<String> availablesAction() {
            List<String> actions  = new ArrayList<>();
            if(canPaid(bp.geodeRobot)) {                
                actions.add(BUILD_GEODE);
                return actions;
            }

            if(canPaid(bp.obsidianRobot)) {             
                actions.add(BUILD_OBSIDIAN);
                return actions;
            }

            if(canPaid(bp.buildClayRobot) && max(bp.buildOreRobot.costClay, bp.buildClayRobot.costClay, bp.obsidianRobot.costClay, bp.geodeRobot.costClay) >  this.clayRobot) {             
                actions.add(BUILD_CLAY);                
            }

            if(canPaid(bp.buildOreRobot) && max(bp.buildOreRobot.costOre, bp.buildClayRobot.costOre, bp.obsidianRobot.costOre, bp.geodeRobot.costOre) >  this.oreRobot) {               
                actions.add(BUILD_ORE);             
            }

            actions.add(WAIT);
            return actions;

        }

        private int max(int costOre, int costOre2, int costOre3, int costOre4) {
            return Math.max(Math.max(Math.max(costOre, costOre2), costOre3), costOre4);
        }

        public void transform(String command) {
            ++index;
            //System.out.println(index);
            //System.out.println(command);      
            this.ore += this.oreRobot;
            this.clay += this.clayRobot;
            this.obsidian += this.obsidianRobot;            
            this.geode += this.geodeRobot;      

            if(command.equals(BUILD_GEODE)) {
                paid(bp.geodeRobot);
                this.geodeRobot++;
            }

            if(command.equals(BUILD_OBSIDIAN)) {
                paid(bp.obsidianRobot);
                this.obsidianRobot++;
            }

            if(command.equals(BUILD_CLAY)) {
                paid(bp.buildClayRobot);
                this.clayRobot++;
            }

            if(command.equals(BUILD_ORE)) {
                paid(bp.buildOreRobot);
                this.oreRobot++;
            }

            //System.out.println("S:" + this.ore + ";"  + this.clay + ";" + this.obsidian + ";" + this.geode);
            //System.out.println("R:" + this.oreRobot + ";"  + this.clayRobot + ";" + this.obsidianRobot + ";" + this.geodeRobot);

        }

        public void copyInto(A2022D19.State newState) {
            newState.bp = this.bp;
            newState.oreRobot = this.oreRobot;
            newState.clayRobot = this.clayRobot;
            newState.obsidianRobot = this.obsidianRobot;
            newState.geodeRobot = this.geodeRobot;

            newState.ore = this.ore;
            newState.clay = this.clay;
            newState.obsidian = this.obsidian;
            newState.geode = this.geode;
            newState.index= this.index;

        }
    }

    public static void main(String[] args) {
        step1();
    }


    public static void executeDFS(State state) {
        if(state.index == 32) {
            if(bestMap.get(state.bp) == null || state.geode > bestMap.get(state.bp)) {              
                bestMap.put(state.bp, state.geode);                         
                System.out.println("Best:" + state.bp.index +";" + state.geode);                                            
            }
            return;
        }
        List<String> actions =state.availablesAction();
        State newState = new State(state.bp);
        for(String action : actions) {          
            state.copyInto(newState);
            newState.transform(action);
            executeDFS(newState);
        }
    }

    private static void step1() {
        try (Scanner in = new Scanner(A2022D19.class.getResourceAsStream("/res/i19.txt"))) {
            List<BluePrint> listBp = new ArrayList<>(); 
            while (in.hasNext()) {
                String row = in.nextLine();
                BluePrint bp = new BluePrint(row, listBp.size()+1);             
                listBp.add(bp);

            }

            State state;    
            for(BluePrint bp: listBp) {
                state =new State(bp);
                executeDFS(state);
            }               

            int sum  = 0;
            int prod = 1;
            for(Map.Entry<BluePrint, Integer> e : bestMap.entrySet()) {
                System.out.println("Final:" + e.getKey().index + "," + e.getValue());   
                prod *= e.getValue();
                sum += (e.getKey().index  * e.getValue());
            }

            System.out.println(sum);
            System.out.println(prod);


        }

    }

}

Est ce qu'on peut construire plusieurs robots en un tour ?

C'est probablement çà mon erreur ?

Gg, Perso, j'y ai passé 2h ce matin et je bloque sur le fait que je ne trouve pas comment arriver à 12 sur le 2ème du test unit.
Je dois avoir un bug qui m'echape.

Malheureusement, j'ai 2 truc urgent qui sont tombé aujourd'hui. Pas sur que je puisse y rebosser aujourd'hui.
et la fin de semaine risque d'être compliqué, je suis en vacances jeudi soir.

J'ai mis 45min pour les 2 étoiles.

La première étape stockés les cubes dans un HashSet puis compter les faces non adjacente à une autre en checkant la présence dans le HashSet.

Pour la deuxième, j'ai monté un dijkstra en partant d'un espace à l'extérieur à la structure de cube. Au final, je check si le côté du cube est adjacent à une zone accessible depuis l'air.

J'ai bien galéré encore sur celui-ci ~ 4h.

La première partie est relativement simple. Je joue à Tetris dans un tableau de char.

La deuxième partie est galère car si j'utilise la méthode de la première partie ,avec un clear du tableau quand c'est possible après une ligne pleine.
Il me fallait ~20j de calcul pour approcher 1000000000000L piece.

J'ai donc identifié quand le pattern d'empilement se répète. De cette manière, j'ai rapidement le test unit de la 2eme partie qui marchait.
pour trouver 1514285714288.

Seulement, quand j'appliquais la méthode sur mon input, çà ne marchait pas.
Je suis revenu sur un jeu plus petite et j'ai comparé la première méthode et la deuxième méthode avec le raccourcis quand je détecte la répétition.
J'ai constaté qu'il me manquait 9 à chaque application de la répétition.

En ajoutant, le nombre de répétition fois 9 ,j'ai obtenu le résultat attendu.

Gg.
Je n'ai pas pensé à simplifier les chemin.
Résultat, j'ai fait un AG. il met 1h pour trouver l'optimum de la 2ème réponse :o)

çà me rassure de voir que tout le monde a ramé sur celui d'aujourd'hui.

Perso, j'y ai bien passé 4h en cumulé. J'ai commencé vers 10h et au final, mon code met presque 1h pour trouver l'optimum de la 2ème réponse avec un AG.

Je pense que j'ai du manquer une simplification du problème car normalement tous les problèmes doivent sortir sur une machine normal en moins de 10min.

Ce matin, tu étais devant moi et il y a l'air d'avoir eu un nouvelle inscrit. Résultat,je te suis repassé devant.

Pour info, On est en mode Local Score

Local Score, which awards users on this leaderboard points much like the global leaderboard. If you add or remove users, the points will be recalculated, and the order can change. For N users, the first user to get each star gets N points, the second gets N-1, and the last gets 1. This is the default.

A priori, je te suis repassé devant car avec l'arrivé d'un nouveau , çà revalorise potentiellement le N des classements précédents.

C'est clair. L'an dernier, il y en a un ou j'y ai passé + d'une demi-journée pour arriver à le faire.

C'était celui , où il fallait monter un interpréteur d'expression pour lequel, il fallait déduire le min et la max possible. J'avais beau avoir optimisé mon code avec de la mémoïsation & quelques optims. Il mettait 30min à sortir la réponse :-p.

Il y a moins de joueur que l'an dernier.

https://adventofcode.com/2021/stats
https://adventofcode.com/2022/stats

et les sujets sont plus simple pour le moment.

J'ai créé un leadboard
1844559-f65dbf07
si vous vous voulez le rejoindre, il faut l'ajouter dans votre interface sur adventofcode

Mince, je voulais faire un journal dessus. Tu m'as devancé.

Pour ma part, je compte les jours avant son lancement autant que j'attends d'ouvrir mon premier jour de mon calendrier Kinder :-p.

Est-ce que çà vous dit d'ouvrir un groupe pour les lecteurs de LFR ? de cette manière , on aura un classement LFR :)

L article est signé :
Guillaume Le Pessec
Membre du Collège des Cardiologues en Formation,
Rouen

En fait, ce n est pas un médecin, ni un professeur et il ne fait pas partie d un service de cardilogie…

Juste pour comparer, un site officiel sur la cardiologie…
Ça fait un peu moins amateur avec des titres moins accrocheurs.
https://sfcardio.fr/actualites

Il y a eu du taff pour faire le site du lien. Qui en est le commanditaire dans quel objectif ?

Il y a un truc bizarre , l historique du site fait franchement factice

Est-ce qu'il il avait le choix ?

Sérieusement, je trouve que le timing est intéressant. Il aurait pu le faire depuis des années et il le fait maintenant dans une période ou il peut passer pour l'emblème de quelqu'un qui fuit l'impérialisme américain.

Bizarrement, je ne vois pas trop son intérêt mais par contre je vois bien l intérêt pour les autorités russe.

Je vais y réfléchir pour le prochain. C'est vrai qu'on n'en parle pas assez sur LFR.

Pour ceux qu'ils ne le savent pas. Il y avait un Challenge pour faire partie la sélection de l'équipe de France fin avril
https://www.ssi.gouv.fr/agence/cybersecurite/france-cybersecurity-challenge-2022/

On peut y participer en Candidat Libre pour s'amuser. Personnelement, j'ai appris plein de chose.

Si çà vous interesse , il y a https://discord.gg/rwZY6hh8z8, on retrouve tous les postmortem des différentes épreuves, c'est très interessant.

Bonjour,

J'ai exactement les même symptomes que toi. une connection qui marche à 100Mb/s upload/download (suffisant pour moi)

Mais régulierement essentiellement sur le Wifi des téléphones. , j'ai des connexions qui sont perdu.

Je viens de tester ton script , je n'ai aucun paquet de rejeté.

Enfin, le truc bizarre, c'est que je télétravaille en wifi toute la journée sans soucis avec mon portable en liaison VPN

Par contre, dès que je suis en Wifi avec les téléphones & tablettes. J'ai régulierement des pertes de connexions.

Mes enfants en viennent à consommer leur 4G car le Wifi est vraiment trop limite.

A mon avis, c'est le wifi de la livebox qui est pourri.

Merci pour toutes ces années d information sur les logiciels libres.

Pendant des années , j'ai utilisé un pattern similaire. Il y a encore des traces sur ce projet sourceforge.
https://sourceforge.net/projects/planningrh/

Spécialement, le framework associé à ce projet.
https://sourceforge.net/p/planningrh/code/HEAD/tree/stateengine/

La force de ce pattern pour décrire un screen flow, c'est qu'une "Action | Transition" peut-être agnostique de son état de départ.
Résultat, tu peux très facilement créer des actions qui vont manipuler ta machine à état et l'utiliser depuis différents endroit .

Par exemple:

Action: "Editer une fiche client"
Cette action crée un état "fiche client" avec l'état précédent en paramètre.
L'état "fiche client" supporte alors une action ActionBack qui permet de revenir à l'état précédent.

                            |------------------|
ActionEditCustomer          |                  |    ActionBack
--------------------------->|EditCustomerState |----------------------->
                            |                  |
                            |------------------|

Tu peux alors plugger ton action éditer la fiche client dans tous les écrans qui ont un client sélectionné.
Sans ajouter de code, tu peux alors revenir sur l'écran de départ.

D'une certaines manières, VueX reprend un peu ce principe.