Génération de Nombres Aléatoires avec le Package rand

Dans Go, le package math/rand permet de générer des nombres pseudo-aléatoires. L'utilisation basique implique la fonction Intn pour obtenir un entier dans un intervalle spécifié. Sans initialisation du générateur, les séquences peuvent se répéter.

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    for idx := 0; idx < 8; idx++ {
        valeur := rand.Intn(750) // Plage : [0, 750)
        fmt.Println(valeur)
    }
}

Pour garantir l'unicité des séquences à chaque exécution, il faut initialiser la graine avec une valeur unique, comme l'horodatage actuel.

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    for compteur := 0; compteur < 5; compteur++ {
        nombre := rand.Intn(200) // Intervalle [0, 200)
        fmt.Println("Nombre généré :", nombre)
    }
}

Jeux de Devises : Interaction Console et Logique Conditionnelle

Un exemple courant est un jeu où l'utilisateur doit deviner un prix généré aléatoirement. L'entrée utilisateur est lue via fmt.Scan, et des conditions comparent la tentative avec la valeur cible.

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    var tentative int
    essais := 0
    rand.Seed(time.Now().Unix())
    prixReel := rand.Intn(150) // Prix dans [0, 150)

    for {
        fmt.Print("Entrez votre estimation du prix : ")
        fmt.Scan(&tentative)
        switch {
        case tentative > prixReel:
            fmt.Println("Estimation trop élevée")
            essais++
        case tentative < prixReel:
            fmt.Println("Estimation trop basse")
            essais++
        default:
            essais++
            fmt.Printf("Correct ! Le prix était %d. Tentatives : %d\n", prixReel, essais)
            return
        }
    }
}

Pour modulariser le code, la logique peut être encapsulée dans une fonction dédiée, retournant le nombre d'essais.

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    resultats := jouerJeuDevises()
    fmt.Println("Total des tentatives réussies :", resultats)
}

func jouerJeuDevises() int {
    rand.Seed(time.Now().UnixNano())
    cible := rand.Intn(250)
    var saisie, tentatives int

    for {
        fmt.Printf("Deviner le prix (0-%d) : ", 249)
        fmt.Scan(&saisie)
        tentatives++

        if saisie == cible {
            fmt.Println("Bravo, deviné !")
            return tentatives
        } else if saisie > cible {
            fmt.Println("Trop haut")
        } else {
            fmt.Println("Trop bas")
        }
    }
}

Lecture d'Entrées Avancées avec le Package bufio

Pour des entrées plus robustes, notamment pour lire des chaînes de caractères avec espaces, le package bufio offre des alternatives à fmt.Scan.

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    fmt.Println("Saisissez du texte :")
    texte := lireEntreeBufio()
    fmt.Println("Entrée reçue :", texte)
}

func lireEntreeBufio() string {
    lecteur := bufio.NewReader(os.Stdin)
    ligne, _, err := lecteur.ReadLine()
    if err != nil {
        fmt.Println("Erreur de lecture :", err)
        return ""
    }
    return string(ligne)
}

Une autre approche utilise bufio.Scanner, qui gère automatiquement la fin de ligne et permet une lecture plus intuitive.

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    fmt.Println("Entrez une phrase :")
    phrase := lireAvecScanner()
    fmt.Println("Phrase capturée :", phrase)
}

func lireAvecScanner() string {
    scanner := bufio.NewScanner(os.Stdin)
    if scanner.Scan() {
        return scanner.Text()
    }
    return "Aucune entrée"
}

Ces techniques permettent de gérer divers scénarios d'entrée console dans des applications Go, de la saisie simple à la lecture de lignes complexes.