Remove french subjects

subjects/abort.fr.md

@@ -1,40 +0,0 @@
-## abort
-
-### Instructions
-
-Écrire une fonction qui retournes la médiane de 5 arguments.
-
-### Fonction attendue
-
-```go
-func Abort(a, b, c, d, e int) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	middle := piscine.Abort(2, 3, 8, 5, 7)
-	fmt.Println(middle)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-5
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/activebits.fr.md

@@ -1,40 +0,0 @@
-## activebits
-
-### Instructions
-
-Écrire une fonction, `ActiveBits`, qui retourne le nombre de `bits` actifs (`bits` ayant la valeur 1) dans la représentation binaire d'un nombre entier.
-
-### Fonction attendue
-
-```go
-func ActiveBits(n int) uint {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	nbits := piscine.ActiveBits(7)
-	fmt.Println(nbits)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-3
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/addprimesum.fr.md

@@ -1,20 +0,0 @@
-## addprimesum
-
-### Instructions
-
-Écrire un programme qui prend un entier positif comme argument et qui affiche la somme de tous les nombres premiers inférieurs ou égaux à celui-ci, suivie d'un retour à la ligne (`'\n'`).
-
-- Si le nombre d'arguments est différent de 1, ou si l'argument n'est pas un nombre positif, le programme affiche `0` suivi d'un retour à la ligne.
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test 5
-10
-student@ubuntu:~/[[ROOT]]/test$ ./test 7
-17
-student@ubuntu:~/[[ROOT]]/test$ ./test 5 7
-0
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/advancedsortwordarr.fr.md

@@ -1,43 +0,0 @@
-## advancedsortwordarr
-
-### Instructions
-
-Écrire une fonction `AdvancedSortWordArr` qui trie un tableau de `string`, basé sur la fonction `f` passée en paramètre.
-
-### Fonction attendue
-
-```go
-func AdvancedSortWordArr(array []string, f func(a, b string) int) {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-
-	result := []string{"a", "A", "1", "b", "B", "2", "c", "C", "3"}
-	piscine.AdvancedSortWordArr(result, piscine.Compare)
-
-	fmt.Println(result)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-[1 2 3 A B C a b c]
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/alphacount.fr.md

@@ -1,44 +0,0 @@
-## alphacount
-
-### Instructions
-
-Write a function that counts only the letters of a `string` and that returns that count.
-White spaces or any other characters should not be counted.
-
-The letters are only the ones from the latin alphabet.
-
-### Expected function
-
-```go
-func AlphaCount(str string) int {
-
-}
-```
-
-### Usage
-
-Here is a possible program to test your function :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	str := "Hello 78 World!    4455 /"
-	nb := piscine.AlphaCount(str)
-	fmt.Println(nb)
-}
-```
-
-And its output :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-10
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/alphamirror.fr.md

@@ -1,27 +0,0 @@
-## alphamirror
-
-### Instructions
-
-Écrire un programme nommé `alphamirror` qui prend une `string` comme argument et qui affiche cette `string` après remplacement de chaque caractère alphabétique avec son opposé.
-
-Les majuscules restent des majuscules, de même pour le minuscules, par exemple :
-
-'a' devient 'z', 'Z' devient 'A'
-'d' devient 'w', 'M' devient 'N'
-
-Le résultat final sera suivi d'un retour à la ligne (`'\n'`).
-
-Si le nombre d'arguments est différent de 1, le programme affiche seulement un retour à la ligne (`'\n'`).
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/alphamirror$ go build
-student@ubuntu:~/[[ROOT]]/alphamirror$ ./alphamirror "abc"
-zyx
-student@ubuntu:~/[[ROOT]]/alphamirror$ ./alphamirror "My horse is Amazing." | cat -e
-Nb slihv rh Znzarmt.$
-student@ubuntu:~/[[ROOT]]/alphamirror$ ./alphamirror | cat -e
-$
-student@ubuntu:~/[[ROOT]]/alphamirror$
-```

subjects/any.fr.md

@@ -1,49 +0,0 @@
-## any
-
-### Instructions
-
-Écrire une fonction `Any` qui retourne `true`, pour un tableau de `string` :
-
-- si, lorsque ce tableau de `string` est passé à travers une fonction `f`, au moins un element retourne `true`.
-
-### Fonction attendue
-
-```go
-func Any(f func(string) bool, arr []string) bool {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	tab1 := []string{"Hello", "how", "are", "you"}
-	tab2 := []string{"This", "is", "4", "you"}
-
-	result1 := piscine.Any(piscine.IsNumeric, tab1)
-	result2 := piscine.Any(piscine.IsNumeric, tab2)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-false
-true
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/appendrange.fr.md

@@ -1,47 +0,0 @@
-## appendrange
-
-### Instructions
-
-Écrire une fonction qui prend un `int` minimum et un `int` maximum comme paramètres. Cette fonction retourne une slice d'`int` avec toutes les valeurs comprises entre le minimum et le maximum.
-
-Le minimum est inclus, le maximum est exclu.
-
-Si le minimum est supérieur ou égal au maximum, une slice `nil` est retournée.
-
-`make` n'est pas autorisé pour cet exercice.
-
-### Fonction attendue
-
-```go
-func AppendRange(min, max int) []int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.AppendRange(5, 10))
-	fmt.Println(piscine.AppendRange(10, 5))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-[5 6 7 8 9]
-[]
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/atoi.fr.md

@@ -1,77 +0,0 @@
-## atoi
-
-### Instructions
-
-- Écrire une fonction qui reproduit le comportement de la fonction `Atoi` en Go. `Atoi` transforme un nombre représenté en `string` (chaîne de caractères) en `int` (entier).
-
-- `Atoi` retourne `0` si la `string` n'est pas considéré un nombre valide. Pour cet exercice des **`string` non valides seront testées!**. Certaines contiendront d'autres caractères que des chiffres.
-
-- Pour cet exercice la gestion des signes + ou - **doit être** prise en compte.
-
-- Cette fonction aura **seulement** à retourner l'`int` (entier). Pour cet exercice le retour d'erreur d'atoi de go n'est pas demandé.
-
-### Fonction attendue
-
-```go
-func Atoi(s string) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	s := "12345"
-	s2 := "0000000012345"
-	s3 := "012 345"
-	s4 := "Hello World!"
-	s5 := "+1234"
-	s6 := "-1234"
-	s7 := "++1234"
-	s8 := "--1234"
-
-	n := piscine.Atoi(s)
-	n2 := piscine.Atoi(s2)
-	n3 := piscine.Atoi(s3)
-	n4 := piscine.Atoi(s4)
-	n5 := piscine.Atoi(s5)
-	n6 := piscine.Atoi(s6)
-	n7 := piscine.Atoi(s7)
-	n8 := piscine.Atoi(s8)
-
-	fmt.Println(n)
-	fmt.Println(n2)
-	fmt.Println(n3)
-	fmt.Println(n4)
-	fmt.Println(n5)
-	fmt.Println(n6)
-	fmt.Println(n7)
-	fmt.Println(n8)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-12345
-12345
-0
-0
-1234
--1234
-0
-0
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/atoibase.fr.md

@@ -1,59 +0,0 @@
-## atoibase
-
-### Instructions
-
-Écrire une fonction qui prend un nombre `string` et sa base `string` en paramètres et retourne sa conversion en `int`.
-
-Si la base n'est pas valide elle retourne `0`:
-
-Règles de validité d'une base :
-
-- Une base doit contenir au moins 2 caractères.
-- Chaque caractère d'une base doit être unique.
-- Une base ne doit pas contenir les caractères `+` ou `-`.
-
-Seuls des nombres en `string` valides seront testés.
-
-La fonction **ne doit pas** gérer les nombres négatifs.
-
-### Fonction attendue
-
-```go
-func AtoiBase(s string, base string) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.AtoiBase("125", "0123456789"))
-	fmt.Println(piscine.AtoiBase("1111101", "01"))
-	fmt.Println(piscine.AtoiBase("7D", "0123456789ABCDEF"))
-	fmt.Println(piscine.AtoiBase("uoi", "choumi"))
-	fmt.Println(piscine.AtoiBase("bbbbbab", "-ab"))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-125
-125
-125
-125
-0
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/atoibaseprog.fr.md

@@ -1,69 +0,0 @@
-## atoibaseprog
-
-##**AVERTISSEMENT! TRÈS IMPORTANT!**
-
-Pour cet exercice une fonction sera testée **avec le main de l'examen**. Cependant l'étudiant **doit quand même** rendre un programme structuré:
-
-Cela signifie que:
-
-- Le package doit être nommé `package main`.
-- Le code rendu doit avoir une fonction main déclarée(`func main()`) même si elle est vide.
-- La fonction main déclarée doit **aussi passer** le `Restrictions Checker`(le testeur de fonctions illégales). Il est conseillé à l'étudiant de rendre une fonction main vide après ses tests finis.
-- Toutes les autres régles sont les mêmes que pour un `programme`.
-
-### Instructions
-
-Écrire une fonction qui prend un nombre `string` et sa base `string` en paramètres et retourne sa conversion en `int`.
-
-Si la base n'est pas valide elle retourne `0`:
-
-Règles de validité d'une base :
-
-- Une base doit contenir au moins 2 caractères.
-- Chaque caractère d'une base doit être unique.
-- Une base ne doit pas contenir les caractères `+` ou `-`.
-
-Seuls des nombres en `string` valides seront testés.
-
-La fonction **ne doit pas** gérer les nombres négatifs.
-
-### Fonction attendue
-
-```go
-func AtoiBase(s string, base string) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-)
-
-func main() {
-	fmt.Println(AtoiBase("125", "0123456789"))
-	fmt.Println(AtoiBase("1111101", "01"))
-	fmt.Println(AtoiBase("7D", "0123456789ABCDEF"))
-	fmt.Println(AtoiBase("uoi", "choumi"))
-	fmt.Println(AtoiBase("bbbbbab", "-ab"))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/test$ go build
-student@ubuntu:~/test$ ./test
-125
-125
-125
-125
-0
-student@ubuntu:~/test$
-```

subjects/basicatoi.fr.md

@@ -1,57 +0,0 @@
-## basicatoi
-
-### Instructions
-
-- Écrire une fonction qui reproduit le comportement de la fonction atoi en Go. Atoi transforme un nombre représenté en `string` (chaîne de caractères) en `int` (entier).
-
-- Atoi retourne `0` si la `string` n'est pas considéré un nombre valide. Pour cet exercice **seulement des** `string` **valides** seront testées. Elles ne contiendront que un ou plusieurs chiffres comme charact.
-
-- Pour cet exercice la gestion des signes `+` ou `-` ne doit pas être prise en compte.
-
-- Cette fonction aura **seulement** à retourner l'`int` (entier). Pour cet exercice le retour d'erreur d'atoi de go n'est pas demandé.
-
-### Fonction attendue
-
-```go
-func BasicAtoi(s string) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	s := "12345"
-	s2 := "0000000012345"
-	s3 := "000000"
-
-	n := piscine.BasicAtoi(s)
-	n2 := piscine.BasicAtoi(s2)
-	n3 := piscine.BasicAtoi(s3)
-
-	fmt.Println(n)
-	fmt.Println(n2)
-	fmt.Println(n3)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-12345
-12345
-0
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/basicatoi2.fr.md

@@ -1,62 +0,0 @@
-## basicatoi2
-
-### Instructions
-
-- Écrire une fonction qui reproduit le comportement de la fonction atoi en Go. Atoi transforme un nombre représenté en `string` (chaîne de caractères) en `int` (entier).
-
-- Atoi retourne `0` si la `string` n'est pas considérée comme un nombre valide. Pour cet exercice des **`string` non valides seront testées!**. Certaines contiendront d'autres caractères que des chiffres.
-
-- Pour cet exercice la gestion des signes `+` ou `-` ne doit pas être prise en compte.
-
-- Cette fonction aura **seulement** à retourner l'`int` (entier). Pour cet exercice le retour d'erreur d'atoi de go n'est pas demandé.
-
-### Fonction attendue
-
-```go
-func BasicAtoi2(s string) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	s := "12345"
-	s2 := "0000000012345"
-	s3 := "012 345"
-	s4 := "Hello World!"
-
-	n := piscine.BasicAtoi2(s)
-	n2 := piscine.BasicAtoi2(s2)
-	n3 := piscine.BasicAtoi2(s3)
-	n4 := piscine.BasicAtoi2(s4)
-
-	fmt.Println(n)
-	fmt.Println(n2)
-	fmt.Println(n3)
-	fmt.Println(n4)
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-12345
-12345
-0
-0
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/basicjoin.fr.md

@@ -1,40 +0,0 @@
-## basicjoin
-
-### Instructions
-
-Écrire une fonction qui retourne la concaténation de toutes les `string` d'un slice de `string` passées en paramètres.
-
-### Fonction attendue
-
-```go
-func BasicJoin(strs []string) string {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	toConcat := []string{"Hello!", " How", " are", " you?"}
-	fmt.Println(piscine.BasicJoin(toConcat))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-Hello! How are you?
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/boolean.fr.md

@@ -1,50 +0,0 @@
-## boolean
-
-### Instructions
-
-Créer un fichier `.go`.
-
-- Le code ci-dessous doit être copié dans ce fichier.
-
-- Les changements nécéssaires doivent être appliqués pour que le programme fonctionne.
-
-- Le programme doit être rendu dans un dossier nommé `boolean`.
-
-### Code à copier
-
-```go
-func printStr(str string) {
-	arrayStr := []rune(str)
-
-	for i := 0; i < len(arrayStr); i++ {
-		z01.PrintRune(arrayStr[i])
-	}
-	z01.PrintRune('\n')
-}
-
-func isEven(nbr int) boolean {
-	if even(nbr) == 1 {
-		return yes
-	} else {
-		return no
-	}
-}
-
-func main() {
-	if isEven(lengthOfArg) == 1 {
-		printStr(EvenMsg)
-	} else {
-		printStr(OddMsg)
-	}
-}
-```
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/boolean$ go build
-student@ubuntu:~/[[ROOT]]/boolean$ ./boolean "not" "odd"
-I have an even number of arguments
-student@ubuntu:~/[[ROOT]]/boolean$ ./boolean "not even"
-I have an odd number of arguments
-```

subjects/brackets.fr.md

@@ -1,27 +0,0 @@
-## brackets
-
-### Instructions
-
-Écrire un programme qui prend un nombre indéfini de `string` en arguments. Pour chaque argument, si l'expression est correctement "entre parenthèses" (bracketed), le programme affiche sur la sortie standard `OK` suivi d'un retour à la ligne (`'\n'`), autrement il affiche `Error` suivi d'un retour à la ligne.
-
-Les symboles considérés comme des parenthèses sont `(` et `)`, les crochets `[` et `]` et les accolades `{` et `}`. Tout autre symbole est simplement ignoré.
-
-Une parenthèse ouvrante doit toujours être fermée par la parenthèse correspondante dans l'ordre correct. Une `string` qui ne contient aucune parenthèse est considérée comme une `string` correctement "entre parenthèses".
-
-Si il n'y a pas d'argument, le programme affiche seulement un retour à la ligne.
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/brackets$ go build
-student@ubuntu:~/[[ROOT]]/brackets$ ./brackets '(johndoe)' | cat -e
-OK$
-student@ubuntu:~/[[ROOT]]/brackets$ ./brackets '([)]' | cat -e
-Error$
-student@ubuntu:~/[[ROOT]]/brackets$ ./brackets '' '{[(0 + 0)(1 + 1)](3*(-1)){()}}' | cat -e
-OK$
-OK$
-student@ubuntu:~/[[ROOT]]/brackets$ ./brackets | cat -e
-$
-student@ubuntu:~/[[ROOT]]/brackets$
-```

subjects/brainfuck.fr.md

@@ -1,35 +0,0 @@
-## brainfuck
-
-### Instructions
-
-Écrire un program interpréteur du `Brainfuck`.
-Le code source sera donné en premier paramètre.
-Le code sera toujours valide, avec moins de 4096 opérations.
-Le `Brainfuck` est un langage minimaliste. Il consiste en un slice de `byte` (octets) (dans cet exercise 2048 octets) tous initialisés à zéro, et avec un pointeur sur le premier octet.
-
-Chaque opérateur consiste en un seul caractère :
-
-- '>' incrémente le pointeur
-- '<' décrémente le pointeur
-- '+' incrémente le byte pointé
-- '-' décrémente le byte pointé
-- '.' affiche le byte pointé sur la sortie standard
-- '[' se rend à son ']' correspondant si le byte pointé est 0 (début de la boucle)
-- ']' se rend à son '[' correspondant si le byte pointé n'est pas 0 (fin de la boucle)
-
-Tout autre caractère est un commentaire.
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/brainfuck$ go build
-student@ubuntu:~/[[ROOT]]/brainfuck$ ./brainfuck "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>." | cat -e
-Hello World!$
-student@ubuntu:~/[[ROOT]]/brainfuck$ ./brainfuck "+++++[>++++[>++++H>+++++i<<-]>>>++\n<<<<-]>>--------.>+++++.>." | cat -e
-Hi$
-student@ubuntu:~/[[ROOT]]/brainfuck$ ./brainfuck "++++++++++[>++++++++++>++++++++++>++++++++++<<<-]>---.>--.>-.>++++++++++." | cat -e
-abc$
-student@ubuntu:~/[[ROOT]]/brainfuck$ ./brainfuck | cat -e
-$
-student@ubuntu:~/[[ROOT]]/brainfuck$
-```

subjects/btreeapplybylevel.fr.md

@@ -1,46 +0,0 @@
-## btreeapplybylevel
-
-### Instructions
-
-Écrire une fonction, `BTreeApplyByLevel`, qui applique la fonction donnée par `fn` à chacune des nodes de l'arbre donné par `root`.
-
-### Fonction attendue
-
-```go
-func BTreeApplyByLevel(root *TreeNode, fn interface{})  {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	piscine.BTreeApplyByLevel(root, fmt.Println)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-4
-1
-7
-5
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/btreeapplyinorder.fr.md

@@ -1,47 +0,0 @@
-## btreeapplyinorder
-
-### Instructions
-
-Écrire une fonction qui applique une fonction en ordre (in order) à chaque élément de l'arbre (voir les "in order tree walks").
-
-### Fonction attendue
-
-```go
-func BTreeApplyInorder(root *TreeNode, f func(...interface{}) (int, error)) {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	piscine.BTreeApplyInorder(root, fmt.Println)
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-1
-4
-5
-7
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/btreeapplypostorder.fr.md

@@ -1,47 +0,0 @@
-## btreeapplypostorder
-
-### Instructions
-
-Écrire une fonction qui applique une fonction en post-ordre ("postorder walk") à chaque élément de l'arbre.
-
-### Fonction attendue
-
-```go
-func BTreeApplyPostorder(root *piscine.TreeNode, f func(...interface{}) (int, error)) {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine "."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	BTreeApplyPostorder(root, fmt.Println)
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/btreeinsertdata$ go build
-student@ubuntu:~/[[ROOT]]/btreeinsertdata$ ./btreeinsertdata
-1
-5
-7
-4
-student@ubuntu:~/[[ROOT]]/btreeinsertdata$
-```

subjects/btreeapplypreorder.fr.md

@@ -1,47 +0,0 @@
-## btreeapplypreorder
-
-### Instructions
-
-Écrire une fonction qui applique une fonction en pré-ordre ("preorder walk") à chaque élément de l'arbre.
-
-### Fonction attendue
-
-```go
-func BTreeApplyPreorder(root *TreeNode, f func(...interface{}) (int, error)) {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	piscine.BTreeApplyPreorder(root, fmt.Println)
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-4
-1
-7
-5
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/btreedeletenode.fr.md

@@ -1,58 +0,0 @@
-## btreedeletenode
-
-### Instructions
-
-Écrire une fonction, `BTreeDeleteNode`, qui efface `node` d'un arbre donné par `root`.
-
-L'arbre en résultant devra toujours suivre les règles des arbres de recherche binaires.
-
-### Fonction attendue
-
-```go
-func BTreeDeleteNode(root, node *TreeNode) *TreeNode {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	node := piscine.BTreeSearchItem(root, "4")
-	fmt.Println("Before delete:")
-	piscine.BTreeApplyInorder(root, fmt.Println)
-	root = piscine.BTreeDeleteNode(root, node)
-	fmt.Println("After delete:")
-	piscine.BTreeApplyInorder(root, fmt.Println)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-Before delete:
-1
-4
-5
-7
-After delete:
-1
-5
-7
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/btreeinsertdata.fr.md

@@ -1,57 +0,0 @@
-## btreeinsertdata
-
-### Instructions
-
-Écrire une fonction qui insère de la nouvelle donnée dans un arbre binaire en suivant les propriétés des arbres de recherche binaires.
-
-Les nodes doivent être définies comme ci-dessous :
-
-### Fonction attendue
-
-```go
-type TreeNode struct {
-	Left, Right, Parent *TreeNode
-	Data                 string
-}
-
-func BTreeInsertData(root *TreeNode, data string) *TreeNode {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	fmt.Println(root.Left.Data)
-	fmt.Println(root.Data)
-	fmt.Println(root.Right.Left.Data)
-	fmt.Println(root.Right.Data)
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/btreeinsertdata$ go build
-student@ubuntu:~/[[ROOT]]/btreeinsertdata$ ./btreeinsertdata
-1
-4
-5
-7
-student@ubuntu:~/[[ROOT]]/btreeinsertdata$
-```

subjects/btreeisbinary.fr.md

@@ -1,43 +0,0 @@
-## btreeisbinary
-
-### Instructions
-
-Écrire une fonction, `BTreeIsBinary`, qui retourne `true` seulement si l'arbre donné par `root` suit les propriétés des arbres de recherche binaires.
-
-### Fonction attendue
-
-```go
-func BTreeIsBinary(root *TreeNode) bool {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	fmt.Println(piscine.BTreeIsBinary(root))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-true
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/btreelevelcount.fr.md

@@ -1,44 +0,0 @@
-## btreelevelcount
-
-### Instructions
-
-Écrire une fonction, `BTreeLevelCount`, qui retourne le nombre de niveaux de l'arbre binaire. (la hauteur de l'arbre)
-
-### Fonction attendue
-
-```go
-func BTreeLevelCount(root *TreeNode) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-
-	piscine ".."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	fmt.Println(piscine.BTreeLevelCount(root))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-3
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/btreemax.fr.md

@@ -1,45 +0,0 @@
-## btreemax
-
-### Instructions
-
-Écrire une fonction, `BTreeMax`, qui retourne la node avec la valeur maximum de l'arbre donné par `root`.
-
-### Fonction attendue
-
-```go
-func BTreeMax(root *TreeNode) *TreeNode {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-
-	piscine ".."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	max := piscine.BTreeMax(root)
-	fmt.Println(max.Data)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-7
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/btreemin.fr.md

@@ -1,45 +0,0 @@
-## btreemin
-
-### Instructions
-
-Écrire une fonction, `BTreeMin`, qui retourne la node avec la valeur minimum de l'arbre donné par `root`.
-
-### Fonction attendue
-
-```go
-func BTreeMin(root *TreeNode) *TreeNode {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-
-	piscine ".."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	min := piscine.BTreeMin(root)
-	fmt.Println(min.Data)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-1
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/btreeprintroot.fr.md

@@ -1,47 +0,0 @@
-## btreeprintroot
-
-### Instructions
-
-Écrire une fonction qui affiche la valeur de node `root` d'un arbre binaire.
-Les nodes doivent être définies comme ci-dessous:
-
-### Fonction attendue
-
-```go
-type TreeNode struct {
-	left, right *TreeNode
-	data        string
-}
-
-func PrintRoot(root *TreeNode){
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-func main() {
-	//rootNode initialized with the value "who"
-	//rootNode1 initialized with the value "are"
-	//rootNode2 initialized with the value "you"
-	printRoot(rootNode)
-	printRoot(rootNode1)
-	printRoot(rootNode2)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/printroot$ go build
-student@ubuntu:~/[[ROOT]]/printroot$ ./printroot
-who
-are
-you
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/btreesearchitem.fr.md

@@ -1,73 +0,0 @@
-## btreesearchitem
-
-### Instructions
-
-Écrire une fonction qui cherche une node avec un élément de data égal à `elem` et qui retourne cette node.
-
-### Fonction attendue
-
-```go
-func BTreeSearchItem(root *TreeNode, elem string) *TreeNode {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	selected := piscine.BTreeSearchItem(root, "7")
-	fmt.Print("Item selected -> ")
-	if selected != nil {
-		fmt.Println(selected.Data)
-	} else {
-		fmt.Println("nil")
-	}
-
-	fmt.Print("Parent of selected item -> ")
-	if selected.Parent != nil {
-		fmt.Println(selected.Parent.Data)
-	} else {
-		fmt.Println("nil")
-	}
-
-	fmt.Print("Left child of selected item -> ")
-	if selected.Left != nil {
-		fmt.Println(selected.Left.Data)
-	} else {
-		fmt.Println("nil")
-	}
-
-	fmt.Print("Right child of selected item -> ")
-	if selected.Right != nil {
-		fmt.Println(selected.Right.Data)
-	} else {
-		fmt.Println("nil")
-	}
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-Item selected -> 7
-Parent of selected item -> 4
-Left child of selected item -> 5
-Right child of selected item -> nil
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/btreetransplant.fr.md

@@ -1,49 +0,0 @@
-## btreetransplant
-
-### Instructions
-
-Afin de déplacer les sous-arbres dans l'arbre de recherche binaire, écrire une fonction, `BTreeTransplant`, qui remplace le sous-arbre commencé par `node` avec la node `rplc` dans l'arbre donné par `root`.
-
-### Fonction attendue
-
-```go
-func BTreeTransplant(root, node, rplc *TreeNode) *TreeNode {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	root := &piscine.TreeNode{Data: "4"}
-	piscine.BTreeInsertData(root, "1")
-	piscine.BTreeInsertData(root, "7")
-	piscine.BTreeInsertData(root, "5")
-	node := piscine.BTreeSearchItem(root, "1")
-	replacement := &piscine.TreeNode{Data: "3"}
-	root = piscine.BTreeTransplant(root, node, replacement)
-	piscine.BTreeApplyInorder(root, fmt.Println)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-3
-4
-5
-7
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/capitalize.fr.md

@@ -1,41 +0,0 @@
-## capitalize
-
-### Instructions
-
-Écrire une fonction qui met en majuscule la première lettre de chaque mot et en minuscule les autres lettres du reste du mot d'une `string`.
-
-Un mot est une suite de caractères **alphanumériques**.
-
-### Fonction attendue
-
-```go
-func Capitalize(s string) string {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.Capitalize("Hello! How are you? How+are+things+4you?"))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-Hello! How Are You? How+Are+Things+4you?
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/capitalizeprog.fr.md

@@ -1,24 +0,0 @@
-## capitalizeprog
-
-### Instructions
-
-Écrire un programme qui met en majuscule la première lettre de chaque mot et en minuscule les autres lettres du reste du mot d'une `string`.
-
-- Un mot est une suite de caractères **alphanumériques**.
-
-- Si il y a plus d'un argument le programme doit afficher `Too many arguments`.
-
-- Si il n'y a pas d'arguments le programme doit afficher un retour à la ligne (`'\n'`).
-
-### Utilisation :
-
-```console
-student@ubuntu:~/capitalizeprog$ go build
-student@ubuntu:~/capitalizeprog$ ./capitalizeprog "Hello! How are you? How+are+things+4you?" | cat -e
-Hello! How Are You? How+Are+Things+4you?$
-student@ubuntu:~/capitalizeprog$ ./capitalizeprog Hello! How are you? | cat -e
-Too many arguments$
-student@ubuntu:~/capitalizeprog$ ./capitalizeprog
-
-student@ubuntu:~/capitalizeprog$
-```

subjects/cat.fr.md

@@ -1,41 +0,0 @@
-## cat
-
-### Instructions
-
-Écrire un programme qui a le même comportement que la ligne de commande `cat`.
-
-- Les `options` ne doivent pas être gérés.
-
-- Si le programme est éxécuté sans arguments il doit prendre l'`input` et l'afficher.
-
-- Dans le dossier du programme créer deux fichiers nommés `quest8.txt` et `quest8T.txt`.
-
-- Copier dans le fichier `quest8.txt` la phrase suivante :
-
-`"Programming is a skill best acquired by pratice and example rather than from books" by Alan Turing`
-
-- Copier dans le fichier `quest8T.txt` la phrase suivante :
-
-`"Alan Mathison Turing was an English mathematician, computer scientist, logician, cryptanalyst. Turing was highly influential in the development of theoretical computer science, providing a formalisation of the concepts of algorithm and computation with the Turing machine, which can be considered a model of a general-purpose computer. Turing is widely considered to be the father of theoretical computer science and artificial intelligence."`
-
-- En cas d'erreur le programme doit afficher l'erreur.
-
-- Le programme doit être rendu dans un dossier nommé `cat`.
-
-### Utilisation:
-
-```console
-student@ubuntu:~/[[ROOT]]/cat$ go build
-student@ubuntu:~/[[ROOT]]/cat$ ./cat abc
-open abc: no such file or directory
-student@ubuntu:~/[[ROOT]]/cat$ ./cat quest8.txt
-"Programming is a skill best acquired by pratice and example rather than from books" by Alan Turing
-student@ubuntu:~/[[ROOT]]/cat$ ./cat
-Hello
-Hello
-^C
-student@ubuntu:~/[[ROOT]]/cat$ ./cat quest8.txt quest8T.txt
-"Programming is a skill best acquired by pratice and example rather than from books" by Alan Turing
-
-"Alan Mathison Turing was an English mathematician, computer scientist, logician, cryptanalyst. Turing was highly influential in the development of theoretical computer science, providing a formalisation of the concepts of algorithm and computation with the Turing machine, which can be considered a model of a general-purpose computer. Turing is widely considered to be the father of theoretical computer science and artificial intelligence."
-```

subjects/cl-camp1.fr.md

@@ -1,21 +0,0 @@
-## cl-camp1
-
-### Instructions
-
-Une petite voix dans votre esprit vous dit:
-
-"Maintenant que tu sais qui tu es. Tu dois te souvenir de ce que tu peux faire..."
-
-Les instincts resurgissent...
-
-Mettez dans un fichier `mastertheLS` la ligne de commande qui:
-
-- listera les fichiers et dossiers dans le dossier courant.
-- Ignorera les fichiers cachés, le "." et le "..".
-- Separarera le resultat avec des virgules.
-- Les triera pas ordre croissant de date de création.
-- Placera un `/` en face des dossiers.
-
-### Indice
-
-Lisez le man...

subjects/cl-camp2.fr.md

@@ -1,17 +0,0 @@
-## cl-camp2
-
-### Instructions
-
-"Continue l'entrainement ..."
-
-Créez un fichier `r`, qui affiche `R` sur une ligne quand la commande `cat` est exécutée.
-
-Une ligne est une suite de caractères précédant le caractère [fin de ligne](https://en.wikipedia.org/wiki/Newline) (`'\n'`).
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ cat -e r
-R$
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/cl-camp3.fr.md

@@ -1,15 +0,0 @@
-## cl-camp3
-
-### Instructions
-
-"commences à chercher ..."
-
-Créer un fichier `look`, qui cherchera et montrera, dans le répertoire courant et ses sous-répertoires, tous les fichiers qui:
-
-- commence avec `a` et,
-- tous les fichiers qui se terminent avec `z` et,
-- tous les fichiers qui commencent avec `z` et qui se finissent avec `a!`.
-
-### Indice
-
-Lisez le man de `find`...

subjects/cl-camp4.fr.md

@@ -1,24 +0,0 @@
-## cl-camp4
-
-### Instructions
-
-"quelqu'un de familier"
-
-Créer un fichier `myfamily.sh`, qui affichera la famille d'un individu (clef: relatives).
-
-- Les guillemets doivent être enlevés.
-
-- L'individu sera choisi en fonction de son ID qui sera contenu dans la variable d'environment HERO_ID.
-
-* Où chercher : https://[[DOMAIN]]/assets/superhero/all.json
-
-* Quoi utiliser : `curl`, `jq` et d'autres...
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ export HERO_ID=1
-student@ubuntu:~/[[ROOT]]/test$ ./myfamily.sh
-Marlo Chandler-Jones (wife); Polly (aunt); Mrs. Chandler (mother-in-law); Keith Chandler, Ray Chandler, three unidentified others (brothers-in-law); unidentified father (deceased); Jackie Shorr (alleged mother; unconfirmed)
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/cl-camp5.fr.md

@@ -1,25 +0,0 @@
-## cl-camp5
-
-### Instructions
-
-"continues à chercher..."
-
-Créer un fichier `lookagain.sh`, qui cherchera et montrera, dans le répertoire courant et ses sous-répertoires, tous les fichiers qui:
-
-- qui finissent avec `.sh`.
-
-Cette commande montrera le nom des fichiers sans le`.sh`.
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ ./lookagain.sh | cat -e
-file1$
-file2$
-file3$
-student@ubuntu:~/[[ROOT]]/test$
-```
-
-### Indice
-
-Un petit `cut`ter pourrait être utile...

subjects/cl-camp6.fr.md

@@ -1,15 +0,0 @@
-## cl-camp6
-
-### Instructions
-
-"Maintenant, fais ton inventaire"
-
-Créer un fichier `countfiles.sh`, qui affichera le nombre **(et seulement le nombre)** de fichiers réguliers et répertoires contenu dans le répertoire courant et ses sous-répertoires :
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ ./countfiles.sh | cat -e
-12$
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/cl-camp7.fr.md

@@ -1,15 +0,0 @@
-## cl-camp7
-
-### Instructions
-
-"Sois précis"
-
-Créer un fichier `"\?$*'ChouMi'*$?\"` qui contiendra "01" et **rien d'autre**.
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ ls | cat -e
-"\?$*'ChouMi'*$?\" $
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/cl-camp8.fr.md

@@ -1,11 +0,0 @@
-## cl-camp8
-
-### Instructions
-
-"Choisis ton équipement"
-
-écrire une ligne dans un fichier `skip.sh` qui affiche le résultat d'un `ls -l` qui saute 1 ligne sur 2, en commençant par la **première**.
-
-### Indice
-
-`awk` ou `sed` peuvent faire le travail.

subjects/cl.fr.md

@@ -1,21 +0,0 @@
-## cl-camp1
-
-### Instructions
-
-A little voice speaks in your head:
-
-"Now that you know who you are. You need to remember what you can do..."
-
-The instincts are coming back...
-
-Put in a file `mastertheLS` the command line that will:
-
-- list the files and folders of the current folder.
-- Ignore the hidden files, the "." and the "..".
-- Separates the results with commas.
-- Order them by ascending order of creation date.
-- Have the folders have a `/` in front of them.
-
-### Hint
-
-Read the man...

subjects/cleanstr.fr.md

@@ -1,28 +0,0 @@
-## cleanstr
-
-### Instructions
-
-Écrire un programme qui prend une `string`, et qui affiche cette `string` avec exactement:
-
-- un espace entre les mots.
-- aucun espace ni de tabulation ni au début ni à la fin.
-- le résultat avecsuivi d'un saut de ligne("`\n`").
-
-Un "mot" est défini comme une partie de `string` délimité par soit des espaces/tabulations soit par le début/fin d'une `string`.
-
-Si le nombre d'arguments est différent de 1, ou si il n'y a pas de mots à afficher, alors le programme affiche un saut de ligne("`\n`").
-
-### Utilisation :
-
-```console
-student@ubuntu:~/[[ROOT]]/cleanstr$ go build
-student@ubuntu:~/[[ROOT]]/cleanstr$ ./cleanstr "you see it's easy to display the same thing" | cat -e
-you see it's easy to display the same thing$
-student@ubuntu:~/[[ROOT]]/cleanstr$ ./cleanstr " only    it's  harder   "
-only it's harder$
-student@ubuntu:~/[[ROOT]]/cleanstr$ ./cleanstr " how funny" "Did you   hear Mathilde ?"
-$
-student@ubuntu:~/[[ROOT]]/cleanstr$ ./cleanstr "" | cat -e
-$
-student@ubuntu:~/[[ROOT]]/cleanstr$
-```

subjects/collatzcountdown.fr.md

@@ -1,42 +0,0 @@
-## collatzcountdown
-
-### Instructions
-
-Écrire une fonction, `CollatzCountdown`, qui retournes le nombre d'étapes nécéssaires pour atteindre 1 en utilisant le comptage de collatz.
-
-- Elle doit renvoyer `-1` si `start` est égal à 0 ou négatif.
-
-### Fonction attendue
-
-```go
-func CollatzCountdown(start int) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	steps := piscine.CollatzCountdown(12)
-	fmt.Println(steps)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-10
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/comcheck.fr.md

@@ -1,20 +0,0 @@
-## comcheck
-
-### Instructions
-
-écrire un programme `comcheck` qui affiche sur la sortie standard `Alert!!!` suivi d'un retour à la ligne (`'\n'`) si au moins un des arguments passé ne paramètre correspond aux `string`:
-
-- `01`, `galaxy` ou `galaxy 01`.
-
-- si aucun des paramètres correspond, le programme affiche rien.
-
-### Usage
-
-```console
-student@ubuntu:~/[[ROOT]]/comcheck$ go build
-student@ubuntu:~/[[ROOT]]/comcheck$ ./comcheck "I" "Will" "Enter" "the" "galaxy"
-Alert!!!
-student@ubuntu:~/[[ROOT]]/comcheck$ ./comcheck "galaxy 01" "do" "you" "hear" "me"
-Alert!!!
-student@ubuntu:~/[[ROOT]]/comcheck$
-```

subjects/commandments.fr.md

@@ -1,114 +0,0 @@
----
-tier: 0
-team: 1
-duration: 1 hour
-objectives: reading the rules
-skills: git, github, reading
----
-
-## commandments
-
-A few basic principles to follow
-
-<p align="center">
-  <img width="476" height="600" src="https://upload.wikimedia.org/wikipedia/commons/thumb/e/e5/MCC-31231_Mozes_toont_de_wetstafelen_%281%29.tif/lossy-page1-476px-MCC-31231_Mozes_toont_de_wetstafelen_%281%29.tif.jpg">
-</p>
-
-### The Commandements _(read them)_
-
-- Le numérique est ta passion.
-
-- Ton objectif à 42 : développer ton talent et tes compétences pour le marché du numérique.
-
-- L’objectif de 42 pour toi : te faire accéder au marché de l’emploi, à une longue et pérenne carrière dans le numérique, et te faire progresser socialement.
-
-- L’ambition de 42 pour toi : être un pionnier du numérique de demain.
-
-- Il est de ta responsabilité de gérer ta progression : 42 te propose un parcours individualisé adapté à ton rythme.
-
-- Des challenges jalonnent ton parcours. 42 ne fournira aucun élément de solution. C’est ton rôle de chercher et trouver par toi-même ces solutions pour atteindre l’objectif.
-
-- Sois actif. N’attend pas que les choses se fassent pour toi. 42 est un parcours 100% pratique.
-
-- Sois autonome dans ton cursus. N’attend pas que l’on te dise quoi faire.
-
-- Sois collaboratif, autant sur les projets solos que les projets de groupe. Face aux challenges à resoudre, l’échange et le debat sont tes meilleures armes.
-
-- Ne "crois" pas. Sois sûr. Techniquement, relationnelement, organisationellement, administrativement.
-
-- Pour être sûr, teste, contrôle.
-
-- N’ai pas peur de te tromper, d’échouer. L’échec est une étape normale vers le succès.
-
-- Teste à nouveau. Collabore davantage pour tester davantage.
-
-- Ose. Le risque est de se tromper. Voir le commandement 12.
-
-- Sois rigoureux dans ton travail.
-
-- Sois investi dans ton cursus : 50 heures par semaine est un minimum. Ta capacité de travail est une valeur. L’école est ouverte 24h/24 et 7j/7.
-
-- Sois régulier dans ton travail. Un jour oui, un jour non, un coup nocturne, un coup diurne... le chaos t’empêche d’avancer.
-
-- Prévois un groupe de travail large et hétérogène pour y trouver facilement des idées neuves et des groupes de projet.
-
-- Pour tes collaborations et ton travail en groupe, privilégie des étudiants qui n’ont pas déjà la solution au problème.
-
-- Sois investi dans ton groupe de projet, et ne le laisse pas faire ton travail à ta place.
-
-- Ton groupe de projet est solidaire, son succès comme son échec est de la responsabilité de tous, et les conflits se règlent en interne.
-
-- Travaille à l’école. Faire du peer-learning, collaborer, cela demande d’être physiquement avec les autres. A distance cela ne fonctionne pas.
-
-- Implique toi dans les évaluations de tes projets. Elles te permettent de prendre du recul.
-
-- Implique toi dans tes évaluations des projets des autres. La qualité de la communauté en dépend.
-
-- Sois juste et teste rigoureusement tes projets comme ceux des autres en évaluation avec tes propres jeux de tests.
-
-- Joue pleinement le jeu de ta scolarité dans l’état d’esprit demandé, fait tous les exercices et projets demandés.
-
-- Ne cherche pas des biais et des failles dans le système. Tu vas fausser ta propre formation et ta valeur sur le marché.
-
-- Ne triche pas intentionellement. C’est amoral, cela contredit le commandement 12, et c’est du temps inutilement passé à ne pas développer tes compétences pour faire croire aux autres que tu sais coder alors que ce n’est pas le cas.
-
-- Ne rends pas un projet que tu ne serais pas capable de reproduire seul à huis clos. Même si c’est parfois involontaire, c’est aussi de la triche.
-
-- C’est pas pour tes parents que tu travailles, ni pour le staff. C’est pour toi.
-
-- Participe à la vie de la communauté, à son épanouissement, et sa qualité en sortie de formation.
-
-- Aide au respect de ces commandements par la communauté.
-
-- Sois bienveillant et empathique vis à vis de tes camarades comme des personnes avec qui tu interagis, échanges, débats.
-
-- N’ai pas peur du monde professionnel.
-
-- Respecte le matériel. Des consignes spécifiques sont données en ce sens.
-
-- Respecte les locaux. Des consignes spécifiques sont données en ce sens.
-
-- Respecte les gens, étudiants, staffs, partenaires, visiteurs.
-
-- Respecte la loi en vigueur dans le pays.
-
-- Respecte les lois et consignes en vigueur liées à la consommation d’alcool.
-
-- Respecte les lois et consignes en vigueur liées à la consommation de tabac, stupéfiants, ou produits assimilés.
-
-- N’hésite pas à interagir avec le staff, pour parler de tes problèmes, pour remonter des problèmes dans le cursus, pour contribuer au cursus.
-
-- Si tu t’interroges ou ne comprends pas nos choix pédagogiques, demande nous. On ne fait généralement rien au hasard.
-
-### Required
-
-You [clone](http://lmgtfy.com/?q=git+clone) your [fork](http://lmgtfy.com/?q=github+fork) of this [repository](http://lmgtfy.com/?q=git+repository)
-and in it, you must create a file named `turn_in` () in which you write EXACTLY the following sentence ending by a line break.
-
-<p align="center">
-  <img width="600" height="300" src="https://i.imgur.com/2PPQ2iZ.png">
-</p>
-
-### Submiting your solution
-
-Your work should be commited and pushed in the master branch of your own fork of this repository.

subjects/compact.fr.md

@@ -1,69 +0,0 @@
-## compact
-
-### Instructions
-
-Écrire une fonction `Compact` qui prend un pointeur sur slice de `string` comme paramètre.
-Cette fonction doit:
-
-- Retourner le nombre d'éléments avec des valeurs non-`nil`
-
-- Comprimer, c.à.d., effacer les éléments qui ont une valeur `nil` dans la slice.
-
-### Fonction attendue
-
-```go
-func Compact(ptr *[]string) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-
-	piscine ".."
-)
-
-const N = 6
-
-func main() {
-	arr := make([]string, N)
-	arr[0] = "a"
-	arr[2] = "b"
-	arr[4] = "c"
-
-	for _, v := range arr {
-		fmt.Println(v)
-	}
-
-	fmt.Println("Size after compacting:", piscine.Compact(&arr))
-
-	for _, v := range arr {
-		fmt.Println(v)
-	}
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-a
-
-b
-
-c
-
-Size after compacting: 3
-a
-b
-c
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/compare.fr.md

@@ -1,43 +0,0 @@
-## compare
-
-### Instructions
-
-Écrire une fonction qui se comporte comme la fonction [`Compare`](https://golang.org/pkg/strings/#Compare).
-
-### Fonction attendue
-
-```go
-func Compare(a, b string) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.Compare("Hello!", "Hello!"))
-	fmt.Println(piscine.Compare("Salut!", "lut!"))
-	fmt.Println(piscine.Compare("Ola!", "Ol"))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-0
--1
-1
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/compareprog.fr.md

@@ -1,24 +0,0 @@
-## compareprog
-
-### Instructions
-
-Écrire un programme qui se comporte comme la fonction `Compare`.
-
-Ce programme affiche un nombre après avoir comparé deux `string` lexicalement.
-
-### Utilisation :
-
-```console
-student@ubuntu:~/compareprog$ go build
-student@ubuntu:~/compareprog$ ./compareprog a b | cat -e
--1$
-student@ubuntu:~/compareprog$ ./compareprog a a | cat -e
-0$
-student@ubuntu:~/compareprog$ ./compareprog b a | cat -e
-1$
-student@ubuntu:~/compareprog$ ./compareprog b a d | cat -e
-$
-student@ubuntu:~/compareprog$ ./compareprog | cat -e
-$
-student@ubuntu:~/compareprog$
-```

subjects/concat.fr.md

@@ -1,40 +0,0 @@
-## concat
-
-### Instructions
-
-Écrire une fonction qui retourne la concaténation de deux `string` passées en paramètres.
-
-### Fonction attendue
-
-```go
-func Concat(str1 string, str2 string) string {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.Concat("Hello!", " How are you?"))
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-Hello! How are you?
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/concatparams.fr.md

@@ -1,45 +0,0 @@
-## concatparams
-
-### Instructions
-
-Écrire une fonction qui prend les arguments en paramètres et les retournes dans une `string`.
-
-Les arguments doivent être **séparés** par un `\n`.
-
-### Fonction attendue
-
-```go
-func ConcatParams(args []string) string {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	test := []string{"Hello", "how", "are", "you?"}
-	fmt.Println(piscine.ConcatParams(test))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-Hello
-how
-are
-you?
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/convertbase.fr.md

@@ -1,44 +0,0 @@
-## convertbase
-
-### Instructions
-
-Écrire une fonction qui retourne la convertion d'un nombre `string` d'une baseFrom `string` à une baseTo `string`.
-
-Seules des bases valides seront testées.
-
-Les nombres négatifs ne seront pas testés.
-
-### Fonction attendue
-
-```go
-func ConvertBase(nbr, baseFrom, baseTo string) string {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	result := piscine.ConvertBase("101011", "01", "0123456789")
-	fmt.Println(result)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-43
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/countdown.fr.md

@@ -1,14 +0,0 @@
-## countdown
-
-### Instructions
-
-Écrire un programme qui affiche les chiffres dans l'ordre décroissant sur une seule ligne, suivi par un retour à la ligne (`'\n'`).
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-9876543210
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/countif.fr.md

@@ -1,45 +0,0 @@
-## countif
-
-### Instructions
-
-Écrire une fonction `CountIf` qui retournes le nombre d'éléments d'un tableau de `string` pour lesquels la fonction `f` retourne `true`.
-
-### Fonction attendue
-
-```go
-func CountIf(f func(string) bool, tab []string) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	tab1 := []string{"Hello", "how", "are", "you"}
-	tab2 := []string{"This","1", "is", "4", "you"}
-	answer1 := piscine.CountIf(piscine.IsNumeric, tab1)
-	answer2 := piscine.CountIf(piscine.IsNumeric, tab2)
-	fmt.Println(answer1)
-	fmt.Println(answer2)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-0
-2
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/createelem.fr.md

@@ -1,45 +0,0 @@
-## createelem
-
-### Instructions
-
-Écrire une fonction `CreateElem` qui crée un nouvel élément de type `Node`.
-
-### Fonction attendue et structure
-
-```go
-type Node struct {
-	Data interface{}
-}
-
-func CreateElem(n *Node, value int) {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	n := &node{}
-	n.CreateElem(1234)
-	fmt.Println(n)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-&{1234}
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/disclaimer.fr.md

@@ -1,10 +0,0 @@
-## **AVERTISSEMENT! TRÈS IMPORTANT!**
-
-Pour cet exercice une fonction sera testée **avec le main de l'examen**. Cependant l'étudiant **doit quand même** rendre un programme structuré:
-
-Cela signifie que:
-
-- Le package doit être nommé `package main`.
-- Le code rendu doit avoir une fonction main déclarée(`func main()`) même si elle est vide.
-- La fonction main déclarée doit **aussi passer** le `Restrictions Checker`(le testeur de fonctions illégales). Il est conseillé à l'étudiant de rendre une fonction main vide après ses tests finis.
-- Toutes les autres régles sont les mêmes que pour un `programme`.

subjects/displaya.fr.md

@@ -1,18 +0,0 @@
-## displaya
-
-### Instructions
-
-Écrire un programme qui prend une `string`, et qui affiche le premier caractère `a` qu'il trouve dedans, suivi par un retour à la ligne (`'\n'`). Si il n'y a pas de caractère `a` dans la `string`, le programme affiche juste un `a` suivi d'un retour à la ligne (`'\n'`). Si le nombre de paramètres n'est pas 1, le programme affiche un `a` suivi d'un retour à la ligne (`'\n'`).
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test "abc"
-a
-student@ubuntu:~/[[ROOT]]/test$ ./test "bcvbvA"
-a
-student@ubuntu:~/[[ROOT]]/test$ ./test "nbv"
-a
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/displayalpham.fr.md

@@ -1,14 +0,0 @@
-## displayalpham
-
-### Instructions
-
-Écrire un programme qui affiche l'alphabet, avec les lettres paires en majuscule, et les lettres impaires en minuscule, suivi d'un retour à la ligne (`'\n'`).
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/displayalpham$ go build
-student@ubuntu:~/[[ROOT]]/displayalpham$ ./displayalpham | cat -e
-aBcDeFgHiJkLmNoPqRsTuVwXyZ$
-student@ubuntu:~/[[ROOT]]/displayalpham$
-```

subjects/displayalrevm.fr.md

@@ -1,14 +0,0 @@
-## displayalrevm
-
-### Instructions
-
-Écrire un programme qui affiche l'alphabet à l'envers, avec les lettres paires en majuscule, et les lettres impaires en minuscule, suivi d'un retour à la ligne (`'\n'`).
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/displayalrevm$ go build
-student@ubuntu:~/[[ROOT]]/displayalrevm$ ./displayalrevm | cat -e
-zYxWvUtSrQpOnMlKjIhGfEdCbA$
-student@ubuntu:~/[[ROOT]]/displayalrevm$
-```

subjects/displayfile.fr.md

@@ -1,25 +0,0 @@
-## Display File
-
-### Instructions
-
-Écrire un programme qui affiche, sur la sortie standard, le contenu d'un fichier donné en argument.
-
-- Créer un fichier `quest8.txt` et écrire dedans la phrase `Almost there!!`
-
-- L'argument pour ce programme sera, dans ce cas, `quest8.txt`.
-
-- En cas d'erreur le programme doit afficher un des deux messages suivants de manière approprié:
-  - `File name missing`.
-  - `Too many arguments`.
-
-### Utilisation :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-File name missing
-student@ubuntu:~/[[ROOT]]/test$ ./test quest8.txt main.go
-Too many arguments
-student@ubuntu:~/[[ROOT]]/test$ ./test quest8.txt
-Almost there!!
-```

subjects/displayfirstparam.fr.md

@@ -1,17 +0,0 @@
-## displayfirstparam
-
-### Instructions
-
-Écrire un programme qui prend des `string` comme arguments, et qui affiche le premier argument.
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test hello there
-hello
-student@ubuntu:~/[[ROOT]]/test$ ./test "hello there" how are you
-hello there
-student@ubuntu:~/[[ROOT]]/test$ ./test
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/displaylastparam.fr.md

@@ -1,19 +0,0 @@
-## displaylastparam
-
-### Instructions
-
-Écrire un programme qui prend des `string` comme arguments, et qui affiche le dernier argument.
-
-### Expected output
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test hello there
-there
-student@ubuntu:~/[[ROOT]]/test$ ./test "hello there" how are you
-you
-student@ubuntu:~/[[ROOT]]/test$ ./test "hello there"
-hello there
-student@ubuntu:~/[[ROOT]]/test$ ./test
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/displayz.fr.md

@@ -1,18 +0,0 @@
-## displayz
-
-### Instructions
-
-Écrire un programme qui prend une `string`, et qui affiche le premier caractère `z` qu'il trouve dedans, suivi par un retour à la ligne (`'\n'`). Si il n'y a pas de caractère `z` dans la `string`, le programme affiche juste un `z` suivi d'un retour à la ligne (`'\n'`). Si le nombre de paramètres n'est pas 1, le programme affiche un `z` suivi d'un retour à la ligne (`'\n'`).
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test "xyz"
-z
-student@ubuntu:~/[[ROOT]]/test$ ./test "bcvbvZ"
-z
-student@ubuntu:~/[[ROOT]]/test$ ./test "nbv"
-z
-student@ubuntu:~/[[ROOT]]/test$ ./test
-```

subjects/divmod.fr.md

@@ -1,50 +0,0 @@
-## divmod
-
-### Instructions
-
-- Écrire une fonction qui aura le format ci-dessous.
-
-### Fonction attendue
-
-```go
-func DivMod(a int, b int, div *int, mod *int) {
-
-}
-```
-
-- Cette fonction divisera les int **a** et **b**.
-- Le résultat de la division sera stocké dans l'int pointé par **div**.
-- Le reste de cette division sera stocké dans l'int pointé par **mod**.
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	a := 13
-	b := 2
-	var div int
-	var mod int
-	piscine.DivMod(a, b, &div, &mod)
-	fmt.Println(div)
-	fmt.Println(mod)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-6
-1
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/doop.fr.md

@@ -1,40 +0,0 @@
-## doop
-
-### Instructions
-
-Écrire un [programme](TODO-LINK) qui s'apelle `doop`.
-
-Le programme doit être utilisé avec trois arguments:
-
-- Une valeur
-- Un opérateur
-- Une autre valeur
-
-En cas d'opérateur invalide le programme affiche `0`.
-
-En cas de nombre invalide d'arguments le programme affiche rien.
-
-Le programme doit géré les opérations modulo et division par 0 comme dans les examples ci-dessous.
-
-`fmt.Print` est autorisé.
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build doop.go
-student@ubuntu:~/[[ROOT]]/test$ ./doop
-student@ubuntu:~/[[ROOT]]/test$ ./doop 1 + 1 | cat -e
-2$
-student@ubuntu:~/[[ROOT]]/test$ ./doop hello + 1 | cat -e
-0$
-student@ubuntu:~/[[ROOT]]/test$ ./doop 1 p 1 | cat -e
-0$
-student@ubuntu:~/[[ROOT]]/test$ ./doop 1 / 0 | cat -e
-No division by 0$
-student@ubuntu:~/[[ROOT]]/test$ ./doop 1 % 0 | cat -e
-No modulo by 0$
-student@ubuntu:~/[[ROOT]]/test$ ./doop 1 "*" 1
-1
-student@ubuntu:~/[[ROOT]]/test$ ./doop 1 "*" -1
--1
-```

subjects/eightqueens.fr.md

@@ -1,33 +0,0 @@
-## eightqueens
-
-### Instructions
-
-Écrire une [fonction](TODO-LINK) qui affiche toutes les solutions du [problème des huit dames](https://en.wikipedia.org/wiki/Eight_queens_puzzle).
-
-La récursion doit être utilisée pour résoudre ce problème.
-
-L'affichage sera quelque chose comme ça :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-15863724
-16837425
-17468253
-...
-```
-
-Chaque solution sera sur une ligne unique.
-L'index du placement d'une reine commence à 1.
-Elle se lit de gauche à droite et chaque chiffre est la position pour chacune des colonnes.
-Les solutions seront affichées dans l'ordre croissant.
-
-### Fonction attendue
-
-```go
-package main
-
-func EightQueens() {
-
-}
-```

subjects/enigma.fr.md

@@ -1,88 +0,0 @@
-## enigma
-
-### Instructions
-
-Écrire une fonction nommé `Enigma` qui prends des pointeurs comme arguments et qui interchanges leurs valeurs pour les cacher.
-Cette fonction déplacera :
-
-- `a` dans `c`.
-- `c` dans `d`.
-- `d` dans `b`.
-- `b` dans `a`.
-
-### Fonction attendue
-
-```go
-func Enigma(a ***int, b *int, c *******int, d ****int) {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	x := 5
-	y := &x
-	z := &y
-	a := &z
-
-	w := 2
-	b := &w
-
-	u := 7
-	e := &u
-	f := &e
-	g := &f
-	h := &g
-	i := &h
-	j := &i
-	c := &j
-
-	k := 6
-	l := &k
-	m := &l
-	n := &m
-	d := &n
-
-	fmt.Println(***a)
-	fmt.Println(*b)
-	fmt.Println(*******c)
-	fmt.Println(****d)
-
-	student.Enigma(a, b, c, d)
-
-	fmt.Println("After using Enigma")
-	fmt.Println(***a)
-	fmt.Println(*b)
-	fmt.Println(*******c)
-	fmt.Println(****d)
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-5
-2
-7
-6
-After using Enigma
-2
-6
-5
-7
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/expandstr.fr.md

@@ -1,26 +0,0 @@
-## expandstr
-
-### Instructions
-
-Écrire un programme qui prend une `string` et qui l'affiche avec exactement 3 espaces entre chaque mot, sans espace ou tabulation ni au début ni à la fin.
-
-La `string` sera suivie d'un retour à la ligne (`'\n'`).
-
-Un mot est une suite de caractères alphanumériques.
-
-Si le nombre de paramètres n'est pas 1, ou si il n'y a pas de mot, le programme affiche un retour à la ligne.
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/expandstr$ go build
-student@ubuntu:~/[[ROOT]]/expandstr$ ./expandstr "you   see   it's   easy   to   display   the   same   thing" | cat -e
-you   see   it's   easy   to   display   the   same   thing$
-student@ubuntu:~/[[ROOT]]/expandstr$ ./expandstr "   only  it's harder   " | cat -e
-only   it's   harder$
-student@ubuntu:~/[[ROOT]]/expandstr$ ./expandstr " how funny it is" "did you  hear, Mathilde ?" | cat -e
-$
-student@ubuntu:~/[[ROOT]]/expandstr$ ./expandstr | cat -e
-$
-student@ubuntu:~/[[ROOT]]/expandstr$
-```

subjects/fibonacci.fr.md

@@ -1,50 +0,0 @@
-## fibonacci
-
-### Instructions
-
-Écrire une fonction **récursive** qui renvoie la valeur de la suite de fibonacci correspondant à l'index passé en paramètre.
-
-La premiére valeur est à l'index `0`.
-
-La suite débute ainsi: 0, 1, 1, 2, 3 etc...
-
-Un index négatif renvoie `-1`.
-
-`for` est **interdit** pour cet exercice.
-
-### Fonction attendue
-
-```go
-package piscine
-
-func Fibonacci(index int) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel `main.go` :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	arg1 := 4
-	fmt.Println(piscine.Fibonacci(arg1))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-3
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/findnextprime.fr.md

@@ -1,45 +0,0 @@
-## findnextprime
-
-### Instructions
-
-Écrire une fonction qui renvoie le premier nombre premier qui est égal ou supérieur à l'`int` passé en paramètre.
-
-La fonction devra être optimisée pour éviter les time-outs avec le testeur.
-
-### Fonction attendue
-
-```go
-func FindNextPrime(nb int) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	arg1 := 5
-	arg2 := 4
-	fmt.Println(piscine.FindNextPrime(arg1))
-	fmt.Println(piscine.FindNextPrime(arg2))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-5
-5
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/firebase-demo.fr.md

@@ -1 +0,0 @@
-## firebase-demo

subjects/firstrune.fr.md

@@ -1,42 +0,0 @@
-## firstrune
-
-### Instructions
-
-Écrire une fonction qui retourne la première `rune` d'une `string`.
-
-### Fonction attendue
-
-```go
-func FirstRune(s string) rune {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"github.com/01-edu/z01"
-	piscine ".."
-)
-
-func main() {
-	z01.PrintRune(piscine.FirstRune("Hello!"))
-	z01.PrintRune(piscine.FirstRune("Salut!"))
-	z01.PrintRune(piscine.FirstRune("Ola!"))
-	z01.PrintRune('\n')
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-HSO
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/firstruneprog.fr.md

@@ -1,19 +0,0 @@
-## firstruneprog
-
-### Instructions
-
-Écrire un programme qui reçoit une `string` et qui retourne la première `rune` de cette `string`.
-
-### Utilisation :
-
-```console
-student@ubuntu:~/[[ROOT]]/firstruneprog$ go build
-student@ubuntu:~/[[ROOT]]/firstruneprog$ ./firstruneprog "this is not happening"
-t
-student@ubuntu:~/[[ROOT]]/firstruneprog$ ./firstruneprog "hello" | cat-e
-h$
-student@ubuntu:~/[[ROOT]]/firstruneprog$ ./firstruneprog "this" "is" "not" "happening"
-student@ubuntu:~/[[ROOT]]/firstruneprog$
-student@ubuntu:~/[[ROOT]]/firstruneprog$ ./firstruneprog
-student@ubuntu:~/[[ROOT]]/firstruneprog$
-```

subjects/firstword.fr.md

@@ -1,26 +0,0 @@
-## firstword
-
-### Instructions
-
-Écrire un programme qui prend une `string` et qui affiche son premier mot, suivi d'un retour à la ligne (`'\n'`).
-
-- Un mot est une section de `string` délimité par des espace ou par le début/fin d'une `string`.
-
-- L'output sera suivi d'un retour à la ligne (`'\n'`).
-
-- Si le nombre de paramètres n'est pas 1, ou si il n'y a pas de mots, le programme affiche un retour à la ligne (`'\n'`).
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test "hello there"
-hello
-student@ubuntu:~/[[ROOT]]/test$ ./test "hello   .........  bye"
-hello
-student@ubuntu:~/[[ROOT]]/test$ ./test
-
-student@ubuntu:~/[[ROOT]]/test$ ./test "hello" "there"
-
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/fixthemain.fr.md

@@ -1,48 +0,0 @@
-## Fix the Main
-
-### Instructions
-
-Réparer le programme ci-dessous.
-
-### Programme à réparer
-
-```go
-package piscine
-
-func PrintStr(str string) {
-	arrayRune := []rune(str)
-	for _, s := range arrayRune {
-		z01.PrintRune(s)
-	}
-}
-
-func CloseDoor(ptrDoor *Door) bool {
-	PrintStr("Door Closing...")
-	state = CLOSE
-	return true
-}
-
-func IsDoorOpen(Door Door) {
-	PrintStr("is the Door opened ?")
-	return Door.state = OPEN
-}
-
-func IsDoorClose(ptrDoor *Door) bool {
-	PrintStr("is the Door closed ?")
-}
-
-func main() {
-	door := &Door{}
-
-	OpenDoor(door)
-	if IsDoorClose(door) {
-		OpenDoor(door)
-	}
-	if IsDoorOpen(door) {
-		CloseDoor(door)
-	}
-	if door.state == OPEN {
-		CloseDoor(door)
-	}
-}
-```

subjects/flags.fr.md

@@ -1,49 +0,0 @@
-## flags
-
-### Instructions
-
-Write a **program** that can have as arguments `--insert` (or `-i`), `--order` (or `-o`) and a `string`.
-
-This program should :
-
-- Insert the string given to the `--insert` (or `-i`), in the `string` argument, if given.
-- Order the `string` argument (in ASCII order) if given the flag `--order` (or `-o`).
-- In case there are no arguments or the flag `--help` (or `-h`) is given, it should print the options, as shown in the example.
-
-Example of output :
-
-```console
-student@ubuntu:~/[[ROOT]]/flags$ go build
-student@ubuntu:~/[[ROOT]]/flags$ ./flags --insert=4321 --order asdad
-1234aadds
-student@ubuntu:~/[[ROOT]]/flags$ ./flags --insert=4321 asdad
-asdad4321
-student@ubuntu:~/[[ROOT]]/flags$ ./flags asdad
-asdad
-student@ubuntu:~/[[ROOT]]/flags$ ./flags --order 43a21
-1234a
-student@ubuntu:~/[[ROOT]]/flags$ ./flags
---insert
-  -i
-    This flag inserts the string into the string passed as argument.
---order
-  -o
-    This flag will behave like a boolean, if it is called it will order the argument.
-student@ubuntu:~/[[ROOT]]/flags$
-student@ubuntu:~/[[ROOT]]/flags$ ./flags -h
---insert
-  -i
-    This flag inserts the string into the string passed as argument.
---order
-  -o
-    This flag will behave like a boolean, if it is called it will order the argument.
-student@ubuntu:~/[[ROOT]]/flags$
-student@ubuntu:~/[[ROOT]]/flags$ ./flags --help
---insert
-  -i
-    This flag inserts the string into the string passed as argument.
---order
-  -o
-    This flag will behave like a boolean, if it is called it will order the argument.
-student@ubuntu:~/[[ROOT]]/flags$
-```

subjects/foreach.fr.md

@@ -1,37 +0,0 @@
-## foreach
-
-### Instructions
-
-Écrire une fonction `ForEach` qui, pour un tableau d'`int`, applique une fonction sur chaque éléments de ce tableau.
-
-### Fonction attendue
-
-```go
-func ForEach(f func(int), arr []int) {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import piscine ".."
-
-func main() {
-	arr := []int{1, 2, 3, 4, 5, 6}
-	piscine.ForEach(piscine.PutNbr, arr)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-123456
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/fprime.fr.md

@@ -1,34 +0,0 @@
-## fprime
-
-### Instructions
-
-Écrire un programme qui prend un `int` positif et qui affiche ses facteurs premiers sur la sortie standard, suivi d'un retour à la ligne (`'\n'`).
-
-- Les facteurs doivent être affichés en ordre croissant et séparés par `*`.
-
-- Si le nombre de paramètres est différent de 1, le programme affiche un retour à la ligne.
-
-- L'input (l'entrée), quand il y en a un, sera toujours valide.
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test 225225
-3*3*5*5*7*11*13
-student@ubuntu:~/[[ROOT]]/test$ ./test 8333325
-3*3*5*5*7*11*13*37
-student@ubuntu:~/[[ROOT]]/test$ ./test 9539
-9539
-student@ubuntu:~/[[ROOT]]/test$ ./test 804577
-804577
-student@ubuntu:~/[[ROOT]]/test$ ./test 42
-2*3*7
-student@ubuntu:~/[[ROOT]]/test$ ./test a
-
-student@ubuntu:~/[[ROOT]]/test$ ./test 0
-
-student@ubuntu:~/[[ROOT]]/test$ ./test 1
-
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/functions.fr.md

@@ -1,3 +0,0 @@
-## functions
-
-This repository aggregate every functions of the Zone 01 organization

subjects/gcd.fr.md

@@ -1,30 +0,0 @@
-## gcd
-
-### Instructions
-
-Écrire un programme qui prend deux `string` représentant deux entiers strictement positifs qui rentrent dans un `int`.
-
-Afficher leur plus grand diviseur commun suivi d'un retour à la ligne (`'\n'`).
-
-Si le nombre de paramètres est différent de 2, le programme affiche un retour à la ligne.
-
-Tous les arguments testés seront des `int` positifs.
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/gcd$ go build
-student@ubuntu:~/[[ROOT]]/gcd$ ./gcd 42 10 | cat -e
-2$
-student@ubuntu:~/[[ROOT]]/gcd$ ./gcd 42 12 | cat -e
-6$
-student@ubuntu:~/[[ROOT]]/gcd$ ./gcd 14 77 | cat -e
-7$
-student@ubuntu:~/[[ROOT]]/gcd$ ./gcd 17 3 | cat -e
-1$
-student@ubuntu:~/[[ROOT]]/gcd$ ./gcd | cat -e
-$
-student@ubuntu:~/[[ROOT]]/gcd$ ./gcd 50 12 4 | cat -e
-$
-student@ubuntu:~/[[ROOT]]/gcd$
-```

subjects/hello.fr.md

@@ -1,14 +0,0 @@
-## hello
-
-### Instructions
-
-Écrire un programme qui affiche "Hello World!" suivi d'un retour à la ligne (`'\n'`).
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-Hello World!
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/hiddenp.fr.md

@@ -1,26 +0,0 @@
-## hiddenp
-
-### Instructions
-
-Écrire un programme nommé `hiddenp` qui prend deux `string` et qui, si la première `string` est cachée dans la deuxième, affiche `1` suivi d'un retour à la ligne (`'\n'`), autrement il affiche `0` suivi d'un retour à la ligne.
-
-Considérons s1 et s2 comme étant des `string`. Il est considéré que s1 est cachée dans s2 si il est possbile de trouver chaque caractère de s1 dans s2, **dans le même ordre d'apparence que s1.**
-
-Si s1 est une `string` vide elle est considérée cachée dans n'importe quelle `string`.
-
-Si le nombre de paramètres est différent de 2, le programme affiche un retour à la ligne.
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/hiddenp$ go build
-student@ubuntu:~/[[ROOT]]/hiddenp$ ./hiddenp "fgex.;" "tyf34gdgf;'ektufjhgdgex.;.;rtjynur6" | cat -e
-1$
-student@ubuntu:~/[[ROOT]]/hiddenp$ ./hiddenp "abc" "2altrb53c.sse" | cat -e
-1$
-student@ubuntu:~/[[ROOT]]/hiddenp$ ./hiddenp "abc" "btarc" | cat -e
-0$
-student@ubuntu:~/[[ROOT]]/hiddenp$ ./hiddenp | cat -e
-$
-student@ubuntu:~/[[ROOT]]/hiddenp$
-```

subjects/index.fr.md

@@ -1,43 +0,0 @@
-## index
-
-### Instructions
-
-Écrire une fonction qui se comporte comme la fonction [`Index`](https://golang.org/pkg/strings/#Index).
-
-### Fonction attendue
-
-```go
-func Index(s string, toFind string) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.Index("Hello!", "l"))
-	fmt.Println(piscine.Index("Salut!", "alu"))
-	fmt.Println(piscine.Index("Ola!", "hOl"))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-2
-1
--1
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/inter.fr.md

@@ -1,20 +0,0 @@
-## inter
-
-### Instructions
-
-Écrire un programme qui prend deux `string` et qui affiche, sans doublons, les caractères qui apparaissent dans les deux `string`, dans l'ordre dans lequel ils apparaissent dans la première.
-
-- L'affichage sera suivi d'un retour à la ligne (`'\n'`).
-
-- Si le nombre d'arguments est différent de 2, le programme affiche un retour à la ligne (`'\n'`).
-
-### Utilisation
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test "padinton" "paqefwtdjetyiytjneytjoeyjnejeyj"
-padinto
-student@ubuntu:~/[[ROOT]]/test$ ./test ddf6vewg64f  twthgdwthdwfteewhrtag6h4ffdhsd
-df6ewg4
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/introduction.fr.md

@@ -1,45 +0,0 @@
-## Introduction
-
-### Instructions
-
-#### 1- get-ready
-
-Créer dans votre compte `git` le repository nommé `[[ROOT]]`.
-
-Une fois créé, cloner ce repository sur votre desktop.
-Si votre nom d'utilisateur `git` était `choumi` voici la commande qui devrait être utilisé :
-
-`git clone https://[[DOMAIN]]/git/choumi/[[ROOT]]`
-
-Cette commande doit être adaptée avec **votre propre username**.
-
-Ce repository sera le dossier où tous les exercises doivent être uploadés.
-
-#### 2- set
-
-Une fois que le repository est créé, écrire votre premier programme shell nommé `hello.sh`
-
-Quand ce programme est éxécuté il doit afficher `Hello {username}!`
-Où `{username}` est votre `username`
-
-##### Utilisation
-
-Si l'`{username}` est `choumi` :
-
-```console
-user@host:~/[[ROOT]]$ ./hello.sh
-Hello choumi!
-user@host:~/[[ROOT]]$
-```
-
-#### 3- go-say-hello
-
-Après que `hello.sh` s'exécute proprement, il doit être uploadé dans le repository avec les commandes ci-dessous :
-
-1. `git add hello.sh`
-2. `git commit -m "My very first commit"`
-3. `git push origin master`
-
-Une fois ces étapes appliquées, le fichier peut maintenant être soumis pour correction sur la platforme en cliquant le bouton `submit`.
-
-Cette action fera passer les tests sur le fichier rendu `hello.sh`.

subjects/isalpha.fr.md

@@ -1,46 +0,0 @@
-## isalpha
-
-### Instructions
-
-Écrire une fonction qui retourne `true` si la `string` passée en paramètre contient seulement des caractères alphanumériques, et qui retourne `false` autrement.
-
-### Fonction attendue
-
-```go
-func IsAlpha(str string) bool {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.IsAlpha("Hello! How are you?"))
-	fmt.Println(piscine.IsAlpha("HelloHowareyou"))
-	fmt.Println(piscine.IsAlpha("What's this 4?"))
-	fmt.Println(piscine.IsAlpha("Whatsthis4"))
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-false
-true
-false
-true
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/islower.fr.md

@@ -1,42 +0,0 @@
-## islower
-
-### Instructions
-
-Écrire une fonction qui retourne `true` si la `string` passée en paramètre contient seulement des caractères minuscules, et qui retourne `false` autrement.
-
-### Fonction attendue
-
-```go
-func IsLower(str string) bool {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programmes pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.IsLower("hello"))
-	fmt.Println(piscine.IsLower("hello!"))
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-true
-false
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/isnegative.fr.md

@@ -1,40 +0,0 @@
-## isnegative
-
-### Instructions
-
-Écrire une fonction qui affiche `'T'` (true) sur une seule ligne si l'`int` passé en paramètre est négatif, sinon elle affiche `'F'` (false).
-
-### Fonction attendue
-
-```go
-func IsNegative(nb int) {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import piscine ".."
-
-func main() {
-	piscine.IsNegative(1)
-	piscine.IsNegative(0)
-	piscine.IsNegative(-1)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-F
-F
-T
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/isnumeric.fr.md

@@ -1,42 +0,0 @@
-## isnumeric
-
-### Instructions
-
-Écrire une fonction qui retourne `true` si la `string` passée en paramètre contient seulement des caractères numériques, et qui retourne `false` autrement.
-
-### Fonction attendue
-
-```go
-func IsNumeric(str string) bool {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.IsNumeric("010203"))
-	fmt.Println(piscine.IsNumeric("01,02,03"))
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-true
-false
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/ispowerof2.fr.md

@@ -1,28 +0,0 @@
-## ispowerof2
-
-### Instructions
-
-Écrire un programme qui détermine si un nombre donné est une puissance de 2.
-
-Ce programme doit afficher `true` si le nombre donné est une puissance de 2, autrement il affiche `false`.
-
-- Si il y a plus d'un ou aucun argument le programme doit afficher un retour à la ligne (`'\n'`).
-
-- WSi il n'y a qu'un seul argument, ce sera toujours un int positif.
-
-### Usage :
-
-```console
-student@ubuntu:~/ispowerof2$ go build
-student@ubuntu:~/ispowerof2$ ./ispowerof2 2 | cat -e
-true$
-student@ubuntu:~/ispowerof2$ ./ispowerof2 64 | cat -e
-true$
-student@ubuntu:~/ispowerof2$ ./ispowerof2 513 | cat -e
-false$
-student@ubuntu:~/ispowerof2$ ./ispowerof2
-
-student@ubuntu:~/ispowerof2$ ./ispowerof2 64 1024
-
-student@ubuntu:~/ispowerof2$
-```

subjects/isprime.fr.md

@@ -1,43 +0,0 @@
-## isprime
-
-### Instructions
-
-Écrire une fonction qui renvoie `true` si l'`int` passé en paramètre est un nombre premier. Autrement elle renvoie `false`.
-
-La fonction devra être optimisée pour éviter les time-outs avec le testeur.
-
-### Fonction attendue
-
-```go
-func IsPrime(nb int) bool {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.IsPrime(5))
-	fmt.Println(piscine.IsPrime(4))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-true
-false
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/isprintable.fr.md

@@ -1,42 +0,0 @@
-## isprintable
-
-### Instructions
-
-Écrire une fonction qui retourne `true` si la `string` passée en paramètre contient seulement des caractères majuscules, et qui retourne `false` autrement.
-
-### Fonction attendue
-
-```go
-func IsPrintable(str string) bool {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.IsPrintable("Hello"))
-	fmt.Println(piscine.IsPrintable("Hello\n"))
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-true
-false
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/issorted.fr.md

@@ -1,51 +0,0 @@
-## issorted
-
-### Instructions
-
-Écrire une fonction `IsSorted` qui retourne `true` si la slice d'`int` est triée, et qui retourne `false` autrement.
-
-La fonction passée en paramètre retourne un `int` positive si `a` (le premier argument) est supérieur à `b`(le deuxième argument), elle retourne `0` si ils sont égaux et elle retourne un `int` négatif autrement.
-
-Pour faire vos tests, vous devez coder votre propre fonction `f`.
-
-### Fonction attendue
-
-```go
-func IsSorted(f func(a, b int) int, tab []int) bool {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction (sans `f`) :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	tab1 := []int{0, 1, 2, 3, 4, 5}
-	tab2 := []int{0, 2, 1, 3}
-
-	result1 := piscine.IsSorted(f, tab1)
-	result2 := piscine.IsSorted(f, tab2)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-true
-false
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/isupper.fr.md

@@ -1,42 +0,0 @@
-## isupper
-
-### Instructions
-
-Écrire une fonction qui retourne `true` si la `string` passée en paramètre contient seulement des caractères majuscules, et qui retourne `false` autrement.
-
-### Fonction attendue
-
-```go
-func IsUpper(str string) bool {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel [programme](TODO-LINK) pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	fmt.Println(piscine.IsUpper("HELLO"))
-	fmt.Println(piscine.IsUpper("HELLO!"))
-
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-true
-false
-stude0t@ubuntu:~$
-```

subjects/iterativefactorial.fr.md

@@ -1,42 +0,0 @@
-## iterativefactorial
-
-### Instructions
-
-Écrire une fonction **itérative** qui renvoie la factorielle d'un `int` passé en paramètre.
-
-Les erreurs (valeurs non possibles ou overflows) renverront `0`.
-
-### Fonction attendue
-
-```go
-func IterativeFactorial(nb int) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	arg := 4
-	fmt.Println(piscine.IterativeFactorial(arg))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-24
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/iterativepower.fr.md

@@ -1,44 +0,0 @@
-## iterativepower
-
-### Instructions
-
-Écrire une fonction **itérative** qui renvoie la puissance de deux `int` passés en paramètre.
-
-Les puissances négatives renverront `0`. Les overflows **ne doivent pas** être gérés.
-
-### Fonction attendue
-
-```go
-func IterativePower(nb int, power int) int {
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-
-func main() {
-	arg1 := 4
-	arg2 := 3
-	fmt.Println(piscine.IterativePower(arg1, arg2))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-64
-student@ubuntu:~/[[ROOT]]/test$
-```

subjects/itoa.fr.md

@@ -1,15 +0,0 @@
-## itoa
-
-### Instructions
-
-- Écrire une fonction qui reproduit le comportement de la fonction `Itoa` en Go. `Itoa` transforme un nombre représenté en `int` (entier) en `string` (chaîne de caractères).
-
-- Pour cet exercice la gestion des signes + ou - **doit être** prise en compte.
-
-## Fonction attendue
-
-```go
-func Itoa(n int) string {
-
-}
-```

subjects/itoabase.fr.md

@@ -1,24 +0,0 @@
-## itoabase
-
-### Instructions
-
-Écrire une fonction qui:
-
-- convertit une valeur `int` en `string` en utilisant la base spécifiée en argument
-- et qui retourne cette `string`
-
-Cette base est exprimée comme un `int`, de 2 à 16. Les caractères compris dans la base sont les chiffres de 0 à 9, suivis des lettres majuscules de A à F.
-
-Par exemple, la base `4` sera équivalente à "0123" et la base `16` sera équivalente à "0123456789ABCDEF".
-
-Si la valeur est négative, la `string` résultante doit être précédée d'un signe moins `-`.
-
-Seuls des arguments valables seront testés.
-
-### Fonction attendue
-
-```go
-func ItoaBase(value, base int) string {
-
-}
-```

subjects/itoabaseprog.fr.md

@@ -1,35 +0,0 @@
-## itoabase
-
-##**AVERTISSEMENT! TRÈS IMPORTANT!**
-
-Pour cet exercice une fonction sera testée **avec le main de l'examen**. Cependant l'étudiant **doit quand même** rendre un programme structuré:
-
-Cela signifie que:
-
-- Le package doit être nommé `package main`.
-- Le code rendu doit avoir une fonction main déclarée(`func main()`) même si elle est vide.
-- La fonction main déclarée doit **aussi passer** le `Restrictions Checker`(le testeur de fonctions illégales). Il est conseillé à l'étudiant de rendre une fonction main vide après ses tests finis.
-- Toutes les autres régles sont les mêmes que pour un `programme`.
-
-### Instructions
-
-Écrire une fonction qui:
-
-- convertit une valeur `int` en `string` en utilisant la base spécifiée en argument
-- et qui retourne cette `string`
-
-Cette base est exprimée comme un `int`, de 2 à 16. Les caractères compris dans la base sont les chiffres de 0 à 9, suivis des lettres majuscules de A à F.
-
-Par exemple, la base `4` sera équivalente à "0123" et la base `16` sera équivalente à "0123456789ABCDEF".
-
-Si la valeur est négative, la `string` résultante doit être précédée d'un signe moins `-`.
-
-Seuls des arguments valables seront testés.
-
-### Fonction attendue
-
-```go
-func ItoaBase(value, base int) string {
-
-}
-```

subjects/join.fr.md

@@ -1,40 +0,0 @@
-## join
-
-### Instructions
-
-Écrire une fonction qui retourne la concaténation de deux `string` **séparées** par le séparateur passées en paramètres.
-
-### Fonction attendue
-
-```go
-func Join(strs []string, sep string) string{
-
-}
-```
-
-### Utilisation
-
-Voici un éventuel programme pour tester votre fonction :
-
-```go
-package main
-
-import (
-	"fmt"
-	piscine ".."
-)
-
-func main() {
-	toConcat := []string{"Hello!", " How", " are", " you?"}
-	fmt.Println(piscine.Join(toConcat, ":"))
-}
-```
-
-Et son résultat :
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ go build
-student@ubuntu:~/[[ROOT]]/test$ ./test
-Hello!: How: are: you?
-student@ubuntu:~/[[ROOT]]/test$
-```