forked from root/public
![32063953+xpetit@users.noreply.github.com](/git/assets/img/avatar_default.png)
![xpetit](/git/assets/img/avatar_default.png)
207 changed files with 0 additions and 8350 deletions
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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 |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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." |
|
||||||
``` |
|
@ -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... |
|
@ -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$ |
|
||||||
``` |
|
@ -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`... |
|
@ -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$ |
|
||||||
``` |
|
@ -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... |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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. |
|
@ -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... |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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. |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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`. |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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!! |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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 |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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 |
|
||||||
``` |
|
@ -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() { |
|
||||||
|
|
||||||
} |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -1 +0,0 @@ |
|||||||
## firebase-demo |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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) |
|
||||||
} |
|
||||||
} |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -1,3 +0,0 @@ |
|||||||
## functions |
|
||||||
|
|
||||||
This repository aggregate every functions of the Zone 01 organization |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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`. |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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:~$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
@ -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 { |
|
||||||
|
|
||||||
} |
|
||||||
``` |
|
@ -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 { |
|
||||||
|
|
||||||
} |
|
||||||
``` |
|
@ -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 { |
|
||||||
|
|
||||||
} |
|
||||||
``` |
|
@ -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$ |
|
||||||
``` |
|
Some files were not shown because too many files changed in this diff diff.show_more
Loading…
Reference in new issue