[blabla@olympe] Le topic du modo, dieu de la fibre et du monde

J'ai à un moment le nombre 41426456027.
 
Considérons l'opération new = old + 7  à effectuer et un test de divisibilité par 3 (qui est la configuration d'un de mes monkeys).
 
Le code qui fonctionne (= donc la réponse est validée par le formulaire de l'AoC) et n'applique pas une division par le LCM
41426456027 + 7 = 41426456034
41426456034 / 3 = 13808818678 (on est en partie un, il faut diviser par 3)
13808818678 mod 3 = 1
 
Si on applique en amont la division par le LCM (dans mon cas 9699690) :
41426456027 mod 9699690 = 8779727
8779727 + 7 = 8779734
8779727 / 3 = 2926578
2926578 mod 3 = 0
 
Du coup dans un cas j'ai 1 en sortie et dans l'autre cas j'ai 0, donc ça oriente pas vers le même singe ensuite.
 
Et j'ai 2 autres nombres comme ça qui posent ce souci : 6648690481 et 1067073787.
 
Avec mon jeu de données https://github.com/ratibus/adventof [...] /input.txt tu as combien en partie 1 ? Le résultat attendu par AoC est : 88208
Si je divise par le LCM, j'obtiens 87615.

oui

using System.Collections.ObjectModel;
 
Collection<Monkey> AllMonkeys = new Collection<Monkey>();
 
void InitAllMonkeys()
{
    AllMonkeys.Clear();
    AllMonkeys.Add(new Monkey(new UInt64[] { 71, 56, 50, 73                 }, wl => wl * 11, wl => ((wl % 13) == 0) ? 1 : 7));
    AllMonkeys.Add(new Monkey(new UInt64[] { 70, 89, 82                     }, wl => wl + 1 , wl => ((wl %  7) == 0) ? 3 : 6));
    AllMonkeys.Add(new Monkey(new UInt64[] { 52, 95                         }, wl => wl * wl, wl => ((wl %  3) == 0) ? 5 : 4));
    AllMonkeys.Add(new Monkey(new UInt64[] { 94, 64, 69, 87, 70             }, wl => wl + 2 , wl => ((wl % 19) == 0) ? 2 : 6));
    AllMonkeys.Add(new Monkey(new UInt64[] { 98, 72, 98, 53, 97, 51         }, wl => wl + 6 , wl => ((wl %  5) == 0) ? 0 : 5));
    AllMonkeys.Add(new Monkey(new UInt64[] { 79                             }, wl => wl + 7 , wl => ((wl %  2) == 0) ? 7 : 0));
    AllMonkeys.Add(new Monkey(new UInt64[] { 77, 55, 63, 93, 66, 90, 88, 71 }, wl => wl * 7 , wl => ((wl % 11) == 0) ? 2 : 4));
    AllMonkeys.Add(new Monkey(new UInt64[] { 54, 97, 87, 70, 59, 82, 59     }, wl => wl + 8 , wl => ((wl % 17) == 0) ? 1 : 3));
}
 
InitAllMonkeys();
 
UInt64 MaxWorryLevel = 13 * 7 * 3 * 19 * 5 * 2 * 11 * 17;
 
for (int round = 1; round <= 20; ++round)
{
    for (int monkeyID = 0; monkeyID < AllMonkeys.Count; ++monkeyID)
    { // Monkey turn
        Monkey monkey = AllMonkeys[monkeyID];
        while (monkey.Items.Count != 0)
        {
            ++monkey.inspectionCount;
            UInt64 wl = monkey.Items[0];
            monkey.Items.RemoveAt(0);
            wl = (monkey.operationOp(wl) / 3) % MaxWorryLevel;
            AllMonkeys[monkey.nextMonkeyOp(wl)].Items.Add(wl);
        }
    }
}
 
Console.WriteLine("1 = " + AllMonkeys.Select( m => m.inspectionCount ).OrderBy( ic => ic ).Skip( AllMonkeys.Count-2 ).Aggregate( (a, b) => a*b ) ) ;
 
InitAllMonkeys();
 
for (int round = 1; round <= 10000; ++round)
{
    for (int monkeyID = 0; monkeyID < AllMonkeys.Count; ++monkeyID)
    { // Monkey turn
        Monkey monkey = AllMonkeys[monkeyID];
        while (monkey.Items.Count != 0)
        {
            ++monkey.inspectionCount;
            UInt64 wl = monkey.Items[0];
            monkey.Items.RemoveAt(0);
            wl = monkey.operationOp(wl) % MaxWorryLevel;
            AllMonkeys[monkey.nextMonkeyOp(wl)].Items.Add(wl);
        }
    }
}
 
Console.WriteLine("2 = " + AllMonkeys.Select(m => m.inspectionCount).OrderBy(ic => ic).Skip(AllMonkeys.Count - 2).Aggregate((a, b) => a * b));
 
public class Monkey
{
    public UInt64 inspectionCount = 0;
    public Collection<UInt64> Items = new Collection<UInt64>();
    public delegate UInt64 OperationOp(UInt64 wl);
    public OperationOp operationOp;
    public delegate int NextMonkeyOp(UInt64 item);
    public NextMonkeyOp nextMonkeyOp;
    public Monkey(UInt64[] items, OperationOp op, NextMonkeyOp nm)
    {
        foreach (UInt64 i in items) Items.Add(i);
        operationOp = op;
        nextMonkeyOp = nm;
    }
}

Ca fonctionne chez vous la partie 1, si vous faites un % LCM après la division entière par 3 ? Je pensais que la division par le LCM allait tout le temps fonctionner mais j'ai dû rater un truc dans le raisonnement.

Quand je veux mettre cette ligne tout le temps (et pas uniquement dans la partie 2), ça casse ma partie 1 (mais pas sur les données de test) : https://github.com/ratibus/adventof [...] ve.php#L53
Je comprends pas pourquoi.

package AOC2022

import java.io.File

class Day11 {

   data class Monkey(val items: MutableList<Long>,
                 private val operation: String,
                 private val test: Long,
                 private val throwToIfTrue: Int, private val throwToIfFalse: Int) {

       var inspected = 0

       fun operate(item : Long): Long {
            var worry = operation.split(' ')
                .let { (instr, operand) ->
                    when(instr) {
                        "+" -> item + if (operand != "old" ) operand.toLong() else item
                        "*" -> item * if (operand != "old" ) operand.toLong() else item
                        else -> throw Exception("Unknown operation: $instr" )
                    }
                }
            return worry / 3
        }

       fun throwTo(worryLevel: Long) : Pair<Int, Long> {
            inspected++
            return Pair(if (worryLevel % test == 0L) throwToIfTrue else throwToIfFalse, worryLevel)
        }
    }

   var monkeys: MutableList<Monkey> = mutableListOf()

   fun parse(lines: List<String> ): List<Monkey> {
        var numChunk = 0
        val chunks = lines
            .chunked(7)
            .map { it.filter { it.isNotBlank() } }
        for(chunk in chunks) {
                monkeys.add(
                    Monkey(
                        chunk[1].substring(18).split(',').map { it.trim().toLong() }.toMutableList(),
                        chunk[2].substring(23).trim(),
                        chunk[3].substring(20).trim().toLong(),
                        chunk[4].substring(29).trim().toInt(),
                        chunk[5].substring(29).trim().toInt(),
                    )
                )
        }
        return monkeys
    }

   fun part1(lines: List<String> ): Int {
        for (monkey in parse(lines)) {
            println(monkey)
        }
        (1..20).forEach{ i ->
            println("Round " + i)
            for(monkey in monkeys) {
                for (item in monkey.items.toLongArray()) {   // copy to avoid concurrent modification
                    monkey.items.removeAt(0)
                    val (recipient, item) = monkey.throwTo(monkey.operate(item))
                    monkeys[recipient].items.add(item)
                }
            }
            for(monkey in monkeys) {
                println("${monkey}, ${monkey.inspected}" )
            }
        }
        val sortedByInspected = monkeys.map { it.inspected }.sortedByDescending { it }
        return monkeys[0].inspected * monkeys[1].inspected
    }

   fun part2(lines: List<String>  ): Unit {
    }
}

fun main() {
    val lines = File("src/main/kotlin/AOC2022/input11.txt" ).readLines()
    val day11 = Day11()
    println(day11.part1(lines))
    println(day11.part2(lines))
}

https://rehost.diberie.com/Picture/Get/r/113521

J'ai cru que j'avais le cerveau trop brumeux pour faire la partie 1 en une passe, mais c'est au calcul du total que j'avais introduit un décalage de 1 [:el g]
https://github.com/mrossard/aoc2022 [...] /day10.php