Liens utiles

la liste des "Advent of Code"

Antisèches Go

opérations et comparaisons [AFFICHER]

types [AFFICHER]

tableaux et dictionnaires [AFFICHER]

variables [AFFICHER]

fonctions [AFFICHER]

boucles et conditionnelles [AFFICHER]

Séance 1 (06-01-2025)

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.

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

INFO-6?? : introduction au langage Go

algorithmes, optimisation et "Advent of Code"

Hivers 2025

Liens utiles

Antisèches Go

Séance 1 (06-01-2025)

Pour gagner du temps

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