| §2.2 Tableaux unidimensionnels d'entiers
Leçons 11 à 14
§2.2 Tableaux unidimensionnels d'entiers
Description, remplissage, sortie du tableau
Calculer la somme des éléments du tableau
Recherche séquentielle dans un tableau
Trier un tableau
Mots clés:
Tableau
description du tableau
remplir le tableau
sortie du tableau
traitement de tableau
recherche séquentielle
tri
Jusqu'à présent, nous avons travaillé avec des types de données simples. Pour résoudre de nombreux problèmes pratiques, les types simples sont transformés en types de données composites, appelés structures de données. Un exemple d’une telle structure est un tableau unidimensionnel.
Un tableau est une collection d’un nombre fixe d’éléments du même type, auxquels est attribué un nom commun. Un élément de tableau individuel est accessible par son numéro (index).
Avec des objets similaires - séquences de nombres- vous vous êtes déjà rencontrés en cours de mathématiques. Par exemple, les membres d'une progression arithmétique étaient désignés comme suit : a 1, a 2, a 3, ..., a n.
La dimension d'un tableau est le nombre d'indices requis pour accéder de manière unique à un élément du tableau. Les tableaux avec un indice sont appelés unidimensionnels, avec deux - bidimensionnels, etc. Nous considérerons des tableaux unidimensionnels.
La solution à divers problèmes liés au traitement des tableaux repose sur l'utilisation d'algorithmes standards tels que :
Additionner les valeurs des éléments du tableau ;
rechercher un élément avec des propriétés spécifiées ;
tri des tableaux.
2.2.1. Description du tableau
Avant de l'utiliser dans un programme, un tableau doit être décrit, c'est-à-dire que le nom du tableau, le nombre d'éléments du tableau et leur type doivent être indiqués. Ceci est nécessaire pour allouer une zone mémoire de la taille requise pour stocker le tableau. Vue générale de la description d'un tableau unidimensionnel :
Exemple
Un tableau de 10 valeurs entières est décrit ici. Lorsque cette instruction est exécutée, de l'espace sera alloué dans la mémoire de l'ordinateur pour stocker dix variables entières.
Un tableau dont les éléments ont donné des valeurs initiales peut être décrit dans la section description des constantes :
Dans ce cas, les cellules mémoire successives ne sont pas simplement allouées - les valeurs correspondantes y sont immédiatement saisies.
2.2.2. Remplissage d'un tableau
Vous pouvez remplir un tableau soit en saisissant la valeur de chaque élément à partir du clavier, soit en attribuant certaines valeurs aux éléments du programme. Dans ce cas, une boucle avec un paramètre peut être utilisée.
Par exemple, pour saisir au clavier les valeurs des éléments du tableau a décrit ci-dessus, utilisez la boucle suivante avec un paramètre :
Vous pouvez définir les valeurs des éléments du tableau à l'aide de l'opérateur d'affectation. Par exemple:
Le fragment suivant du programme organise le remplissage d'un tableau d'entiers a, composé de 10 éléments, avec des nombres aléatoires dont les valeurs varient entre 0 et 99 :
2.2.3. Sortie du tableau
Dans de nombreux cas, il est utile d'afficher les valeurs des éléments du tableau à l'écran. Ainsi, si les valeurs du tableau ont été générées de manière aléatoire, vous devez alors savoir quel est le tableau d'origine. Vous devez également savoir ce qu'est devenu le tableau après le traitement.
Les valeurs des éléments du tableau peuvent être imprimées dans une chaîne, séparées par un espace :
L'option suivante pour afficher les éléments du tableau avec des explications dans une colonne est plus visuelle :
Sur la base des exemples discutés, nous écrirons un programme qui effectue : remplir un tableau d'entiers UN , composé de 10 éléments, nombres aléatoires dont les valeurs varient entre 0 et 99 ; sortie du tableau UN à l'écran.
2.2.4. Calculer la somme des éléments du tableau
Exemple. Dans une localité, j'ai des maisons. On sait combien de personnes vivent dans chaque maison. Créons un algorithme pour calculer le nombre de résidents d'une colonie.
Les données initiales (nombre d'habitants) sont présentées ici à l'aide d'un tableau unidimensionnel UN contenant n éléments : a - le nombre d'habitants de la maison 1, a - le nombre d'habitants de la maison 2, ..., a[n] - le nombre d'habitants de la maison n. En général, a[i] est le nombre d'habitants de la maison n, où i prend des valeurs entières de 1 à n (nous le désignerons brièvement dans le schéma fonctionnel par ). Le résultat de l'algorithme est noté s.
La sommation des éléments du tableau s'effectue selon le même principe que la sommation des valeurs de variables simples : en ajoutant les termes un à un :
1) une cellule mémoire (variable s) est déterminée dans laquelle le résultat de la sommation sera accumulé séquentiellement ;
2) la variable s reçoit la valeur initiale 0 - un nombre qui n'affecte pas le résultat de l'addition ;
3) pour chaque élément du tableau, sa valeur actuelle est lue à partir de la variable s et ajoutée à la valeur de l'élément du tableau ; le résultat résultant est affecté à la variable s.
Le processus décrit peut être clairement décrit comme suit :
Écrivons le programme correspondant en Pascal.
Comparez les programmes n_2 et n_3. Sélectionnez-y des blocs communs. Notez les différences.
Comment le programme n_3 clarifie-t-il les informations présentées dans l'exemple sur les maisons de la localité ?
2.2.5. Recherche séquentielle dans un tableau
En programmation recherche- l'une des tâches non informatiques les plus courantes.
Les tâches de recherche typiques suivantes peuvent être distinguées :
1) trouver le plus grand (le plus petit) élément du tableau ;
2) trouver un élément du tableau dont la valeur est égale à la valeur donnée.
Pour résoudre de tels problèmes, le programme doit organiser une visualisation séquentielle des éléments du tableau et une comparaison de la valeur de l'élément visualisé suivant avec un certain échantillon.
Examinons en détail la solution des problèmes du premier type : trouver le plus grand (le plus petit) élément.
Imaginons un tableau unidimensionnel sous la forme d'une pile de cartes sur chacune desquelles est écrit un numéro. Ensuite, l'idée de trouver le plus grand élément d'un tableau peut être représentée comme suit :
1) prenez la carte du dessus (le premier élément du tableau), mémorisez le numéro sur la carte (écrivez-le à la craie sur le tableau) comme le plus grand de ceux regardés ; mettez la carte de côté ;
2) prenez la carte suivante ; comparer les nombres inscrits sur la carte et au tableau ; si le numéro sur la carte est plus grand, alors effacez le numéro inscrit au tableau et écrivez-y le même numéro que sur la carte ; si le nouveau nombre n'est pas supérieur, nous laisserons l'entrée existante sur le tableau ; mettez la carte de côté ;
3) répétez les étapes décrites à l'étape 2 pour toutes les cartes restantes de la pile.
En conséquence, la plus grande valeur de l’élément du tableau visualisé sera écrite au tableau.
En programmation, pour justifier l'exactitude des algorithmes cycliques, le concept d'invariant de cycle est utilisé.
Un invariant de boucle est une expression logique (condition) qui dépend des variables changeant dans le corps de la boucle ; c'est vrai immédiatement avant le début de l'exécution de la boucle et après chaque itération du corps de la boucle.
La condition « le nombre écrit sur le tableau est le plus grand de tous ceux visualisés jusqu’à présent » est un invariant de boucle pour l’algorithme considéré.
Étant donné que la valeur d'un élément du tableau est accessible par son index, lorsque vous recherchez le plus grand élément d'un tableau unidimensionnel, vous pouvez rechercher son index. Notons l'indice requis par imax. Ensuite, l'algorithme décrit ci-dessus dans le tableau que nous avons formé peut être écrit en Pascal comme suit :
S'il y a plusieurs éléments dans le tableau dont les valeurs sont égales à la valeur maximale, alors ce programme trouvera le premier d'entre eux (la première occurrence). Pensez à ce qui doit être modifié dans le programme pour qu'il contienne le dernier des éléments maximum. Comment le programme doit-il être transformé pour qu'il puisse être utilisé pour trouver l'élément minimum d'un tableau ?
Le résultat de la résolution d'un problème du deuxième type (trouver un élément de tableau dont la valeur est égale à une valeur donnée) peut être :
K est l'index de l'élément du tableau tel que a[k] = x, où x est un nombre donné ;
un message indiquant que l'élément souhaité n'a pas été trouvé dans le tableau.
Le programme de recherche d'une valeur égale à x dans le tableau que nous avons formé peut ressembler à ceci :
Ce programme parcourt tous les éléments d'un tableau un par un. S'il y a plusieurs éléments dans le tableau dont les valeurs sont égales à un nombre donné, alors le programme trouvera le dernier.
Dans de nombreux cas, vous devez rechercher le premier élément ayant une valeur correspondante et arrêter d'analyser davantage le tableau. À cette fin, vous pouvez utiliser le fragment de programme suivant :
Ici, l'exécution de l'algorithme sera interrompue dans l'un des deux cas suivants : 1) le premier élément égal à celui donné est trouvé dans le tableau ; 2) tous les éléments du tableau ont été scannés.
Notez le texte complet du programme et exécutez-le sur votre ordinateur.
Vous devez souvent déterminer le nombre d’éléments qui satisfont à certaines conditions. Dans ce cas, on introduit une variable dont la valeur est augmentée de un à chaque fois que l'élément recherché est trouvé.
Déterminez quels éléments sont comptés à l’aide du fragment de programme suivant.
S'il est nécessaire de déterminer la somme des valeurs des éléments qui satisfont à une certaine condition, alors une variable est introduite, à la valeur de laquelle est ajoutée la valeur de l'élément de tableau trouvé.
Déterminez quelle condition est remplie par les éléments du tableau dont les valeurs sont additionnées à l'aide du fragment de programme suivant.
Notez les textes intégraux des deux derniers programmes et exécutez-les sur l'ordinateur.
2.2.6. Trier un tableau
Par trier (ordonner) un tableau, nous entendons redistribuer les valeurs de ses éléments dans un ordre spécifique.
L'ordre dans lequel le premier élément d'un tableau a la plus petite valeur et la valeur de chaque élément suivant n'est pas inférieure à la valeur de l'élément précédent, est appelé non décroissant.
L'ordre dans lequel le premier élément d'un tableau a la plus grande valeur et la valeur de chaque élément suivant n'est pas supérieure à la valeur de l'élément précédent est appelé non croissant.
Le tri a pour but de faciliter la recherche ultérieure d'éléments : il est plus facile de retrouver l'élément souhaité dans un tableau ordonné.
Vous avez déjà rencontré le tri lorsque vous travaillez avec des bases de données. Nous allons maintenant considérer l'une des options possibles 1 mise en œuvre du mécanisme de cette opération - tri par sélection.
1 Vous vous familiariserez avec d'autres méthodes de tri dans les cours d'informatique de la 10e à la 11e année.
Le tri par sélection (par exemple non ascendant) s'effectue de la manière suivante :
1) l'élément maximum du tableau est sélectionné ;
2) les éléments maximum et premier sont échangés ; le premier élément est considéré comme trié ;
3) dans la partie non triée du tableau, l'élément maximum est à nouveau sélectionné ; il échange sa place avec le premier élément non trié du tableau ;
4) les actions décrites au paragraphe 3 sont répétées avec des éléments de tableau non triés jusqu'à ce qu'il reste un élément non trié (sa valeur sera minime).
Considérons le processus de tri par sélection en utilisant l'exemple du tableau a = (0, 1, 9, 2, 4, 3, b, 5).
Dans ce tableau de 8 éléments, nous avons effectué 7 fois l’opération de sélection de l’élément maximum. Dans un tableau de n éléments, une telle opération sera effectuée n à 1 fois. Expliquer pourquoi.
Voici un fragment d'un programme qui implémente l'algorithme décrit :
Ici, nous avons utilisé une boucle dans une autre. Cette conception est appelée boucle imbriquée.
Notez le texte intégral du programme et exécutez-le sur l'ordinateur pour le tableau a considéré dans l'exemple.
2.2.7. Autres structures de données
De nombreuses applications modernes (systèmes conversationnels, réseau, instrumentaux, systèmes d'exploitation, etc.) fonctionnent avec des données dont le volume ne peut être limité à l'avance à une certaine valeur. Supposons qu'un grand complexe logiciel soit en cours de développement, au cours duquel une grande quantité de données différentes, présentées sous forme de tableaux, sera stockée dans la RAM. La zone mémoire allouée à chaque tableau est contiguë ; Les limites de la zone sont strictement fixées lors de l'exécution du programme. La quantité de données étant inconnue à l'avance, les programmeurs devront spécifier les tailles maximales possibles des tableaux utilisés. Par conséquent, il se peut qu’il n’y ait pas suffisamment de mémoire disponible pour stocker toutes les données possibles. De plus, dans la pratique, il sera extrêmement rare de rencontrer des situations où chaque tableau sera complètement plein - dans beaucoup d'entre elles, une partie de la mémoire réservée restera libre. Les limites strictes ne permettent pas de redistribuer l'espace vide de certains tableaux en faveur d'autres. Le résultat est une utilisation inefficace de la RAM. La solution à cette situation consiste à remplacer certains tableaux par des listes lors de la conception d'un programme, qui occupent exactement autant de mémoire que ce qui est réellement nécessaire à l'heure actuelle et ne créent aucune réserve.
La liste est un ensemble d'éléments qui peuvent être dispersés par le système d'exploitation dans la RAM à volonté. La connexion des éléments de liste s'effectue du fait que chaque élément de liste contient, en plus des données, l'adresse de l'élément qui le suit dans la liste.
Une liste linéaire à chaînage unique est une séquence d'éléments liés linéairement pour laquelle les opérations d'ajout d'un élément à un emplacement arbitraire dans la liste et de suppression de tout élément sont autorisées.
Dans une liste linéaire, pour chaque élément sauf le premier, il existe un élément précédent ; pour chaque élément sauf le dernier, il y a un élément suivant. Ainsi, tous les éléments de la liste sont ordonnés (Fig. 2.3).
Riz. 2.3. Liste linéaire
Dans une liste linéaire, vous pouvez parcourir tous les éléments uniquement en vous déplaçant séquentiellement de l'élément actuel au suivant, en commençant par le premier. L'accès direct au i-ème élément n'est pas possible ; list est une structure d’accès séquentiel. Contrairement à une liste, un tableau est une structure à accès aléatoire.
LE PLUS IMPORTANT
Tableau est une collection d'un nombre fixe d'éléments du même type, auxquels est attribué un nom commun. Un élément de tableau individuel est accessible par son numéro (index).
Avant de l'utiliser dans un programme, le tableau doit être décrit. Vue générale de la description d'un tableau unidimensionnel :
Vous pouvez remplir un tableau soit en saisissant la valeur de chaque élément à partir du clavier, soit en attribuant certaines valeurs aux éléments du programme. Lors du remplissage du tableau et de son affichage à l'écran, une boucle avec un paramètre est utilisée.
Lors de la résolution de divers problèmes liés au traitement des tableaux, des algorithmes standard tels que : la sommation des éléments du tableau ; rechercher un élément avec des propriétés spécifiées ; tri des tableaux.
Questions et tâches
1. Lisez les supports de présentation du paragraphe contenu dans l'annexe électronique au manuel. Quelles diapositives pourriez-vous ajouter à votre présentation ?
2. Un tableau peut-il contenir simultanément des valeurs entières et réelles ?
3. Pourquoi une description du tableau est-elle nécessaire ?
4. Que pouvez-vous dire du tableau formé comme suit ?
UN) pour je:=l à 10 faire a[i]:=aléatoire(101)-50 ;
b) pour je:=l à 20 faire une[je]:=je;
V) pour je:=l à 5 faire a[i]:=2*i-l;
5. Exécutez sur votre ordinateur un programme pour résoudre le problème évoqué dans l'exemple du paragraphe 2.2.4. Considérons le nombre d'habitants de la maison comme un nombre aléatoire compris entre 50 et 200 personnes et le nombre de maisons n = 30.
6. Il y a deux paniers à côté de vous. Le premier est rempli de pommes de différentes tailles, le second est vide.
Étape 1. Vous prenez n'importe quelle pomme du premier panier et la placez sur la table devant vous.
Étape 2. Vous prenez la pomme suivante du premier panier et faites la comparaison :
Si la pomme dans vos mains est plus grosse que la pomme sur la table, alors vous mettez la pomme dans vos mains dans le deuxième panier ;
- si la pomme dans vos mains est plus petite que la pomme sur la table, vous posez la pomme sur la table, et transférez la pomme qui était sur la table dans le deuxième panier.
Vous répétez l'étape 2 jusqu'à ce que le premier panier soit vide.
Quelle pomme finira sur la table à la toute fin ? Essayez de formuler quel est l'invariant de boucle dans l'algorithme donné. Formulez l’énoncé du problème en utilisant la terminologie abordée dans ce paragraphe.
7. Écrivez un programme qui calcule la température moyenne de l'air pendant une semaine. Les données initiales sont saisies à partir du clavier.
8. Étant donné un tableau de dix nombres entiers. Écrivez un programme pour compter le nombre d'éléments de ce tableau qui ont la valeur maximale.
9. Dans une classe de 20 élèves, ils ont écrit une dictée en russe. Écrivez un programme qui compte le nombre de deux, trois, quatre et cinq reçus pour une dictée.
10. Le recrutement de l'équipe de basket-ball de l'école a été annoncé. La taille de chacun des n étudiants souhaitant intégrer cette équipe est connue. Créer un algorithme pour calculer le nombre de candidats qui ont une chance d'entrer dans l'équipe si la taille d'un joueur de l'équipe doit être d'au moins 170 cm. Écrire le programme en Pascal. Considérez la taille d'un candidat pour l'équipe comme un nombre aléatoire compris entre 150 et 200 cm et le nombre de candidats n = 50.
11. Les tableaux d'entiers a et b contiennent les longueurs des branches de dix triangles rectangles (a[i] est la longueur de la première branche, b[i] est la longueur de la deuxième branche du triangle i-ro). Écrivez un programme qui, sur la base des données disponibles, déterminera le triangle ayant la plus grande aire et affichera son numéro, les longueurs des jambes et l'aire. Prenons le cas où il existe plusieurs de ces triangles.
12. Entrez les informations sur dix pays européens dans les tableaux n (nom du pays), k (population), s (région du pays). Écrivez un programme qui imprime les noms des pays par ordre croissant de densité de population.
13. Recherchez des informations sur des cas particuliers de liste tels qu'une pile et une file d'attente. Préparez un court message.
Sections: L'informatique
Objectifs:
- Initier les élèves à la possibilité de remplir et de traiter un tableau.
- Créez une interface graphique pour un projet afin de remplir un tableau et de calculer la somme des éléments d'un tableau donné.
- Développer un intérêt cognitif pour le sujet
- Favoriser une attitude responsable envers l’apprentissage
PENDANT LES COURS
1. Mise à jour de la leçon
Organisation du temps
Enquête frontale sur le thème précédent « Le concept de tableau. Tableau unidimensionnel"
2. Formation de compétences et d'aptitudes
Explication du nouveau matériel
Déclaration de tableau
La déclaration d'un tableau est similaire à la déclaration de variables : il vous suffit de spécifier la plage des modifications d'index. Par exemple, déclarer un tableau d'entiers unidimensionnels contenant 10 éléments se fait comme suit :
A : tableau d’entiers ;
Tâches de base lorsque vous travaillez avec des tableaux
1. Formation (remplissage) du tableau
1.1. selon les formules For i:=1 à 10 do a[i]:= i*i;
1.2. générer aléatoirement Pour i:=1 à 10, faites a[i]:= random(20) :
La fonction intégrée RANDOM(MAX), renvoie un entier aléatoire uniformément distribué dans la plage de 0 à MAX – 1 (MAX est le paramètre d'accès)
1.3. saisir au clavier Pour i:=1 à 10 do read(a[i]);
2. Triez le tableau (croissant, décroissant) ;
3. Recherchez des éléments dans un tableau ;
4. Sélection d'éléments d'un tableau par condition ;
Remplir le tableau de manière aléatoire.
Pour commencer à travailler avec un tableau, vous devez le remplir, c'est-à-dire attribuer des valeurs spécifiques aux éléments du tableau. Pour générer une séquence de nombres aléatoires, nous utilisons la fonction Random(100). Lorsque vous exécutez le programme, cette fonction génère une séquence pseudo-aléatoire d'entiers compris entre 0 et 100.
Pour générer des séquences de nombres aléatoires différents les uns des autres, il est recommandé d'utiliser l'opérateur Randomize
Actions avec des tableaux unidimensionnels
1. Calcul de la somme des éléments
Pour I := 1 à 10 Faire s :=s+ a[i] ; (accumulation habituelle du montant en s)
2. Calcul du produit
Pour I:= 1 à 10 Do р:=р* a[i]; (accumulation habituelle de produit dans p)
3. Rechercher un élément avec une valeur donnée
3. Remarque Développement des compétences et des capacités dans la pratique
Projet « Somme des éléments dans un tableau ». Développons un projet « Somme des éléments dans un tableau », qui remplira le tableau de nombres aléatoires et calculera la somme de ces nombres
Commençons par créer une procédure pour remplir le tableau
1.Lancez le système de programmation Delphi.
2. Le travail sur le projet commence par la création d'une interface graphique, pour cela dans la fenêtre Générateur de formulaires Les éléments de contrôle sont placés sur le formulaire. Pour créer une interface graphique pour le projet, nous placerons sur le formulaire deux champs de texte pour afficher des données numériques (un pour remplir un tableau, l'autre pour afficher une somme) et deux boutons pour mettre en œuvre des procédures événementielles : remplir un tableau et une somme
3. Avec Barres d'outils placez un champ de texte Editl et un bouton de commande Buttonl sur le Forml
L'étape suivante consiste à créer le code de procédure événementielle. Un double-clic sur le bouton pour lequel vous devez créer le code du programme fait apparaître une fenêtre Code du programme avec un modèle de procédure événementielle vide.
4. Double-cliquez sur le bouton Buttonl, une procédure événementielle modèle TForml.ButtonlClick apparaîtra : Déclarez un tableau UN et description des variables EST dans la section de description de la variable var
A : tableau d’entiers ;
procédure TForm1.Button1Click(Expéditeur : TObject);
Pour I : = 1 à 10 Faire
A[I] := Aléatoire(10);
Edit1.Text:= Edit1.Text +" " + IntToStr(a[i]);
5. Enregistrer le projet sous
6. Compilation du projet (Projet - Compiler)
Créons maintenant une procédure pour calculer la somme des éléments du tableau rempli
En utilisant Barres d'outils Plaçons un bouton Button2 et un champ de texte Edit2 sur le Forml. Un double-clic sur le bouton Button2, pour lequel vous devez créer un code de programme, ouvre une fenêtre Code du programme avec un modèle de procédure événementielle vide.
procédure TForm1.Button2Click(Expéditeur : TObject);
Pour I : = 1 à 10 Faire
Edit2.Text := Edit2.Text +" " + IntToStr(s)
Sauvegarder le projet de l'ensemble du projet (Save Project).
Compilons le projet (en appuyant sur la touche F9).
Cliquez sur les boutons Remplir le tableau et Somme.
Les résultats des montants pour les différentes options de remplissage seront affichés dans le champ de texte
4. Résumé
5. Devoirs : Créer un projet « Produit d'éléments d'un tableau », qui implique de remplir un tableau avec des nombres aléatoires et la possibilité d'afficher le produit de tous les éléments du tableau dans un champ de texte.
Jusqu'à présent, nous avons travaillé avec des types de données simples - logique (booléen), entier (entier, mot, octet, entier long), réel (réel), caractère (char). N'importe quel algorithme peut être programmé en utilisant ces quatre types de base. Mais pour traiter des informations sur le monde réel diversifié, des données présentant une structure plus complexe sont nécessaires. De telles constructions complexes basées sur les types scalaires les plus simples sont appelées structures. Une structure est un type de données composite composé de données scalaires de base. Si une structure ne change pas de structure tout au long de l'exécution du programme dans lequel elle est décrite, alors une telle structure est dite statique.
Tableau – une collection homogène d’éléments
La structure la plus courante, implémentée dans presque tous les langages de programmation, est un tableau.
Les tableaux sont constitués d’un nombre limité de composants et tous les composants du tableau ont le même type, appelé type de base. La structure du tableau est toujours uniforme. Un tableau peut être constitué d'éléments de type entier, réel ou char, ou d'autres éléments du même type. Cependant, il ne faut pas en conclure que les composants d’un tableau ne peuvent avoir qu’un type scalaire.
Une autre caractéristique d'un tableau est que n'importe lequel de ses composants est accessible de n'importe quelle manière. Qu'est-ce que ça veut dire? Le programme peut obtenir immédiatement l'élément dont il a besoin grâce à son numéro de série (index).
Indice du tableau
Le numéro d'élément du tableau est appelé indice. Un index est une valeur de type ordinal, définie comme type d'index de ce tableau. Très souvent, il s'agit d'un type entier (entier, mot ou octet), mais il peut aussi être logique et caractère.
Description d'un tableau en Pascal. En Pascal, le type d'un tableau est spécifié à l'aide d'un mot spécial tableau(anglais – array), et sa déclaration dans le programme ressemble à ceci :
Taper< имя _ типа >= tableau [I] de T ;
où I est le type d'index du tableau, T est le type de ses éléments.
Vous pouvez immédiatement décrire les variables de type tableau, c'est-à-dire dans la section description des variables :
Var a,b : tableau [ I ] de T ;
Généralement, un type d'index est caractérisé par une certaine plage de valeurs de tout type ordinal : I 1 .. I n . Par exemple, les indices peuvent varier dans la plage 1..20 ou " a ".." n ".
Dans ce cas, la longueur du tableau Pascal est caractérisée par l'expression :
ord (je n)- ord (je 1)+1.
Voici par exemple une déclaration de deux types : vecteur sous forme de tableau Pascal de 10 entiers et chaîne sous forme de tableau de 256 caractères :
Taper
Vecteur=tableau d'entiers ;
Stroka=tableau de caractères ;
À l'aide d'un index de tableau, vous pouvez accéder aux éléments individuels de n'importe quel tableau comme s'il s'agissait d'une variable régulière : vous pouvez obtenir la valeur de cet élément, lui attribuer une valeur séparément et l'utiliser dans des expressions.
Décrivons les variables de type vecteur et chaîne :
Calcul de l'indice de tableau Pascal
L'index d'un tableau en Pascal n'a pas besoin d'être spécifié explicitement. Vous pouvez utiliser une variable ou une expression correspondant au type d'index comme index de tableau. En d’autres termes, des indices peuvent être calculés.
Ce mécanisme est un outil de programmation très puissant. Mais cela crée une erreur courante : le résultat du calcul peut être en dehors de la plage des valeurs d'index valides, c'est-à-dire qu'une tentative sera faite pour accéder à un élément qui n'existe pas. Cette erreur courante est appelée « tableau hors limites ».
Exemple de programme avec une erreur de tableau PascalProgramme primer_error ;
Taper
vecteur = tableau de mots ;
var
n : entier ;
a:vecteur;
commencer
n :=45 ;
une :=25 ;
fin.
Bien que ce programme soit entièrement conforme à la syntaxe du langage et que le traducteur le « transmette », une erreur hors limites du tableau Pascal se produira lors de l'exécution. Lorsque n = 45, l'expression n * 2 = 90, l'ordinateur tentera d'accéder à l'élément du tableau a, mais un tel élément n'existe pas, puisqu'un tableau de dimension 80 est décrit.
Supposons qu'un bon programme émette un message d'avertissement s'il tente d'accéder à des éléments de tableau inexistants. Il ne serait pas superflu de vérifier les éventuels écarts par rapport aux limites droite et gauche du tableau, car il est possible qu'à la suite du calcul de la valeur de l'expression, le résultat soit un nombre situé à gauche de la limite du tableau de Pascal.
De tout cela, nous pouvons conclure : le programmeur doit être très prudent lorsqu'il travaille avec des indices de tableau.
Opérations de base avec les tableaux Pascal
Comme vous le savez, définir un type de données signifie limiter la plage de valeurs autorisées, la représentation interne dans un ordinateur, ainsi qu'un ensemble d'opérations autorisées sur des données de ce type. Nous avons défini le type de données comme un tableau Pascal. Quelles opérations sont définies sur ce type de données ? La seule action qui peut être effectuée sur des tableaux entiers, et uniquement si les tableaux sont du même type, est l'affectation. Si un programme décrit deux variables du même type, par exemple,
Var
a , b : tableau de real ;
alors vous pouvez utiliser une variable un attribuer une valeur à une variable b(une := b). Dans ce cas, chaque élément du tableau un la valeur correspondante du tableau sera attribuée b. Toutes les autres actions sur les tableaux Pascal sont effectuées élément par élément (C'est important!) .
Entrée de tableau Pascal
Afin de saisir les valeurs des éléments du tableau, vous devez modifier séquentiellement la valeur de l'index, du premier au dernier, et saisir l'élément correspondant. Pour mettre en œuvre ces actions, il est pratique d'utiliser une boucle avec un nombre de répétitions donné, c'est-à-dire une simple boucle arithmétique, où le paramètre de boucle sera une variable - l'index du tableau Pascal. Les valeurs des éléments peuvent être saisies à partir du clavier ou spécifiées à l'aide de l'opérateur d'affectation.
Un exemple de fragment d'un programme d'entrée de tableau PascalVar
A : tableau d'entiers ;
Commencer
Pour i:=1 à 10 faire
Lire(a[i]); (le i-ème élément est saisi depuis le clavier)
Considérons maintenant le cas où le tableau Pascal est rempli automatiquement de nombres aléatoires ; pour cela nous utiliserons la fonction aléatoire(N).
Un exemple de fragment d'un programme pour remplir un tableau Pascal avec des nombres aléatoiresVar
I : octet ; (la variable I est entrée comme index de tableau)
Commencer
Pour i:=1 à 10 faire
A[i]:= aléatoire(10); (Le ième élément du tableau se voit attribuer un entier "aléatoire" compris entre 0 et 10)
Sortie du tableau Pascal
La sortie d'un tableau en Pascal s'effectue également élément par élément, dans une boucle, où le paramètre est l'index du tableau, prenant séquentiellement toutes les valeurs de la première à la dernière.
Un exemple de fragment d'un programme de sortie de tableau PascalVar
A : tableau d’entiers ;
I : octet ; (la variable I est entrée comme index de tableau)
Commencer
Pour i:=1 à 10 faire
Écrivez(a[i]," "); (le tableau est affiché sur une ligne, un espace est imprimé après chaque élément)
La sortie peut également se faire dans une colonne indiquant l'index correspondant. Mais dans ce cas, vous devez tenir compte du fait que si le tableau est grand, tous les éléments risquent de ne pas tenir sur l'écran et un défilement se produira, c'est-à-dire Lorsque toutes les lignes de l'écran sont remplies, l'élément suivant sera imprimé et celui du haut sera décalé hors de l'écran.
Un exemple de programme pour afficher un tableau Pascal dans une colonneVar
A : tableau d’entiers ;
I : octet ; (la variable I est entrée comme index de tableau)
Commencer
Pour i:=1 à 10 faire
Writeln("a[", i,"]=", a[i]); (affichage des éléments du tableau dans une colonne)
Sur l'écran, nous verrons, par exemple, les valeurs suivantes :
une =2
une =4
a =1, etc.
Un exemple de résolution d'un problème à l'aide de tableaux Pascal
Tâche: deux vecteurs à n dimensions sont donnés. Trouvez la somme de ces vecteurs.
La solution du problème :
- Les données d'entrée dans ce problème seront deux tableaux unidimensionnels. La taille de ces tableaux peut être arbitraire, mais certaine. Ceux. nous pouvons décrire un tableau délibérément grand et, dans le programme, déterminer combien d'éléments seront réellement utilisés. Les éléments de ces tableaux peuvent être des entiers. La description ressemblera alors à ceci :
var a, b : tableau d'entiers ;
- La sortie sera les éléments du tableau résultant, appelons-le c . Le type du tableau résultant doit également être entier.
- En plus des trois tableaux, nous aurons besoin d'une variable - un paramètre de boucle et un index de tableau, appelons-le i, ainsi que d'une variable n pour déterminer le nombre d'éléments dans chaque tableau.
Progrès dans la résolution du problème :
- Déterminons le nombre d'éléments (dimension) des tableaux, saisissons la valeur n ;
- introduisons un tableau a ;
- introduisons le tableau b ;
- dans une boucle, en parcourant les valeurs de l'indice i de 1 à n, on calcule séquentiellement les valeurs des éléments du tableau c à l'aide de la formule :
c [ je ]= une [ je ]+ b [ je ];
- Affichons le tableau résultant à l'écran.
Texte du programme :
Exemple de programme de somme vectoriellerésumé du programme ;
Var
a, b, c : tableau d'entiers ;
I, n : octet ;
Commencer
Write("entrez la taille du tableau :");
Lecture(n);
Pour i:=1 à n faire
Lire(a[i]); (entrée du tableau a)
Pour i:=1 à n faire
Readln(b[je]); (entrée du tableau b)
Pour i:=1 à n faire
C[i]:=a[i]+b[i]; (calcul de la somme des tableaux)
Pour i:=1 à n faire
écrire(c[i]," "); (sortie du tableau avec)
fin.
La leçon explique comment travailler avec des tableaux unidimensionnels en Pascal, comment utiliser un générateur de nombres aléatoires - la fonction aléatoire chez Pascal. Un exemple de la façon de dériver les nombres de Fibonacci est considéré.
Les supports du site sont destinés à la maîtrise pratique du langage de programmation Pascal. De brèves informations théoriques ne prétendent pas constituer une couverture complète du matériel sur le sujet ; Les informations nécessaires peuvent être trouvées en grande quantité sur Internet. Nos tâches consistent notamment à offrir la possibilité d'acquérir des compétences pratiques en programmation en Pascal. Les exemples visuels et les tâches résolus sont présentés par ordre de complexité croissante, ce qui facilitera l'étude du matériel à partir de zéro.
Déclaration de tableau
Il existe deux types de tableaux en Pascal : unidimensionnels et bidimensionnels.
Définir un tableau unidimensionnel en Pascal ressemble à ceci : un tableau unidimensionnel est un certain nombre d'éléments appartenant au même type de données, qui portent le même nom, et chaque élément a son propre index - un numéro de série.
La description d'un tableau en Pascal (déclaration) et l'accès à ses éléments est la suivante :
Déclaration de tableau
var longueur : tableau [ 1 .. 3 ] d'entier ; début de longueur[ 1 ] : = 500 ; dlina[ 2 ] : = 400 ; dlina[ 3 ] : = 150 ; ... var length : tableau d’entiers ; longueur de début :=500 ; longueur :=400 ; longueur :=150 ; ...
Annoncer la taille peut être utilisée via une constante :
Initialisation d'un tableau
De plus, le tableau lui-même peut être constante, c'est à dire. tous ses éléments dans le programme sont prédéterminés. La description d'un tel tableau ressemble à ceci ::
| const a : tableau [ 1 .. 4 ] d'entier = (1 , 3 , 2 , 5 ) ; |
const a: tableau d'entiers = (1, 3, 2, 5) ;
Remplissage avec des nombres consécutifs :
Résultat : A = 8, A = 9, A = 10, ..., A[N] = A + 1
La saisie au clavier:
Exemple: Regardons comment un tableau est saisi en Pascal :
writeln("entrez le nombre d'éléments : "); readln(n); (si la quantité n'est pas connue à l'avance, on la demande) for i:= 1 to n do start write("a[", i, "]="); lire(une[i]); ...fin; ...
✍ Exemple de résultat :
Entrez le nombre d'éléments : 3 a=5 a=7 a=4
Impression des éléments du tableau
Exemple: Voyons comment afficher un tableau en Pascal :
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | var a : tableau [ 1 .. 5 ] d'entier ; (tableau de cinq éléments) je:entier ; commencer a[ 1 ] : = 2 ; une[ 2 ] : = 4 ; une[ 3 ] : = 8 ; une[ 4 ] : = 6 ; une[ 5 ] : = 3 ; writeln("Tableau A:"); pour i : = 1 à 5, écrivez (a[ i] : 2 ) ; (sortie des éléments du tableau) fin. |
var a : tableau d’entiers ; (tableau de cinq éléments) i : entier ; commencer a:=2 ; une :=4 ; une :=8 ; une :=6 ; une :=3 ; writeln("Tableau A:"); pour i:= 1 à 5, écrivez(a[i]:2); (éléments du tableau de sortie) fin.
✍ Exemple de résultat :
Tableau A : 2 4 8 6 3
Pour travailler avec des tableaux, il est le plus souvent utilisé en Pascal avec un paramètre, car vous savez généralement combien d'éléments se trouvent dans le tableau et vous pouvez utiliser un compteur de boucles comme indices des éléments.
Tableau 0 tâche. Vous devez spécifier un tableau réel de dimensions 6 (c'est-à-dire six éléments); remplissez le tableau avec les valeurs d'entrée et affichez les éléments à l'écran. Utilisez deux boucles : la première pour la saisie des éléments, la seconde pour la sortie.
Dans cet exemple de travail avec un tableau unidimensionnel, il y a un inconvénient évident : attribuer des valeurs aux éléments.
Le traitement des tableaux en Pascal, ainsi que le remplissage d'un tableau, s'effectuent généralement à l'aide d'une boucle for.
Fonction aléatoire en Pascal
Afin de ne pas demander constamment les valeurs des éléments du tableau, un générateur de nombres aléatoires en Pascal est utilisé, qui est implémenté par la fonction Random. En fait, des nombres pseudo-aléatoires sont générés, mais là n’est pas la question.
Pour générer des nombres de 0 à n (sans compter la valeur de n lui-même, les entiers dans l'intervalle des nombres entiers ; i : entier ; commencer à randomiser ; pour i : = 1 à 10, commencez f[i] : = random (10 ); ( intervalle ) write(f[i]," "); end; end.
✍ Exemple de résultat :
9 8 9 2 0 3 6 9 5 0
Pour les nombres réels dans l'intervalle et afficher les éléments à l'écran : définir trois positions d'affichage de chaque élément.
Nombres de Fibonacci en Pascal
L'exemple le plus courant de travail avec un tableau est la sortie d'une série de nombres de Fibonacci en Pascal. Considérons-le.
Exemple: Série de nombres de Fibonacci : 1 1 2 3 5 8 13…
f[ 0 ] : = 1 ; f[ 1 ] : = 1 ; f[ 2 ] : = 2 ; ... f:=1; f:=1; f:=2; ...
f[ 2 ] : = f[ 0 ] + f[ 1 ] ; f[ 3 ] : = f[ 1 ] + f[ 2 ] ;
f[ je] : = f[ je- 2 ] + f[ je- 1 ] ; f[i]:=f+f;
Nous avons reçu la formule des éléments de la série.
Exemple: Calculez et imprimez les 20 premiers nombres de Fibonacci.
| 1 2 3 4 5 6 7 8 9 10 11 | var i : entier ; f : tableau [0 .. 19] d'entier ; commencer f[ 0 ] : = 1 ; f[ 1 ] : = 1 ; pour i : = 2 à 19, commencez f[ i] : = f[ i- 1 ] + f[ i- 2 ] ; writeln (f[ i] ) fin ; fin. |
var je:entier; f: tableau d'entiers ; commencer f:=1; f:=1; pour i:=2 à 19, commencez f[i]:=f+f; writeln(f[i]) fin; fin.
Dans cet exemple, le principe du travail avec des séries de nombres devient clair. Habituellement, pour dériver une série de nombres, on trouve une formule pour déterminer chaque élément de cette série. Ainsi, dans le cas des nombres de Fibonacci, cette formule-règle ressemble à f[i]:=f+f. Par conséquent, il doit être utilisé dans une boucle for lors de la formation des éléments du tableau.
Tâche du tableau 2.Étant donné une ligne de 10 arbitraire nombres : a, a, ... , a (utilisez la fonction random()). Calculer et imprimer la somme des triplets de nombres adjacents : a+a+a , a+a+a , a+a+a , …… , a+a+a
Pseudocode : 
Trouver l'élément maximum par son index :
Tâche Array_min : Trouvez l'élément minimum du tableau. Imprime l'élément et son index.
Tâche du tableau 4.Étant donné un tableau de 10 éléments entiers. Trouvez le nombre de négatifs et affichez le nombre à l’écran.
Tâche du tableau 5. Trouvez le minimum et le maximum de n nombres saisis (tableau). Déterminez la distance entre ces éléments. 3 2 6 1 3 4 7 2 >>> min=1, max=7, distance=3
Tâche du tableau 6.Étant donné un tableau entier de taille N. Imprimer tous les nombres pairs contenus dans ce tableau par ordre décroissant de leurs indices, ainsi que leur numéro K. N=4 mas : 8 9 2 5 >>> 2 8 quantité= 2
Tâche du tableau 7. Saisissez un tableau de 5 éléments à partir du clavier, recherchez les deux éléments maximum et leurs numéros.
Exemple:
Tableau initial : 4 -5 10 -10 5 maximum A=10, A=5
Rechercher dans un tableau
Regardons un exemple complexe de travail avec des tableaux unidimensionnels :
Exemple:Étant donné un tableau de 10 nombres. Déterminez si le nombre saisi par l'utilisateur est dans le tableau. S'il y en a, sortie "trouvé", sinon - "pas trouvé".
La difficulté de la tâche est d'imprimer les mots "trouvé" ou "pas trouvé" nécessaire une fois.
Pour résoudre ce problème, vous aurez besoin d’une instruction break pour quitter la boucle.
Option de solution 1. Boucle For :
Afficher la solution
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | var f : tableau [ 1 .. 10 ] d'entier ; drapeau:booléen ; je, c : entier ; commencer la randomisation ; pour i: = 1 à 10, commencez f[ i] : = random(10 ) ; écrire (f[ i] , " " ) ; fin ; drapeau : = faux ; écrire ( "entrer l'échantillon") ; readln(c); pour i: = 1 à 10, faites si f[ i] = c alors commencez writeln ("found" ) ; drapeau : = vrai ; casser ; fin ; si flag= false alors writeln ("not found" ) ; fin. |
var f : tableau d'entiers ; drapeau:booléen; je,c:entier; commencer la randomisation ; pour i:=1 à 10, commencez f[i]:=random(10); écrire(f[i]," "); fin; drapeau :=faux ; writeln("entrez l'échantillon"); readln(c); pour i:=1 à 10, faites si f[i]=c alors commencez writeln("found"); drapeau :=vrai ; casser; fin; si flag=false alors writeln("not found"); fin.
Considérons solution efficace :
Tâche: trouver un élément égal à X dans le tableau ou établir qu'il n'existe pas.
Algorithme:
- commencer par le 1er élément (i:=1) ;
- si l'élément suivant (A[i]) est égal à X , alors terminez la recherche sinon passez à l'élément suivant.
solution en Pascal Option 2. Boucle While :
Nous vous invitons à regarder une analyse vidéo détaillée de la recherche d'un élément dans un tableau (un algorithme efficace) :
Tâche du tableau 8. Remplissez un tableau de 10 éléments avec des nombres aléatoires dans l'intervalle et imprimez les nombres de tous les éléments égaux à X .
Exemple:
Tableau initial : 4 0 1 2 0 1 3 4 1 0 Que recherchons-nous ? 0 Un, un, un
Changement cyclique
Exemple: décalez les éléments du tableau vers la gauche d’une position, le premier élément remplace le dernier. 
Solution:
Algorithme:
UNE :=UNE ; A:=A;… A:=A[N];
Programme:
Tâche du tableau 9. Remplissez un tableau de 10 éléments avec des nombres aléatoires dans l'intervalle [-10..10] et effectuez un décalage cyclique vers la gauche sans premier élément.
Exemple: Tableau initial : 4 -5 3 10 -4 -6 8 -10 1 0 Résultat : 4 3 10 -4 -6 8 -10 1 0 -5
Réorganiser les éléments dans un tableau
Regardons comment un tableau est réorganisé ou inversé.
Exemple: réorganiser les éléments du tableau dans l'ordre inverse 
Solution:
Algorithme:
Pseudocode :
Programme:
Tâche du tableau 10. Remplissez un tableau de 10 éléments avec des nombres aléatoires dans l'intervalle [-10..10] et inversez tous les éléments sauf le dernier.
Exemple: Tableau source : -5 3 10 -4 -6 8 -10 1 0 4 Résultat : 0 1 -10 8 -6 -4 10 3 -5 4
Sélection d'éléments et enregistrement dans un autre tableau
Exemple: rechercher des éléments dans un tableau qui satisfont à certaines conditions (par exemple négatives) et les copier dans un autre tableau 
Solution:
Solution: comptez le nombre d'éléments trouvés à l'aide du compteur, installez l'élément suivant à la place B. À l'aide d'une variable compter doit être attribué 1 .
Sortie du tableau B :
writeln("Éléments sélectionnés"); pour i:=1 pour compter-1, écrivez(B[i], " ")
Tâche de tableau 11. Remplissez un tableau avec des nombres aléatoires dans l'intervalle et écrivez dans un autre tableau tous les nombres se terminant par 0.
Exemple: Tableau source : 40 57 30 71 84 Se termine par 0 : 40 30
Tri des éléments du tableau
Tri des bulles
- Dans ce type de tri, le tableau est représenté comme de l'eau, les petits éléments sont des bulles dans l'eau qui flottent vers le haut (les plus légères).
- Lors de la première itération de la boucle, les éléments du tableau sont comparés deux à deux entre eux : l'avant-dernier avec le dernier, l'avant-dernier avec l'avant-dernier, etc. Si l'élément précédent s'avère plus grand que le suivant, alors ils sont échangés.
- Lors de la deuxième itération de la boucle, il n’est pas nécessaire de comparer le dernier élément avec l’avant-dernier. Le dernier élément est déjà en place, c'est le plus gros. Cela signifie que le nombre de comparaisons sera d'une de moins. Il en va de même pour chaque itération suivante.
Exécution en Pascal :
| 1 2 3 4 5 6 7 8 | pour i: = 1 à N- 1 commence pour j: = N- 1 jusqu'à ce que je fasse si A[ j] > A[ j+ 1 ] alors commence par : = A[ j] ; UNE[ j] : = UNE[ j+ 1 ] ; UNE[ j+ 1 ] : = с; fin ; fin ; |
pour i:=1 à N-1, commencez pour j:=N-1 jusqu'à ce que je fasse si A[j] > A puis commencez à partir de := A[j] ; UNE[j] := UNE; UNE := c; fin; fin;
Tâche du tableau 12. Remplissez un tableau de 10 éléments avec des nombres aléatoires dans l'intervalle et triez la première moitié du tableau par ordre croissant et la seconde par ordre décroissant (en utilisant la méthode « Bulle »). Exemple: Tableau source : 14 25 13 30 76 58 32 11 41 97 Résultat : 13 14 25 30 76 97 58 41 32 11
Tri par sélection
- l'élément minimum est recherché dans le tableau et placé en première place (places commutées avec A) ;
- Parmi les éléments restants, on recherche également celui du minimum, qui est placé en deuxième position (places commutées avec A), etc.
pour i:= 1 à N-1, commencez min:= i ; pour j:= i+1 à N faire si A[j]< A then min:=j; if min <>je commence alors c:=A[i]; UNE[je]:=UNE; UNE:=c; fin; fin;
Tâche du tableau 13 : Remplissez un tableau de 10 éléments avec des nombres aléatoires dans l'intervalle et triez-le par ordre croissant de la somme des chiffres Exemple: Tableau source : 14 25 13 12 76 58 21 87 10 98 Résultat : 10 21 12 13 14 25 76 58 87 98
Tri rapide ou tri rapide
Algorithme:
Exécution en Pascal :
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | procédure QSort ( premier, dernier : entier ) ; var L, R, c, X : entier ; commencer si d'abord< last then begin X: = A[ (first + last) div 2 ] ; L: = first; R: = last; while L <= R do begin while A[ L] < X do L: = L + 1 ; while A[ R] >X faire R : = R - 1 ; si L<= R then begin c: = A[ L] ; A[ L] : = A[ R] ; A[ R] : = c; L: = L + 1 ; R: = R - 1 ; end ; end ; QSort(first, R) ; QSort(L, last) ; end ; end . |
procédure QSort(premier, dernier : entier); var L, R, c, X : entier ; commencer si d'abord< last then begin X:= A[(first + last) div 2]; L:= first; R:= last; while L <= R do begin while A[L] < X do L:= L + 1; while A[R] >X faire R := R - 1 ; si L<= R then begin c:= A[L]; A[L]:= A[R]; A[R]:= c; L:= L + 1; R:= R - 1; end; end; QSort(first, R); QSort(L, last); end; end.
Tâche du tableau 14 :
Remplissez un tableau de 10 éléments avec des nombres aléatoires compris dans la plage [-50..50] et triez-le à l'aide de l'algorithme de tri rapide.
Tableaux unidimensionnels. Former un tableau et afficher ses éléments
Définition du concept
Un tableau est une collection de données du même type avec un nom commun pour tous les éléments.
Les éléments du tableau sont numérotés et chacun d'eux est accessible par numéro. Les nombres d'éléments du tableau sont autrement appelés indices, et les éléments du tableau eux-mêmes sont appelés variables indexées.
|
un[n] |
||||||
|
- 0. 5 |
-5.2 |
… |
0.6 |
Vecteur (linéaire ou tableau unidimensionnel) est un exemple de tableau dans lequel les éléments sont numérotés avec un seul index.
- Comme nombres (index)élément de tableau, en général, l'expression est utilisée type ordinal(le plus souvent il s'agit d'une constante entière ou d'une variable de type entier : entier, mot, octet ou raccourci)
- Lors de l'accès à un élément du tableau, l'index est indiqué entre crochets. Par exemple, a, masse.
- Les éléments du tableau sont traités lorsque les indices des éléments changent. Par exemple, lors de l'utilisation d'une expression, les variables suivantes sont utiles pour parcourir les éléments d'un tableau :
- a[i] - tous les éléments ;
- a - les éléments situés à des endroits pairs ;
- a - éléments dans des endroits impairs
Description du tableau
- Définir une variable sous forme de tableau sans déclarer au préalable le type de tableau
| varabc: tableau de entier; var s : tableau d'entier; k : tableau d'entier; |
Note
- La description du tableau est requise par le compilateur pour allouer de la mémoire à ses éléments.
- Une variable est définie comme un tableau à l'aide d'un mot de fonction tableau(tableau). La plage est indiquée entre crochets, c'est-à-dire les limites inférieure et supérieure de la valeur de l'index du tableau. La valeur limite supérieure ne peut pas être inférieure à la limite inférieure.
- Ici, les variables s et k sont considérées comme étant de types différents. Pour assurer la compatibilité, il est nécessaire d'utiliser des déclarations de variables via une déclaration de type préalable.
- Si les types de tableaux sont identiques, alors dans un programme, un tableau peut être attribué à un autre. Dans ce cas, les valeurs de toutes les variables d'un tableau seront attribuées aux éléments correspondants du deuxième tableau.
- Aucune opération relationnelle n'est définie sur les tableaux. Vous ne pouvez comparer que deux tableaux élément par élément.
- Description préliminaire du type de tableau
| const n = 5 ; taper mas = tableau d'entier; var a : mas ; |
Note
- Les éléments du tableau seront accessibles comme ceci : a, a, a, a, a (c'est-à-dire que le tableau contient cinq éléments).
- Utiliser des constantes(dans cet exemple n) lors de la description d'un tableau est préférable, car si la taille du tableau change, il ne sera pas nécessaire d'apporter des corrections dans tout le texte du programme.
- Définition d'un tableau sur une constante typée
| const X: tableau d'entier = (1, 2, 3, 4, 5, 6); |
Note
- Dans cet exemple, non seulement la mémoire est allouée au tableau, mais les cellules sont également remplies de données.
- Les éléments du tableau peuvent être changement pendant le programme (comme toutes les constantes saisies).
Remplir un tableau avec des données
§ Pour remplir un tableau données (et sa sortie), une boucle avec un paramètre est le plus souvent utilisée pour
§ Pour remplir un tableau avec des nombres aléatoires, utilisez la fonction aléatoire et procédure randomiser(initialisation du générateur de nombres aléatoires). Le format d'enregistrement est : aléatoire (B - A) + A, où A et B sont extraits de l'intervalle :4);
Exemple de programme pour l'entrée et la sortie d'un tableau
Formulation du problème. Obtenez la somme des éléments d'un tableau composé de 10 éléments entiers. Les éléments du tableau sont saisis à partir du clavier.
| programme tableau2; var somme: entier; je: octet; un: tableau de mot; commencer somme := 0 ; pourje:= 0 à 9 faire commencer écrire("un[",je," ] = "); lire(une[je]); somme := somme + a[i] fin; écrire("somme =", somme) fin. |
Un exemple de programme pour travailler avec des éléments de tableau
Formulation du problème. Obtenez la moyenne arithmétique des éléments du tableau. Les éléments du tableau sont remplis de nombres aléatoires.
| programme tableau3; const n = 100 ; var sar : réel; somme: entier; je: octet; un: tableau d'entier; commencer somme := 0 ; randomiser; pourje:= 0 à n faire commencer un[je] := aléatoire(100); somme := somme + a[i] fin; sar:= somme/n; écrire("sar =", sar) fin. |
