Les Tableaux

Travail à faire - Traitement des transactions bancaires

L'énoncé demande de concevoir un algorithme gérant des dépôts et des retraits sur $N$ comptes bancaires en utilisant des tableaux. Les données des comptes sont réparties dans deux tableaux unidimensionnels dits "parallèles" : l'indice i permet de faire le lien entre le numéro d'un compte (NUMERO[i]) et son solde (SOLDE[i]).

Selon les règles de déclaration vues dans le cours, la taille d'un tableau doit être fixée au préalable. Nous allons donc déclarer des tableaux de taille maximale suffisante (par exemple 100 éléments), mais nous n'en utiliserons qu'un nombre N fourni par l'utilisateur.

L'algorithme requiert trois étapes logiques :

1. L'initialisation : Lire le nombre de comptes N, puis remplir les tableaux avec les numéros et soldes initiaux.
2. La saisie des transactions : Utiliser une boucle Répéter ... Jusqu'à pour demander les opérations en continu tant que l'utilisateur ne saisit pas le code d'arrêt 'F'.
3. La recherche et la mise à jour : Pour chaque transaction ('D' ou 'E'), parcourir le tableau NUMERO pour trouver l'indice du compte, puis modifier la case correspondante du tableau SOLDE.

Voici l'algorithme résolvant ce problème :

Algorithme Traitement_Comptes_Bancaires
Var
    N, i, pos (entier)
    code (caractère)
    compte_recherche (chaîne de caractères)
    montant (réel)
    trouve (booléen)
    
    // Déclaration des tableaux avec une taille maximale de 100
    NUMERO (Tableau [1..100] de chaîne de caractères)
    SOLDE (Tableau [1..100] de réel)

Début
    // --- ÉTAPE 1 : Initialisation des comptes ---
    Répéter
        écrire ("Entrez le nombre de comptes à gérer (entre 1 et 100) :")
        lire (N)
    Jusqu'à (N >= 1 et N <= 100)

    pour i de 1 à N faire
        écrire ("Donner le numéro du compte ", i)
        lire (NUMERO[i])
        écrire ("Donner le solde initial du compte ", NUMERO[i])
        lire (SOLDE[i])
    fin pour

    // --- ÉTAPE 2 : Traitement des transactions ---
    Répéter
        écrire ("Code transaction (D: dépôt, E: retrait, F: fin) :")
        lire (code)

        si (code = 'D') ou (code = 'E') alors
            écrire ("Numéro de compte pour la transaction :")
            lire (compte_recherche)
            écrire ("Montant de la transaction :")
            lire (montant)

            // ÉTAPE 3 : Recherche séquentielle du compte
            trouve ← faux
            pour i de 1 à N faire
                si (NUMERO[i] = compte_recherche) alors
                    trouve ← vrai
                    pos ← i
                fin si
            fin pour

            // Mise à jour du solde si le compte a été trouvé
            si (trouve = vrai) alors
                si (code = 'D') alors
                    SOLDE[pos] ← SOLDE[pos] + montant
                    écrire ("Dépôt validé. Nouveau solde : ", SOLDE[pos])
                sinon // C'est un retrait (code = 'E')
                    si (SOLDE[pos] >= montant) alors
                        SOLDE[pos] ← SOLDE[pos] - montant
                        écrire ("Retrait validé. Nouveau solde : ", SOLDE[pos])
                    sinon
                        écrire ("Opération refusée : solde insuffisant.")
                    fin si
                fin si
            sinon
                écrire ("Erreur : Le compte ", compte_recherche, " n'existe pas.")
            fin si
            
        sinon
            si (code ≠ 'F') alors
                écrire ("Erreur : Code non reconnu. Utilisez D, E ou F.")
            fin si
        fin si

    Jusqu'à (code = 'F')
Fin

Méthode

Face à un problème impliquant des tableaux parallèles (comme NUMERO et SOLDE), la clé est la gestion de l'indice. Les valeurs qui se correspondent partagent toujours la même position i dans leurs tableaux respectifs.

1. Gérer les déclarations statiques : Dans de nombreux langages algorithmiques (et comme précisé dans ce cours), la taille d'un tableau ne peut pas varier en cours d'exécution. Si le nombre exact de données N est dicté par l'utilisateur, déclarez toujours une constante ou une borne maximale (ici 100) assez large pour couvrir les besoins de l'application, et utilisez une boucle allant de 1 jusqu'à N pour le traitement.
2. Isoler la recherche : Ne modifiez jamais un tableau pendant que vous le parcourez pour y chercher un élément. Utilisez d'abord une boucle pour couplée à une variable booléenne (trouve) pour identifier la présence et la position (pos) de la donnée.
3. Contrôler les règles de gestion : Bien que l'énoncé ne l'exige pas explicitement, l'ajout d'une condition empêchant un retrait d'un montant supérieur au solde disponible démontre une excellente compréhension de la logique d'une application réelle. C'est ce qui différencie un code simplement exécutable d'un code robuste.