Comment lire des entiers à partir d'entrées séparées par des espaces dans Golang : une approche récursive ?

Lire des entiers à partir d'une entrée séparée par des espaces dans Golang : une approche efficace

En programmation, lire un ensemble d'entiers séparés par un espace à partir du l'entrée standard et leur stockage efficace dans un tableau est une tâche courante. Une façon d’y parvenir consiste à utiliser une boucle for simple. Cependant, il existe une technique qui exploite la récursivité pour minimiser le code tout en conservant des performances optimales.

Utiliser la récursivité sans boucles explicites

L'extrait de code Go suivant montre comment lire entiers à partir de l'entrée standard sans utiliser de boucles for ou goto :

<code class="go">package main

import "fmt"

func main() {
    var n int
    fmt.Println(`Enter the number of integers`)
    if _, err := fmt.Scan(&n); err != nil {
        panic(err)
    }
    fmt.Println(`Enter the integers`)
    all := make([]int, n)
    ReadN(all, 0, n)
    fmt.Println(all)
}

// Recursively reads n integers into all starting from position i.
func ReadN(all []int, i, n int) {
    if n == 0 {
        return
    }
    if _, err := fmt.Scan(&all[i]); err != nil {
        panic(err)
    }
    ReadN(all, i+1, n-1)
}</code>

Exemple de sortie

Supposons que l'entrée standard contienne les entiers :

Enter the number of integers
3
Enter the integers
23 45 66

L'exécution du programme produirait :

[23 45 66]

Optimisation de l'analyse des entrées

Pour optimiser davantage l'analyse des entrées, envisagez de remplacer la fonction fmt.Scan dans ReadN par un lecteur personnalisé qui permet un traitement d'entrée plus rapide :

<code class="go">type reader struct {
    val int
}

func (r *reader) Read(b []byte) (int, error) {
    w, err := fmt.Scanf("%d", &r.val)
    if err != nil {
        return w, err
    }
    b[0] = byte(r.val)
    return 1, err
}</code>

Dans cette implémentation optimisée, un lecteur personnalisé est créé avec un champ val pour contenir la valeur entière. La méthode Read utilise fmt.Scanf pour lire un entier à partir de l'entrée standard et le stocker dans val. Lors de la lecture à partir du lecteur personnalisé, un seul octet est traité, ce qui réduit considérablement la surcharge.

En incorporant ces techniques, vous pouvez lire efficacement des ensembles d'entiers à partir de l'entrée standard dans Golang, maximisant les performances tout en minimisant la complexité du code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!