OSEC-5?? : introduction au langage Go

algorithmes, optimisation et "Advent of Code"

Automne 2025

• Liens utiles

• Antisèches Go

  • Les bases

  • Niveau 2

• Séance 1 (18-09-2025)

  • Pour gagner du temps

  • Travail à la maison

• Séance 2 (24-09-2025)

  • Pour gagner du temps

  • Travail à la maison

• Séance 3 (03-10-2025)

  • Pour gagner du temps

  • Travail à la maison

• Séance 4 (7-10-2025)

  • Pour gagner du temps

  • Travail à la maison

• Séances 5, 6, 7, ... (14-10-2025, ...) : mini projet

Liens utiles

• la page du langage Go

• le tutoriel officiel

• la spécification complète de Go

• la liste des "Advent of Code"

Antisèches Go

Les bases

opérations et comparaisons [AFFICHER]

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 [AFFICHER]

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.

tableaux et dictionnaires [AFFICHER]

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 [AFFICHER]

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

fonctions [AFFICHER]

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)

boucles et conditionnelles [AFFICHER]

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

Niveau 2

compléments sur les dictionnaires / tableaux [AFFICHER]

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

point virgules [AFFICHER]

En général, un retour chariot termine une instruction. Plus précisément :

• le séparateur d'instruction ; est inséré à la fin d'une ligne si

  • le token précédent est un identifiant,

  • le token précédent est un nombre ou une chaine (ou une "rune", càd un littéral unicode),

  • le token précédent est un des mots clé break, continue ou return (ou fallthrough),

  • le token précédent est ++, --, ), }, ].

• Un séparateur d'instruction ; peut être omis avant ) ou }.

structures et définitions de types [AFFICHER]

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

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 (18-09-2025)

[AFFICHER]

Séance 2 (24-09-2025)

[AFFICHER]

Séance 3 (03-10-2025)

[AFFICHER]

Séance 4 (7-10-2025)

[AFFICHER]

Séances 5, 6, 7, ... (14-10-2025, ...) : mini projet

Remarques sur la page (ou le sujet) : contact.

,

Dernière révision: le 14-10-2025 à 17:00.

mentions légales