Exercice - Utiliser les flux de contrôle dans Go

Effectué

Pratiquez ce que vous avez appris dans ce module en effectuant des exercices de codage. Ces exercices ne sont pas compliqués et vous trouverez des solutions dans l’unité suivante.

Essayez d’abord de résoudre les exercices. Comparez ensuite vos résultats avec les solutions. Vous pouvez toujours passer en revue le module si vous ne vous souvenez pas d’un détail important.

Écrire un programme FizzBuzz

Tout d’abord, écrivez un programme qui imprime les chiffres 1 à 100, avec les modifications suivantes :

• Imprimer Fizz si le nombre est divisible par 3.
• Imprimer Buzz si le nombre est divisible par 5.
• Imprimer FizzBuzz si le nombre est divisible par 3 et par 5.
• Imprimer le nombre si aucun des cas précédents ne correspond.

Essayez d’utiliser l’instruction switch.

Trouver les nombres premiers

Écrivez un programme pour rechercher tous les nombres premiers inférieurs à 20. Un nombre premier est tout nombre supérieur à 1 qui peut être divisé uniformément uniquement par lui-même et 1. Pour être « uniformément divisé », cela signifie qu’il n’y a pas de reste après l’opération de division. Comme la plupart des langages de programmation, Go fournit un moyen de vérifier si une opération de division produit un reste. Nous pouvons utiliser l’opérateur (signe pourcentage) % du modulo.

Dans cet exercice, vous allez mettre à jour une fonction nommée findprimes pour vérifier si un nombre est un nombre premier. La fonction a un argument entier et retourne une valeur booléenne. La fonction teste si le nombre saisi est un nombre premier en vérifiant la présence d’un reste. Si le nombre est un nombre premier, la fonction renvoie true.

Utilisez l’extrait de code suivant comme point de départ et remplacez toutes les instances de ?? par la syntaxe correcte :

package main

import "fmt"

func findprimes(number int) bool {
	for i := 2; i ?? number; i ?? {
        if number ?? i == ?? {
			return false
        }
    }

	if number ?? {
		return true
	} else {
	    return false
	}
}

func main() {
    fmt.Println("Prime numbers less than 20:")

    for number := ??; number ?? 20; number++ {
        if ?? {
            fmt.Printf("%v ", number)
        }
    }
}

Ce programme vérifie les nombres de 1 à 20, puis imprime le nombre s’il s’agit d’un nombre premier. Modifiez l’exemple comme décrit.

• Dans la fonction main, parcourez tous les nombres à vérifier. Quittez la boucle après avoir vérifié le dernier nombre.
• Appelez la fonction findprimes pour vérifier le nombre. Si la fonction retourne true, imprimez le nombre premier.
• Dans la boucle findprimes, démarrez à partir de 2 et répétez l’opération jusqu’à ce que la valeur du compteur soit supérieure ou égale à la valeur number.
• Vérifie si number est uniformément divisible par la valeur de compteur actuelle. Si c’est le cas, quittez la boucle.
• Lorsque number est un nombre premier, retourne true ; sinon, retourne false.
• Conseil : Veillez à gérer correctement le cas où le numéro d’entrée est 1.

Demander un nombre, mettre en état d’alerte si celui-ci est négatif

Écrivez un programme qui demande un nombre à un utilisateur. Utilisez l’extrait de code suivant comme point de départ :

package main

import "fmt"

func main() {
    val := 0
    fmt.Print("Enter number: ")
    fmt.Scanf("%d", &val)
    fmt.Println("You entered:", val)
}

Ce programme demande un nombre et l’imprime. Modifiez l’exemple de code pour :

• Demander continuellement un nombre entier. La condition de sortie de la boucle doit être une entrée utilisateur qui est un nombre négatif.
• Bloquez le programme quand l’utilisateur saisit un nombre négatif. Imprimez ensuite l’erreur de trace de la pile.
• Si le nombre est 0, imprimez 0 is neither negative nor positive. Continuez à demander un nombre.
• Lorsque le nombre est positif, imprime You entered: X (où X est le nombre saisi). Continuez à demander un nombre.

Pour le moment, ignorez la possibilité que l’utilisateur entre une valeur différente d’un nombre entier.