Advent of Code 2020

Bon, je m’y prends un peu tard car je n’avais pas pensé à en faire un sujet avant que @asyd ne me le souffle dans l’oreille ce matin…

Si vous trainez sur IRC, vous n’êtes sans doute pas passé à côté du petit défi annuel qui nous anime en cette période, je veux bien sûr parler de l’Advent of Code.

Il s’agit d’une petite compétition qui existe désormais depuis de nombreuses années et qui rassemble des milliers de développeurs dans le monde.

Le but du jeu est simple : vous avez un énoncé (en anglais) d’un problème à résoudre ainsi qu’un “input” personnalisé (les données sont différentes pour tout le monde). Avec cela et armé de votre langage préféré (que j’espère être Python évidemment :stuck_out_tongue:), vous devez résoudre le problème et fournir le résultat au site.

Comme un calendrier de l’Avant, vous avez un problème à résoudre par jour avec une difficulté croissante dans le temps (c’est subjectif). Chaque problème est en deux parties, la première faisant office d’introduction au problème et la seconde vous demandant d’être plus créatif ou d’optimiser votre solution existante (et parfois de la refaire complètement car vous ne pouviez pas anticiper).

Les problèmes sortent tous les jours vers 6h du matin, un nombre défini de points est reversé aux joueurs qui iront le plus vite, mais il est possible de créer des leaderboards personnalisés si vous souhaitez vous challenger entre vous.

Bon après on ne va pas se mentir, le top 100 du classement est trusté par des monstres experts de ce genre d’énigmes et qui poussent le délire plus loin en ce mettant divers défis, comme des ultra optimisations en temps et/ou mémoire, l’usage d’un langage “non adapté” ou préhistorique, du code-golfing où l’objectif est de faire le script le plus court possible (au point où certains ont même inventé leur propre langage pour cela…).

Bref, il est un peu “tard” pour créer un thread journalier sur cette petite compétition amicale, mais je vous encourage à y participer même avec du retard, le plus important c’est de s’amuser et de découvrir d’autres facette de son langage de programmation favori !

D’ailleurs plusieurs membres y participent, vous pouvez retrouver leurs dépôts ici :

La liste n’est pas exhaustive, n’hésitez pas à me le dire si vous souhaitez que je rajoute le votre.
Comme vous pourrez peut-être le constater, il n’y a pas qu’une seule manière de résoudre les problèmes donnés, vous pouvez être sûrs que chacun aura sa propre méthode, ce qui en fait un outil riche d’enseignements !

Egalement, sachez que la communauté autour de ce jeu est très active sur Reddit, je vous encourage à aller jeter un oeil, ça débat parfois vivement mais on y apprend des choses intéressantes !

2 J'aime

Bonjour,
J’ai aussi participé cette année pour la première fois (https://github.com/albatros69/aoc-2020).
Y-a-t il un leaderbord privé de l’AfPy ?
À+

Bonjour,

Voici mes solutions cette année : GitHub - dancergraham/advent_of_code_2020: Advent of Code 2020

39 étoiles jusqu’ici…

Pas a ma connaissance.

haha pareil ! après c’était les vacances on va dire :slight_smile:

1 J'aime

Pour le jour 17 j’ai fait quelques visualisations sous Rhino3D, scripté en IronPython 2.7:

J’ai fait des sphères car il ne faut qu’un centre et radius alors qu’il faut définir les 8 vertices dans le bon ordre pour créer des cubes ! Simple à faire mais pas envie :upside_down_face:

Mon script :

import rhinoscriptsyntax as rs
import Rhino
from itertools import permutations
from collections import defaultdict

def conway_cubes(rounds, draw = True, dimensions = 2):
    rs.EnableRedraw(False)


    # Example from the puzzle
    state = """.#.
..#
###"""

    # My puzzle input
    state = """..#..##.
#.....##
##.#.#.#
..#...#.
.###....
######..
.###..#.
..#..##."""


    
    new_cubes = set()
    # Build the starting grid
    for y, row in enumerate(state.splitlines()):
        for x, cell in enumerate(row):
            if cell == '#':
                new_cubes.add((x,y) + (0,) * (dimensions - 2))
    
    # Initialise sets and lists 
    old_spheres = []
    neighbouring = set(permutations([1,0,-1]* dimensions,dimensions)) 
    neighbouring.remove((0,)*dimensions) # a cube is not its own neighbour
    
    for round in range(rounds+1):
        cubes = new_cubes.copy()
        rs.DeleteObjects(old_spheres)
        neighbours = defaultdict(int)
        old_spheres=set()
        answer = 0
        
        # Draw cubes and identify neighbours
        for cube in cubes:
            if draw:
                old_spheres.add(rs.AddSphere(cube[:min(3,dimensions)], 0.6))
            answer += 1
            for n in neighbouring:
                neighbours[tuple(cube[i] + n[i] for i in range(dimensions))] += 1
        new_cubes = set()
        rs.Redraw()
        
        # Apply rules for creation of cubes in next round
        for location, n in neighbours.iteritems():
            if location in cubes:
                if 2 <= n <= 3:
                    new_cubes.add(location)
            elif n == 3:
                new_cubes.add(location)
    rs.EnableRedraw()
    print(answer)


if  __name__ == '__main__':
    conway_cubes(rounds = 6, draw = True, dimensions =4)
2 J'aime