Liens utiles

la liste des "Advent of Code"

Antisèches Go

Les bases

opérations et comparaisons [AFFICHER]

types [AFFICHER]

tableaux et dictionnaires [AFFICHER]

variables [AFFICHER]

fonctions [AFFICHER]

boucles et conditionnelles [AFFICHER]

Niveau 2

compléments sur les dictionnaires / tableaux [AFFICHER]

point virgules [AFFICHER]

structures et définitions de types [AFFICHER]

switch [AFFICHER]

switch <EXPR> {...} : les cas sont traités dans l'ordre et seul le premier cas égal à <EXPR> est utilisé (sauf si on utilise le mot clé fallthrough).

Par exemple :

switch n {
case 0:
    fmt.Println("zéro")
case 1,2,3:
    fmt.Println("petit")
case 4:
    fmt.Println("gros")
case 5,6,7:
    fmt.Println("énorme")
default:
    fmt.Println("???")
}

Comme pour if, on peut ajouter une initialisation : switch <INIT>; <EXPR> {...}

Attention, les instructions break et continue agissent sur les switch, on ne peut donc pas les utiliser directement pour sortir d'une boucle depuis l'intérieur d'un switch.

Séance 1 (06-01-2025)

[AFFICHER]

Vérifiez que go fonctionne correctement sur votre machine, par exemple en lançant la commande
```
$ go version
```
Installez le plugin Go dans vscode, (ou un autre plugin dans un autre IDE).
Testez un programme de type bonne année (version saisonnière de hello world).
Connectez vous sur Advent of Code, par exemple avec votre compte Github.

Pour initialiser un nouveau module ("projet"), il faut lancer la commande
```
$ go mod init <NOM_DU_MODULE>
```
dans le répertoire du module.
Votre fichier doit commencer par la ligne
```
package main
```
et un des fichiers du projets doit contenir une fonction main sans argument ni valeur de retour.
Le mot clé pour définir une fonction est func, et la fonction Go pour faire un affichage simple est fmt.Println. (Attention à ne pas oublier la majuscule !) Elle fonctionne comme la fonction print de Python. Vous pouvez aussi utiliser fmt.Printf pour avoir une fonction similaire à printf du langage C. Pour utiliser fmt.Println, il faut ajouter import "fmt" en haut du du fichier. Normalement, vscode s'en chargera tout seul !
Si votre plugin Go est bien installé, votre code sera automatiquement formaté à chaque sauvegarde !
Pour lancer votre programme, il faut utiliser la commande
```
$ go run .
```
ou le lancer à partir de vscode.

Écrivez un programme pour résoudre les problèmes suivants (parties 1 et 2).

année	jours	lien
2022	1	Calorie Counting
2020	2	Password Philosophy
2021	2	Dive!

Notez bien que pour obtenir vos fichier de données personnalisés, vous devez être connecté sur le site Advent of Code.

Un problème est résolu lorsque vous avez pu valider votre réponse sur le site et que vous avez obtenu les 2 étoiles "**" correspondantes. (Ou une seule étoile "*" pour les 25 décembre.)

Note : Eric Wastl, le créateur de Advent of Code, demande explicitement que les fichiers de données ne soient pas partagés sur Internet. Ne les mettez donc pas dans un dépot Git public.

Pour gagner du temps

lecture des lignes d'un fichier

f, _ = os.Open(filename)
sc = bufio.NewScanner(f)
for sc.Scan() {
    line := sc.Text()
    ...
}

conversion depuis une chaine

Les fonctions du module strconv permettent de convertir des chaines en entiers, flottants, etc. Parcourez la documentation des fonctions strconv.Atoi, strconv.ItoA, strconv.ParseBool, strconv.ParseFloat, strconv.ParseInt, strconv.ParseUint en cas de besoin.

Attention, ces fonctions renvoient deux valeurs : le résultat et un code d'erreur. Pour ignorer ce dernier, il faut donc écrire :

var n int
n, _ = strconv.Atoi(<CHAINE>)

documentation

Vous pouvez obtenir la documentation de la bibliothèque standard avec

$ go doc bufio
$ go doc strconv.parsebool

extraction de valeurs d'une chaine formatée, à la scanf

var i, j int
var color string
fmt.Sscanf(s, "(%d,%d): %s", &i, &j, &color)

Si s est la chaine "(12,-123): rouge clair", les variables i et j auront les valeurs 12 et -123, et la variable color aura la valeur "rouge".

tri

La fonction slices.Sort permet de trier un tableau dans l'ordre croissant.

Travail à la maison

Commencez le tutoriel officiel
Parcourez les conseils de style officiels Go style guide et Go Style Decisions (notamment la partie sur les noms de variables).
Écrivez un programme qui utilise un dictionnaire et un programme qui utilise une structure (cf tutoriel), et réfléchissez aux différences entre ces 2 types de données.

Finissez les problèmes Advent of Code commencés :

2022	1	Calorie Counting
2020	2	Password Philosophy
2021	2	Dive!

Séance 2 (14-01-2025)

Écrivez des fonctions pour résoudre les problèmes suivants (parties 1 et 2).

année	jours	lien
2020	1	Report Repair
2016	1	No Time for a Taxicab
2015	4	The Ideal Stocking Stuffer

Pour chaque problème, définissez une fonction de type func (filename string) int qui renverra la solution trouvée. Vous n'aurez qu'à l'appeler dans votre fonction main avec le bon nom de fichier en argument.

Pour gagner du temps

lecture entière d'un fichier dans un tableau de bytes

T, _ = os.ReadFile(filename)

Attention, en cas d'erreur (fichier inexistant, etc.), T sera vide. Pour gérer ça, il faut regarder la deuxième valeur de retour. Par exemple, le code suivant provoque une "panique" en cas d'erreur.

T, err = os.ReadFile(filename)
if err != nil {
    panic(err)
}

les modules strings et bytes

contiennent de nombreuses fonctions sur les chaines / tableaux d'octets : Trim, Split, Join, HasPrefix, ...

Utilisez les commandes go doc strings et go doc bytes pour avoir la liste de ces fonctions.

l'empreinte MD5 d'un tableau T d'octets (type []byte)

peut se calculer de la manière suivante

import "crypto/md5"

... E := md5.Sum(T)

E contiendra alors un tableau statique avec exactement 16 octets (type [16]byte).

Attention, lors de la résolution du problème 2015-04, les "0" que vous devez chercher dans l'empreinte MD5 sont des "0" dans la représentation hexadécimale de l'empreinte. Chaque octet de l'empreinte donne deux chiffres hexadécimaux. Pour trouver cinq "0", il faut donc regarder deux octets et demi (20 bits) !

Travail à la maison

Finissez le tutoriel officiel, si ce n'est pas déjà fait.
Décrivez une manière de coder un type de tableaux dynamiques d'entiers en C pur. Il s'agit d'un type avec les opérations suivantes :
- len(T) : renvoie le nombre d'éléments du tableau,
- get(T, i) : renvoie la case numéro i (indéterminé si i ne correspond pas à une case valide),
- set(T, i, v) : mets la valeur v (un entier) dans la case numéro i (indéterminé si i ne correspond pas à une case valide),
- append(T, v) : ajoute une valeur v à la fin du tableau. (La taille du tableau doit donc augmenter de 1.)
Réfléchissez également à la complexité de ces opérations.
Écrivez une méthode show pour le type type grid map[[2]int] byte : le dictionnaire contient des caractères ASCII (type byte) à des coordonnées entières (type [2]int).

La méthode show devra afficher les caractères à leur coordonnées, mais uniquement pour la boite englobante des coordonnées présentes dans le dictionnaire. Par exemple, pour
```
G := grid(map[[2]int]byte{
    {10, -7}: 'h', {11, -7}: 'e', {12, -7}: 'l', {13, -7}: 'l', {14, -7}: 'o',
    {14, -6}: 'w', {15, -6}: 'o', {16, -6}: 'r', {17, -6}: 'l', {18, -6}: 'd',
})
G.show()
```
on obtiendra
```
$ go run .
hello    
    world
```
Vérifiez que votre code fonctionne en mettant le fichier mystere.go dans votre répertoire et en appelant
```
G := mystere()
G.show()
```

Finissez les problèmes Advent of Code commencés :

année	jours	lien
2020	1	Report Repair
2016	1	No Time for a Taxicab
2015	4	The Ideal Stocking Stuffer

tableaux	`len(T)` (taille), `T[0]` pour l'accès à une case
...	Attention `T[i]` provoque une erreur si `i<0` ou `i>=len(T)`
...	`T = append(T, 1)` ou `T = append(T, 1,2,3)` pour ajouter des éléments à la fin d'un tableau
dictionnaires	`D[k]` renvoie la valeur associée à la clé `k`, ou la valeur "zéro" si la clé n'est pas présente
...	`v, ok = D[k]` met la valeur de `D[k]` dans `v`, et un booléen dans `ok`: vrai si `k` était présente, faux sinon
initialisation (tableau)	`T := make([]int)` déclare un tableau vide d'entiers
...	`T := make([]int, 10)` déclare un tableau d'entiers de taille 10, où toutes les cases ont la valeur "zéro"
...	`T := []int{1,2,3}` déclare un tableau d'entiers de taille 3, avec les éléments `1`, `2` et `3`
initialisation (dictionnaire)	`D := make(map[string]int)` déclare un dictionnaire vide
...	`D := map[string]int{"un": 1, "deux": 2}` déclare un dictionnaire

variables (déclaration)	`var n int` : déclaration sans initialisation (valeur par défaut: "zéro")
...	`var n int = 10` : déclaration avec initialisation
...	`n := 10` : déclaration simple, le type est inféré
...	Attention : `x := 10` ou `var x int` peuvent redéfinir une nouvelle variable dans un sous bloc
affectation	`n = 10` : affectation pour une variable existante
...	`+=`, `-=`, etc. permettent de faire une mise à jours `x += 3` est équivalent à `x = x+3`, etc.
...	`i++` et `i--` sont équivalents à `i = i+1` et `i = i-1`
affectation multiple	`a,b,c = 1,2,3` affectation de plusieurs variables
déclaration multiple	`a,b,c := 1,2,3` déclaration de plusieurs variables
...	Attention, dans `a,b,c := 1,2,3` seules les variables que l'on peut (re)déclarer sont déclarées; pour les autres, cela fait une affectation

sous tableaux	`T[debut:fin]` est un tableau qui contient les valeurs de `T` depuis les indices de `debut` (inclu) à `fin` (exclu)
...	attention, contrairement à Python, les valeurs ne sont pas copiées, `T` et `T[debut:fin]` utilisent la même zone mémoire
boucles	`for i := range T {...}` permet de faire une boucle sur les indices du tableaux `T`
...	`for i, v := range T {...}` permet de faire une boucle sur les indices / valeurs du tableau `T`
...	`for k := range D {...}` permet de faire une boucle sur les clés du dictionnaire `D`
...	`for k, v := range D {...}` permet de faire une boucle sur les clés / valeurs du dictionnaire `D`

structures	ex : `struct {x int; y int; c string}` type des structures à 3 champs, etc.
...	ex : `s := struct{x int; y int; c string}{1,2,"rien"}` pour définir une variable du type précédent
...	on accède aux champs avec `s.x`, `s.y` et `s.c`
définition de type	`type <NOM> <TYPE>`
...	`type pointAnnot struct {x int; y int; c string}` pour définir un type de structures
...	`p := pointAnnot{1,2,"rien"}` pour définir une variable dans le type correspondant
...	attention, il ne faut (en général) pas mettre de `=` entre `<NOM>` et `<TYPE>`
méthodes	`func (p pointAnnot) m(<ARGUMENTS>) <RETOUR> {...}`
...	le receiver est donné avant le nom de la fonction
...	on peut définir des méthodes sur n'importe quel type qu'on a définit
...	remarque : il n'y a pas d'héritage comme en POO

INFO-6?? : introduction au langage Go

algorithmes, optimisation et "Advent of Code"

Hivers 2025

Liens utiles

Antisèches Go

Les bases

Niveau 2

Séance 1 (06-01-2025)

Pour gagner du temps

Travail à la maison

Séance 2 (14-01-2025)

Pour gagner du temps

Travail à la maison

opérations	`+`, `-`, `*`, `/` pour les entiers et flottants, `%` (modulo) pour les entiers
...	`\|\|` (ou), `&&` (et), `!` (négation) pour les booléens
...	`>>`, `<<` (décalage), `\|`, `&` (ou/et bit à bit), `^` (négation bit à bit et XOR bit à bit)
...	`+` (concaténation pour les chaines)
comparaisons	`==`, `!=`, `>`, `<`, `<=`, `>=` pour les entiers, flottants ou chaines

types	`int8`, `int16`, `int32` et `int64` entiers 8, 16, 32 ou 64 bits
...	variantes `uint8`, ..., `uint64` pour les entiers non signés ; `byte` est un synonyme de `uint8`
...	`int` et `uint` pour les entiers "machine" (32 ou 64 bits suivants l'architecture)
...	`float32` et `float64` pour les flottants 32 ou 64 bits
...	`string` pour les chaines (non mutable, comme en Python)
...	`[]int` pour les tableaux d'entiers, `[][]float64` pour les tableaux à 2 dimensions de flottants, etc.
...	`map[string] int` pour les dictionnaires avec chaines comme clés et des entiers comme valeurs, etc.

fonction	`func f(x float64, n int) {` première ligne d'une définition de fonction à 2 arguments, sans valeur de retour
...	`func f(n int) string {` première ligne d'une définition de fonction à 1 argument, qui renvoie une chaine
...	`func f(n int) (string, bool) {` première ligne d'une définition de fonction à 1 argument, qui renvoie 2 valeurs
...	Attention, si `f` renvoie 2 valeurs, il faut utiliser 2 variables pour enregistrer le résultat : `s, b := f(12)`.
...	On peut ignorer un des résultats avec `_` : `s, _ := f(12)`

conditionnelles	`if <CONDITION> {...} else {...}`
...	`if <INIT>; <CONDITION> {...} else {...}` permet de définir des variables (avec `:=`) uniquement pour la conditionnelle
boucles	`for <INIT>; <CONDITION>; <MAJ> {...}`
...	`for <CONDITION> {...}` (c'est la boucle while !)
...	`for {...}` pour une boucle infinie
...	`continue` et `break` fonctionnent comme d'habitude