Exercices

Exercices¶

1. Ecrire un programme qui crée deux variables avec des valeurs entières aléatoires entre 0 et 30. Ensuite, permuter leurs valeurs via une fonction. (utiliser "math/rand" et sa fonction rand.Intn)
2. Implémenter une fonction qui claclule la racine carrée d'un entier. Méthode proposée: chercher l'entier z pour lequel z * z = x. Si x n'est pas un carré parfait, retourner 0.
3. Implémenter une fonction qui claclule la racine carrée d'un float64. Méthode proposée: ajuster une valeur de départ z avec cette formule: z -= (z*z - x) / (2*z) à chaque itération jusqu'à ce que la différence entre z * z et x soit inférieure à une certaine précision epsilon. Démarrer avec z = 1.0 et prendre epsilon = 0.00001.
4. Créer un package mysqrt et y déplacer les deux fonctions définies plus haut.
5. Créer une fonction qui prend une string en argument et donne le nombre d'occurences de ses mots (utiliser strings.Fields) pour séparer les mots dans un slice.
6. Créer un programme qui lit un fichier texte et affiche le nombre de mots qu'il contient.

Solutions¶

Ecrire un programme qui crée deux variables avec des valeurs aléatoires et ensuite permute leurs valeurs via une fonction.

In [14]:

package main

import (
	"fmt"
  "math/rand"
)

func swap(x, y int) (int, int) {
  return y, x
}

func main() {
	a := rand.Intn(30)
  b := rand.Intn(30)
  fmt.Println(a, b)
  fmt.Println(swap(a, b))
  i, j := swap(a, b) // i prend la valeur b et j celle de a
  fmt.Println(i, j)
}

package main import ( "fmt" "math/rand" ) func swap(x, y int) (int, int) { return y, x } func main() { a := rand.Intn(30) b := rand.Intn(30) fmt.Println(a, b) fmt.Println(swap(a, b)) i, j := swap(a, b) // i prend la valeur b et j celle de a fmt.Println(i, j) }

10 9
9 10
9 10

Implémenter une fonction qui claclule la racine carrée d'un entier. Méthode proposée: chercher l'entier z pour lequel z * z = x. Si x n'est pas un carré parfait, retourner 0.

In [15]:

package main

import (
	"fmt"
)

func Sqrt(x int) int {
  for i := 1; i * i <= x ; i += 1 {
    if i * i == x {
      return i
    }
  }
  return 0
}

func main() {
	fmt.Println(Sqrt(4), Sqrt(9), Sqrt(10))
}

package main import ( "fmt" ) func Sqrt(x int) int { for i := 1; i * i <= x ; i += 1 { if i * i == x { return i } } return 0 } func main() { fmt.Println(Sqrt(4), Sqrt(9), Sqrt(10)) }

2 3 0

Implémenter une fonction qui claclule la racine carrée d'un float64. Méthode proposée: ajuster une valeur de départ z avec cette formule: z -= (z*z - x) / (2*z) à chaque itération jusqu'à ce que la différence entre z * z et x soit inférieure à une certaine précision epsilon. Démarrer avec z = 1.0 et prendre epsilon = 0.00001.

In [21]:

package main

import (
	"fmt"
  "math"
)

func Sqrt(x, start, epsilon float64) float64 {
  z := start
  fmt.Println("computing sqrt of", x, "with start", start, "epsilon", epsilon)
  for math.Abs(z*z - x) > epsilon {
    z -= (z*z - x) / (2*z)
    fmt.Println(z, z*z, "math.abs(z*z - x)", math.Abs(z*z - x))
  }
  return z
}

func main() {
	fmt.Println(Sqrt(4, 1.0, 0.0001), Sqrt(9, 1.0, 0.0001), Sqrt(10, 1.0, 0.0001))
}

package main import ( "fmt" "math" ) func Sqrt(x, start, epsilon float64) float64 { z := start fmt.Println("computing sqrt of", x, "with start", start, "epsilon", epsilon) for math.Abs(z*z - x) > epsilon { z -= (z*z - x) / (2*z) fmt.Println(z, z*z, "math.abs(z*z - x)", math.Abs(z*z - x)) } return z } func main() { fmt.Println(Sqrt(4, 1.0, 0.0001), Sqrt(9, 1.0, 0.0001), Sqrt(10, 1.0, 0.0001)) }

computing sqrt of 4 with start 1 epsilon 0.0001
2.5 6.25 math.abs(z*z - x) 2.25
2.05 4.2025 math.abs(z*z - x) 0.20249999999999926
2.000609756097561 4.002439396192742 math.abs(z*z - x) 0.0024393961927419733
2.0000000929222947 4.000000371689188 math.abs(z*z - x) 3.7168918762521686e-07
computing sqrt of 9 with start 1 epsilon 0.0001
5 25 math.abs(z*z - x) 16
3.4 11.559999999999999 math.abs(z*z - x) 2.5599999999999996
3.023529411764706 9.141730103806228 math.abs(z*z - x) 0.14173010380622786
3.00009155413138 9.00054933317044 math.abs(z*z - x) 0.000549333170440042
3.000000001396984 9.000000008381903 math.abs(z*z - x) 8.38190317349087e-09
computing sqrt of 10 with start 1 epsilon 0.0001
5.5 30.25 math.abs(z*z - x) 20.25
3.659090909090909 13.388946280991735 math.abs(z*z - x) 3.3889462809917363
3.196005081874647 10.21444848336857 math.abs(z*z - x) 0.21444848336856936
3.1624556228038903 10.00112556620394 math.abs(z*z - x) 0.0011255662039413904
3.162277665175675 10.000000031668918 math.abs(z*z - x) 3.1668918418998053e-08
2.0000000929222947 3.000000001396984 3.162277665175675

Créer un package mysqrt et y déplacer les deux fonctions définies plus haut.

Solution disponible dans ce projet.

A retenir: les packages sont identifiés par une url. Si c'est un package local, on utilise replace pour indiquer le chemin local.

Créer une fonction qui prend une string en argument et donne le nombre d'occurences de ses mots (utiliser strings.Fields) pour séparer les mots dans un slice.

In [2]:

package main

import (
	"strings"
  "fmt"
)

func WordCount(s string) map[string]int {
	return map[string]int{"x": 1}
}

func main() {
  s1 := "I love go. Let's go"
	fmt.Println(s1, WordCount(s1))
  s2 := "to go, or not to go. That it the question, or not that is the question"
	fmt.Println(s2, WordCount(s2))
}

package main import ( "strings" "fmt" ) func WordCount(s string) map[string]int { return map[string]int{"x": 1} } func main() { s1 := "I love go. Let's go" fmt.Println(s1, WordCount(s1)) s2 := "to go, or not to go. That it the question, or not that is the question" fmt.Println(s2, WordCount(s2)) }

I love Go. Let's go map[x:1]