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
https://github.com/mrossard/aoc2022 [...] /day10.php

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))
}

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.

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.

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;
    }
}

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.