Calendrier de l'avent 🎄 (mais sans chocolats)

[Xerto]

Ah ok j’avais mal compris ce que tu faisais avant alors (je croyais que tu faisais déjà ça)

[Ewi]

A oui,j’avais pas du tout capté ca. C’est en effet, plus logique

[Donjohn]

Tu ne testes pas en remplaçant les nop pas jmp ? Car il me semble qu’il faut tester les 2 variations.

[viewww]

lol non j’avais pas vu

[viewww]

sinon j’ai cette solution qui défonce tout : def part2, do: 1626

[Donjohn]

Rigole pas, j’ai écrit des tests phpunit pour verif les données finales, au cas ou je touche à une connerie qui pète un test en amont (souvent apres refactor du part1 pour la part2)

[viewww]

j’ai des tests pour tous les jours

Mes tests

[canard]

Le subreddit regorge de perles

r/adventofcode - [Day 01] Solution in Factorio

[Ewi]

J’ai beaucoup trop de nop/jmp dans mon puzzle, rajouter la condition ne divise que par 3 le temps d’exécution

[Xerto]

J’ai amélioré un poil ma soluce : je teste désormais correctement les embranchements, c’est à dire qu’au moment de swap, je ne reprends pas de 0 mais de là où je swappe.

[silicium]

trop simple le day 8 part 1

if (($lignes = file("input8")) === false) die("erreur de lecture");
$acc = 0;
$instr = array();
$i=0;

while (! in_array($i, $instr))
{
	array_push($instr, $i);
	$ligne = trim($lignes[$i]);
	$ordre = substr($ligne, 0, 3);
	$vl = substr($ligne, 4);
	switch ($ordre)
	{
		case "acc": $acc += $vl; $i++; break;
		case "nop": $i++; break;
		case "jmp" : $i += $vl; break;
	}
}

echo "acc=" . $acc;

[Donjohn]

Pour se marrer, au taf, ya une spécialiste d’Excel qui a réussi les 2 premiers jours en .xls donc

[anon10092024]

hop, Jour 8 fini

J’ai bloqué un moment sur l’étoile 2 avant de comprendre que dict.copy() conserve le pointeur sur les inner list
J’avais bien pensé à faire des copies de ma liste de départ, mais comme je connais peu python, je me suis fait avoir.
Donc un passage par deepcopy plus tard, et ça a marché directement.

Jour 8 (python)

import re
import copy

regExp = "(?P<inst>nop|acc|jmp) (?P<value>(\+|-)\d*)"

def testProgram(program, swapInstuction = -1):
    instructionposition = 0
    accumulator = 0
    infiniteLoop = False
    while (instructionposition < len(program)) and not infiniteLoop:
        if program[instructionposition][2] > 0:
            infiniteLoop = True
        else:
            program[instructionposition][2] += 1
            instruction = program[instructionposition][0]
            if instructionposition == swapInstuction:
                if instruction == "jmp":
                    instruction = "nop"
                elif instruction == "nop":
                    instruction = "jmp"
            if instruction == "acc":
                accumulator += program[instructionposition][1]
                instructionposition += 1
            elif instruction == "jmp":
                instructionposition += program[instructionposition][1]
            elif instruction == "nop":
                instructionposition += 1
            else:
                instructionposition += 1
    return infiniteLoop, accumulator

instructions = {}
instructionposition = 0
f = open("Z:\donnees\developpement\Python\AdventOfCode\day8.txt", "r")
for line in f:
    line = line.rstrip("\n")
    match = re.match(regExp, line)

    if match:
        instruction = match.group('inst')
        value = int(match.group('value'))
        instructions[instructionposition] = [instruction, value, 0]
        instructionposition += 1
    else:
        print("Error in parsing of line {0}".format(line))
f.close()

## star1
instructionsStar1 = copy.deepcopy(instructions)
infiniteLoop, accumulator = testProgram(instructionsStar1)
if not infiniteLoop:
    print("Star 1 : Program terminated normaly - accumulator = {0}".format(accumulator))
else:
    print("Star 1 : Program interrupted due to infinite loop - accumulator = {0}".format(accumulator))

## star 2
## creating swaping list:
swappingList = []
for instructionPosition in instructions.keys():
    if instructions[instructionPosition][0] == "jmp" or instructions[instructionPosition][0] == "nop":
        swappingList.append(instructionPosition)

for id in swappingList:
    instructionTest = copy.deepcopy(instructions)
    infiniteLoop, accumulator = testProgram(instructionTest, id)
    if not infiniteLoop:
        print("Star 2 : SwapID {1} - Program terminated normaly - accumulator = {0}".format(accumulator, id))
        break

Et le résultat :

Star 1 : Program interrupted due to infinite loop - accumulator = 1941
Star 2 : SwapID 425 - Program terminated normaly - accumulator = 2096
[Finished in 0.334s]

[Ewi]

Maintenant, tu peux lire les spoilers de @viewww sur les immutable

[silicium]

J’ai trouvé çà facile et rapide, j’ai bourriné les solutions.
Si j’avais pas perdu 30 minutes à cause d’un $i=0 pas au bon niveau d’une boucle…

day 8 part2

define('FILE', "input8");
if (($lignes = file(FILE)) === false) die("erreur de lecture " . FILE);

//NOP
$j=0;
$nopc = substr_count(file_get_contents(FILE), 'nop');

while (1)
{
	//RAZ jeu
	$k=0;
	$i=0;
	$acc = 0;
	$instr = array();
	while (! in_array($i, $instr))
	{
		if ($i >= count($lignes)) die("acc=" . $acc);
		array_push($instr, $i);
		$ligne = trim($lignes[$i]);
		$ordre = substr($ligne, 0, 3);
		$vl = substr($ligne, 4);
		switch ($ordre)
		{
			case "acc": $acc += $vl; $i++; break;
			case "nop": 
				//EXPLOIT jmp
				if ($j==$k) $i += $vl;
				else $i++;
				$k++;  
				break;
			case "jmp" : $i += $vl; break;
		}
	}

	//NEXT exploit
	$j++;
	if ($j>$nopc) break;
}


$j=0;
$jmpc = substr_count(file_get_contents(FILE), 'jmp');

while (1)
{
	//RAZ jeu
	$k=0;
	$i=0;
	$acc = 0;
	$instr = array();
	while (! in_array($i, $instr))
	{
		if ($i >= count($lignes)) die("acc=" . $acc);
		array_push($instr, $i);
		$ligne = trim($lignes[$i]);
		$ordre = substr($ligne, 0, 3);
		$vl = substr($ligne, 4);
		switch ($ordre)
		{
			case "acc": $acc += $vl; $i++; break;
			case "nop": $i++; break;
			case "jmp" : 
			if ($j==$k)	$i++;
			else $i += $vl; 
			$k++;
			break;
		}
	}
	//NEXT exploit
	$j++;
	if ($j>$jmpc) break;

}

Faudra que je factorise à l’occasion !

[anon10092024]

oui j’ai vu C’est super pratique Python, mais ca fait parti de ces langages ou ca peut vite devenir crade.
La par exemple, le langage implemente une fonction .copy() pour justement faire la distinction entre un passage de pointeur et une copie.
Sauf quand tu as des listes de liste, et la c’est entre les deux. Pour moi c’est pas coherent. Le .copy() devrait etre un deep copy.
Et python est blindé de truc comme ca. C’est pratique, mais je ferai pas un gros projet sous python, a moins d’avoir vraiment des regles de codage super strictes pour compenser la permissivité du langage.

[Ewi]

Ouais. Le plus crade reste le « len() » qui n’est pas une méthode de liste. Y a plein de connerie comme ça où tu sens bien l’héritage des anciennes version.

[Mistermick]

Voilà ma version en JS ^^

Jour 8

const OK = 0
const INFINITE_LOOP = 1

let formatedData = data
.split('\n')
.map(d => d.split(' '))
.map(d => ({act:d[0], val:parseInt(d[1],10)}))

let run = (acc) => (allActions) => (stepsDone) => (currentStep) => {
    if (currentStep >= allActions.length){
        return {status:OK, val:acc}
    } else if (stepsDone.includes(currentStep)){
        return {status:INFINITE_LOOP, val:acc}
    } else {
        let stepObj = allActions[currentStep]
        if (stepObj.act === 'jmp'){
            return run(acc)(allActions)([...stepsDone,currentStep])(currentStep+stepObj.val)
        } else if (stepObj.act === 'acc') {
            return run(acc+stepObj.val)(allActions)([...stepsDone,currentStep])(currentStep+1)
        } else {
            return run(acc)(allActions)([...stepsDone,currentStep])(currentStep+1)
        }
    }
}

let fixAndRun = (stepToFix) => (allActions) => {
    if (stepToFix >= allActions.length){
        return {status:INFINITE_LOOP, val:0}
    }


    let fixedAllActions = [...allActions]
    if (allActions[stepToFix].act === 'jmp'){
        fixedAllActions[stepToFix] = {...fixedAllActions[stepToFix], act:'nop'}
    } else if (allActions[stepToFix].act === 'nop'){
        fixedAllActions[stepToFix] = {...fixedAllActions[stepToFix], act:'jmp'}
    } else {
        return fixAndRun(stepToFix+1)(allActions)
    }
    
    
    let testRun = run(0)(fixedAllActions)([])(0)
    if (testRun.status === OK){
        return testRun
    } else {
        return fixAndRun(stepToFix+1)(allActions)
    }
}

let result1 = run(0)(formatedData)([])(0)

console.log(result1)

let result2 = fixAndRun(0)(formatedData)

console.log(result2)

[canard]

@silicium

Faudra que je factorise à l’occasion !

https://www.reddit.com/r/adventofcode/comments/k8zfwd/2020_day_8_2019_flashbacks/

[silicium]

T’as raison, je m’y mettrai en 2021.

Des créations sur l’adventofcode

r/adventofcode - -❄️- Advent of Code 2020: Craft Submissions Megathread -❄️-