Zweidimensionale Arrays. Bildung von Matrizen und Ausgabe ihrer Elemente

Ein zweidimensionales Array wird in Pascal als eindimensionales Array behandelt, dessen Elementtyp ebenfalls ein Array (ein Array von Arrays) ist. Die Position von Elementen in zweidimensionalen Pascal-Arrays wird durch zwei Indizes beschrieben. Sie können als rechteckige Tabelle oder Matrix dargestellt werden.

Betrachten Sie ein zweidimensionales Pascal-Array mit den Dimensionen 3 * 3, dh es hat drei Zeilen und jede Zeile hat drei Elemente:

Jedes Element hat seine eigene Nummer, wie in eindimensionalen Arrays, aber jetzt besteht die Nummer bereits aus zwei Zahlen - der Nummer der Zeile, in der sich das Element befindet, und der Nummer der Spalte. Somit wird die Elementnummer durch den Schnittpunkt von Zeile und Spalte bestimmt. Eine 21 ist beispielsweise das Element in der zweiten Zeile und ersten Spalte.

Beschreibung eines zweidimensionalen Pascal-Arrays.

Es gibt mehrere Möglichkeiten, ein zweidimensionales Pascal-Array zu deklarieren.

Wir wissen bereits, wie man eindimensionale Arrays beschreibt, deren Elemente jeden Typs sein können und daher die Elemente selbst Arrays sein können. Betrachten Sie die folgende Beschreibung von Typen und Variablen:

Typ
Vektor = Array von<тип_элементов>;
Matrix = Vektor-Array;
Var m: Matrix;

Wir haben ein zweidimensionales Pascal-Array m deklariert, das aus 10 Zeilen mit je 5 Spalten besteht. In diesem Fall kann auf jede i-te Zeile m [i] und auf jedes j-te Element innerhalb der i-ten Zeile – m [i, j] zugegriffen werden.

Die Definition von Typen für zweidimensionale Pascal-Arrays kann in einer Zeile angegeben werden:

Typ
Matrix = Array von Array von< тип элементов >;
oder noch einfacher:
Typ
Matrix = Array von<тип элементов>;

Die Referenz auf die Elemente eines zweidimensionalen Arrays sieht so aus: M [i, j]. Dies bedeutet, dass wir das Element erhalten möchten, das sich in der i-ten Zeile und der j-ten Spalte befindet. Die Hauptsache ist hier, Zeilen nicht mit Spalten zu verwechseln, sonst können wir wieder ein nicht vorhandenes Element aufrufen. Zum Beispiel hat ein Aufruf des Elements M die richtige Notation, kann aber einen Fehler im Programm verursachen.

Grundoperationen mit zweidimensionalen Pascal-Arrays

Alles, was über grundlegende Operationen mit eindimensionalen Arrays gesagt wurde, gilt auch für Matrizen. Die einzige Aktion, die auf Matrizen des gleichen Typs als Ganzes ausgeführt werden kann, ist die Zuweisung. Das heißt, wenn unser Programm zwei Matrizen des gleichen Typs beschreibt, zum Beispiel:

Typ
Matrix = Array von ganzen Zahlen;
var
a, b: Matrix;

dann können Sie während der Ausführung des Programms die Matrix zuweisen ein Matrixwert B(a: = b). Alle anderen Aktionen werden Element für Element ausgeführt, während Sie an den Elementen alle gültigen Operationen ausführen können, die für den Datentyp der Array-Elemente definiert sind. Das heißt, wenn ein Array aus Ganzzahlen besteht, können Operationen, die für Ganzzahlen definiert sind, an seinen Elementen ausgeführt werden, aber wenn das Array aus Zeichen besteht, dann sind Operationen, die für die Arbeit mit Zeichen definiert sind, auf diese anwendbar.

Eingabe eines zweidimensionalen Pascal-Arrays.

Um die Elemente eines eindimensionalen Arrays nacheinander einzugeben, haben wir eine for-Schleife verwendet, in der wir den Indexwert vom 1. zum letzten geändert haben. Aber die Position eines Elements in einem zweidimensionalen Pascal-Array wird durch zwei Indizes bestimmt: die Zeilennummer und die Spaltennummer. Dies bedeutet, dass wir die Zeilennummer sequentiell von der ersten zur letzten ändern und in jeder Zeile die Elemente der Spalten von der ersten bis zur letzten durchlaufen müssen. Dies bedeutet, dass wir zwei for-Schleifen benötigen, von denen eine in die andere verschachtelt wird.

Betrachten Sie ein Beispiel für die Eingabe eines zweidimensionalen Pascal-Arrays über die Tastatur:

Typ
Matrix = Array von ganzen Zahlen;
var
a,: Matrix;
i, j: ganze Zahl; (Array-Indizes)
Start
for i: = 1 bis 5 do (Schleife zum Iterieren über alle Zeilen)
readln (a [i, j]); (Tastatureingabe des Elements in der i-ten Zeile und j-ten Spalte)

Ein zweidimensionales Pascal-Array kann zufällig gefüllt werden, d.h. Verwenden Sie die Zufallsfunktion (N) und weisen Sie jedem Element der Matrix den Wert eines Ausdrucks zu. Die Art und Weise, das zweidimensionale Pascal-Array zu füllen, wird je nach Aufgabenstellung gewählt, aber in jedem Fall muss jedes Element in jeder Zeile und jeder Spalte definiert werden.

Zeigt ein zweidimensionales Pascal-Array auf dem Bildschirm an.

Die Ausgabe der Elemente eines zweidimensionalen Pascal-Arrays erfolgt ebenfalls sequentiell, es müssen die Elemente jeder Zeile und jeder Spalte gedruckt werden. Gleichzeitig möchte ich, dass die Elemente einer Zeile nebeneinander gedruckt werden, d.h. in eine Zeile, und die Elemente der Spalte lagen untereinander. Dazu müssen Sie die folgende Abfolge von Aktionen ausführen (beachten Sie das Programmfragment für das im vorherigen Beispiel beschriebene Array):

for i: = 1 bis 5 do (Schleife zum Iterieren über alle Zeilen)
Start
für j: = 1 bis 10 do (über alle Elemente der Zeile für Spalte iterieren)
schreiben (a [i, j]: 4); (Drucken der Elemente in der i-ten Zeile der Matrix in einer Bildschirmzeile, wobei für die Ausgabe jedes Elements 4 Positionen belegt sind)
schreiben; (Bevor Sie die Zeilennummer in der Matrix ändern, müssen Sie den Cursor an den Anfang einer neuen Bildschirmzeile bewegen)
Ende;

Anmerkung ( es ist wichtig!): sehr oft tritt in Studentenprogrammen ein Fehler auf, wenn die Tastatureingabe oder die Arrayausgabe wie folgt versucht wird: readln (a), writeln (a), wobei ein Ist eine Variable vom Typ Array. Sie sind jedoch überrascht von der Meldung des Compilers, dass eine Variable dieses Typs nicht gelesen oder gedruckt werden kann. Vielleicht verstehen Sie, warum dies nicht geht, wenn Sie sich N Becher in einer Reihe vorstellen und zum Beispiel einen Wasserkocher in der Hand halten. Können Sie mit dem Befehl "Wasser gießen" alle Becher auf einmal füllen? Egal wie sehr Sie es versuchen, Sie müssen in jede Tasse separat gießen. Auch das Befüllen und Anzeigen von Array-Elementen sollte sequentiell und Element für Element erfolgen, da im Computerspeicher befinden sich die Array-Elemente in sequentiellen Zellen.

Darstellung eines zweidimensionalen Pascal-Arrays im Speicher

Die Elemente eines abstrakten Arrays im Speicher der Maschine sind entsprechend der Beschreibung physikalisch sequentiell angeordnet. Darüber hinaus belegt jedes Element im Speicher die seiner Größe entsprechende Anzahl von Bytes. Wenn das Array beispielsweise aus Elementen des Typs Integer besteht, belegt jedes Element zwei Byte. Und das gesamte Array nimmt S ^ 2 Bytes ein, wobei S die Anzahl der Elemente im Array ist.

Und wie viel Platz nimmt ein Array bestehend aus Arrays ein, d.h. Matrix? Offensichtlich: S i ^ S j, wobei S i die Anzahl der Zeilen und S j die Anzahl der Elemente in jeder Zeile ist. Zum Beispiel für ein Array wie

Matrix = Array von ganzen Zahlen;

es wird 12 Byte Speicher benötigen.

Wie werden die Elemente dieses Arrays im Speicher abgelegt? Betrachten Sie das Layout eines Arrays M vom Typ Matrix im Speicher.

Jedem Element M vom Typ Integer sind zwei Speicherzellen zugeordnet. Die Ablage im Speicher erfolgt "von unten nach oben". Die Elemente werden in der Reihenfolge der Indexänderung platziert, die dem Schema der verschachtelten Schleifen entspricht: zuerst wird die erste Zeile platziert, dann die zweite, die dritte ... Innerhalb der Zeile werden die Elemente der Reihe nach angeordnet: erste, zweite, usw.

Wie wir wissen, ist der Zugriff auf jede Variable nur möglich, wenn die Adresse der Speicherzelle bekannt ist, in der die Variable gespeichert ist. Beim Laden des Programms wird einer Variablen ein bestimmter Speicher zugewiesen, dh es wird eine gegenseitige Entsprechung zwischen der Variablen und der Zellenadresse hergestellt. Wenn wir die Variable jedoch als Array deklariert haben, "kennt" das Programm die Adresse des Anfangs des Arrays, dh seines ersten Elements. Wie greifen Sie auf alle anderen Elemente des Arrays zu? Bei echtem Zugriff auf eine Speicherzelle, die ein Element eines zweidimensionalen Arrays speichert, berechnet das System seine Adresse mit der Formel:

Addr + SizeElem * Cols * (I -1) + SizeElem * (J -1),

wobei Addr die tatsächliche Startadresse ist, an der sich das Array im Speicher befindet; I, J - Elementindizes in einem zweidimensionalen Array; SizeElem - die Größe des Array-Elements (z. B. zwei Bytes für Integer-Elemente); Cols - die Anzahl der Elemente in der Zeile.

Der Ausdruck SizeElem * Cols * (I -1) + SizeElem * (J -1) wird als Offset vom Anfang des Arrays bezeichnet.

Wie viel Speicher wird dem Array zugewiesen?

Betrachten wir nicht so sehr die Frage, wie viel Speicher dem Array zugewiesen wird (wir haben dies im vorherigen Abschnitt besprochen), sondern die maximal zulässige Größe des Arrays angesichts der begrenzten Speichermenge.

Damit das Programm funktioniert, wird der Speicher in Segmenten von jeweils 64 KB zugewiesen, und mindestens eines davon ist definiert als Datensegment... In diesem Segment befinden sich die Daten, die das Programm verarbeitet. Keine Programmvariable darf sich in mehr als einem Segment befinden. Daher kann es, selbst wenn es nur eine Variable im Segment gibt, die als Array beschrieben wird, nicht mehr als 65536 Byte empfangen. Aber mit ziemlicher Sicherheit werden zusätzlich zum Array noch einige weitere Variablen im Datensegment beschrieben, so dass die tatsächliche Speichermenge, die für das Array zugewiesen werden kann, durch die Formel ermittelt wird: 65536-S, wobei S die Menge von ist Speicher bereits für andere Variablen reserviert.

Warum müssen wir das wissen? Um sich nicht zu wundern, wenn der Übersetzer beim Übersetzen eine Fehlermeldung über die Deklaration eines zu langen Arrays generiert, wenn er im Programm auf eine (syntaxrichtige) Beschreibung stößt:

Geben Sie myArray = Array von Integern ein;

Sie wissen bereits, dass Sie angesichts der Zwei-Byte-Darstellung von Ganzzahlen tatsächlich ein Array mit der Anzahl der Elemente gleich 65536/2 –1 = 32767 deklarieren können. Und dann nur, wenn es keine anderen Variablen gibt. 2D-Arrays sollten noch kleinere Indexgrenzen haben.

Beispiele zum Lösen von Problemen mit zweidimensionalen Pascal-Arrays

Aufgabe: Finden Sie das Produkt von Elementen der Matrix ungleich null.

Lösung:

• Um dieses Problem zu lösen, benötigen wir Variablen: eine Matrix, die beispielsweise aus ganzzahligen Elementen besteht; P ist das Produkt anderer Elemente als 0; I, J – Array-Indizes; N, M - die Anzahl der Zeilen und Spalten in der Matrix.
• Eingabedaten sind N, M - wir geben ihre Werte über die Tastatur ein; Matrix - wir werden die Eingabe der Matrix in Form einer Prozedur anordnen, wir werden die Matrix zufällig füllen, d.h. mit der Zufallsfunktion ().
• Die Ausgabedaten sind der Wert der Variablen P (Produkt).
• Um die Korrektheit der Programmausführung zu überprüfen, ist es notwendig, die Matrix auf dem Bildschirm anzuzeigen, dazu formulieren wir das Verfahren zur Anzeige der Matrix.
• Fortschritte bei der Problemlösung:

wir werden zuerst die Ausführung des Hauptprogramms besprechen, wir werden etwas später die Durchführung der Verfahren besprechen:

• geben Sie die Werte von N und M ein;
• Wir führen ein zweidimensionales Pascal-Array ein, dazu wenden wir uns der Prozedur vvod (a) zu, wobei a eine Matrix ist;
• Lassen Sie uns die resultierende Matrix drucken, dafür verweisen wir auf das print (a)-Verfahren;
• Weisen wir der Variablen P = 1 den Anfangswert zu;
• Wir werden sequentiell über alle Zeilen von I vom 1. bis zum N. iterieren, in jeder Zeile werden wir durch alle Spalten von J vom 1. bis zum M. iterieren, für jedes Element der Matrix prüfen wir die Bedingung: wenn a ij ? 0, dann wird das Produkt P mit dem Element a ij multipliziert (P = P * a ij);
• Lassen Sie uns den Wert des Produkts von Matrixelementen ungleich Null anzeigen - P;

Lassen Sie uns nun über die Verfahren sprechen.

Kommentar (es ist wichtig!) Ein Prozedurparameter kann eine beliebige Variable eines vordefinierten Typs sein, dh um ein Array als Parameter an die Prozedur zu übergeben, muss dessen Typ im Voraus beschrieben werden. Zum Beispiel:

Typ
Matrix = Array von ganzen Zahlen;
Prozedur-Primer (a: Matrix);
..............................

Kommen wir nun zu unseren Verfahren zurück.

Die Prozedur zum Eingeben einer Matrix heißt vvod, der Parameter der Prozedur ist eine Matrix und muss daher an das Hauptprogramm übergeben werden, daher muss der Parameter als Referenz übergeben werden. Dann sieht der Header unserer Prozedur so aus:

Verfahren vvod (var m: Matrix);

Um verschachtelte Schleifen in einer Prozedur zu implementieren, benötigen wir lokale Zählervariablen, zum Beispiel k und h. Der Matrixfüllalgorithmus wurde bereits besprochen, daher werden wir ihn nicht wiederholen.

Die Prozedur zum Anzeigen einer Matrix auf dem Bildschirm heißt print, der Parameter der Prozedur ist eine Matrix, aber in diesem Fall ist es ein Eingabeparameter, daher wird er als Wert übergeben. Der Titel dieses Verfahrens sieht wie folgt aus:

Prozedur print (m: Matrix);

Und wieder, um verschachtelte Schleifen innerhalb einer Prozedur zu implementieren, brauchen wir Zähler, lassen Sie sie gleich heißen - k und h. Der Algorithmus zum Anzeigen der Matrix auf dem Bildschirm wurde oben beschrieben, wir verwenden diese Beschreibung.

Programm proizvedenie;
Typ
Matrix = Array von ganzen Zahlen;
Var
A: Matrix;
N, m, i, j: Byte;
P: ganze Zahl;
Verfahren vvod (var m: Matrix);
Var k, h: Byte;
Start
Für i: = 1 bis n do (die Variable n für die Prozedur ist global, was "bekannt" bedeutet)
Für j: = 1 bis m do (die Variable m für die Prozedur ist global, was "bekannt" bedeutet)
M: = zufällig (10);
Ende;
Prozedur print (m: Matrix);
Var k, h: Byte;
Start
Für i: = 1 bis n do
Start
Für j: = 1 bis m do
Schreiben (M: 4);
Schreiben;
Ende;
Ende;
Beginn (Beginn des Hauptprogramms)
Writeln ("Geben Sie die Dimension der Matrix ein:");
Readln (N, M);
Vvod (a);
Drucken (a);
P: = 1;
Für i: = 1 bis N do
Für j: = 1 bis M do
Wenn eine<>0 dann p: = p * a;
Writeln (p);
Ende.

Zweidimensionales Array eine Datenstruktur, die eine rechteckige Matrix der Form speichert:

EIN 11 ein 12 ein 13 ein 14 ein 15 ... ein 1m ein 21 ein 22 ein 23 ein 24 ein 25 ... ein 2m ein 31 ein 32 ein 33 ein 34 ein 35 ... ein 3m ein 41 ein 42 ein 43 ein 44 ein 45 ... ein 4m ein 51 ein 52 ein 53 ein 54 ein 55 ... ein 5m... ... ... ... ... ... ... ein n1 ein n2 ein n3 ein n4 ein n5... ein nm

• In der Matrix wird jedes Element durch die Nummer der Zeile und die Nummer der Spalte bestimmt, an deren Schnittpunkt es sich befindet
• In Pascal wird ein zweidimensionales Array als ein Array betrachtet, dessen Elemente lineare Arrays (ein Array von Arrays) sind. Die folgenden beiden Beschreibungen von zweidimensionalen Arrays sind identisch var masse: Array des Arrays von Real; var masse: Array von reellen;
• Eine Matrix, bei der die Anzahl der Zeilen gleich der Anzahl der Spalten ist, heißt quadratische Matrix.
• Um auf ein Element der Matrix zu verweisen, müssen Sie zwei Indizes verwenden, die die Zeilennummer und die Spaltennummer angeben. Zum Beispiel MyArr1... In diesem Fall befindet sich das Array-Element (MyArr1) in der vierten Zeile und fünften Spalte.
• Alles, was über grundlegende Operationen mit eindimensionalen Arrays gesagt wurde, gilt auch für Matrizen. Beim Iterieren über ein Array in einer Schleife fungieren Variablen vom Typ Integer als Indizes. Traditionell ist die Kennung „ ich „Und die Spalte ist“ J “.
• Die Matrixverarbeitung besteht darin, dass zuerst die Elemente der ersten Zeile (Spalte) nacheinander betrachtet werden, dann die zweite und so weiter bis zur letzten.
• Wenn die Zeilennummer des Elements mit der Spaltennummer übereinstimmt ( ich = j), das heißt, das Element liegt auf Hauptdiagonale Matrizen.
• Liegt ein Element auf der Seitendiagonale, dann beziehen sich die Indizes auf die Anzahl der Elemente ( n) durch folgende Gleichheit: i + j = n + 1

Beschreibung eines zweidimensionalen Arrays

Es gibt mehrere Möglichkeiten, ein zweidimensionales Array in Pascal zu deklarieren (zu beschreiben).

Array-Typ Vorläufige Beschreibung

Eine Variable als Array definieren, ohne zuerst den Typ des Arrays zu beschreiben

Initialisieren eines zweidimensionalen Arrays

Beim Initialisieren zweidimensionaler Arrays wird jede Zeile in ein zusätzliches Klammerpaar eingeschlossen:

Konstante Masse: Array = ((2,3,1,0), (1,9,1,3), (3,5,7,0));

Eingabe / Ausgabe von Werten von Elementen eines zweidimensionalen Arrays

Sehr oft werden die Werte von Array-Elementen über die Tastatur eingegeben. Diese Art der Angabe von Informationen ist bei der Arbeit mit großen Arrays zu umständlich. Um eine breite Klasse von Algorithmen zu debuggen, sollte eine solche Eingabe von Informationen durch eine zufällige Erzeugung von Array-Elementen ersetzt werden. Verwenden Sie dazu das Verfahren randomisieren und Funktion willkürlich... Beim Arbeiten mit zweidimensionalen Arrays werden verschachtelte Schleifen verwendet (normalerweise eine Schleife mit dem Parameter zum).

Füllen eines Arrays mit Zufallszahlen

Beispiele für Problemlösungen

Beispiel 1

Formulierung des Problems. Gegeben seien positive ganze Zahlen M und N. Bilde eine M × N ganzzahlige Matrix, in der alle Elemente der J-ten Spalte den Wert 5 · J haben (J = 1,…, N).

Konstm = 7; n = 10; var i, j: Byte; Matrix: Array von ganzen Zahlen; begin für i: = 1 bis m do für j: = 1 bis n do Matrix: = 5 * j; ... (Ausgabe-Array)

Beispiel 2

Formulierung des Problems. Sie erhalten positive ganze Zahlen M, N und eine Menge von M Zahlen. Bilden Sie eine M × N-Matrix, wobei jede Spalte alle Zahlen aus dem ursprünglichen Satz enthält (in der gleichen Reihenfolge).

Konstm = 5; n = 7; Vektor: Array von Integer = (3, 5, 2, 7, 4); var i, j: Byte; Matrix: Array von ganzen Zahlen; begin für j: = 1 bis n do (nehmen Sie die j-te Spalte) für i: = 1 bis m do (beziehen Sie sich auf die Elemente der j-ten Spalte durch Zeilen) Matrix: = Vektor [i]; (Implementierung) ... (Ausgabe des resultierenden zweidimensionalen Arrays)

Hausaufgaben

1. Gegeben positive ganze Zahlen M und N. Bilden Sie eine ganzzahlige Matrix der Größe M × N, in der alle Elemente der I-ten Zeile den Wert 10 · I haben (I = 1,…, M).
2. Sie erhalten positive ganze Zahlen M, N und eine Menge von N Zahlen. Bilden Sie eine M × N-Matrix, wobei jede Zeile alle Zahlen aus dem ursprünglichen Satz enthält (in der gleichen Reihenfolge).
3. Zusätzlich. Sie erhalten positive ganze Zahlen M, N, eine Zahl D und eine Menge von M Zahlen. Bilden Sie eine M × N-Matrix, in der die erste Spalte mit dem ursprünglichen Zahlensatz übereinstimmt und die Elemente jeder nächsten Spalte gleich der Summe des entsprechenden Elements der vorherigen Spalte und der Zahl D sind (als Ergebnis ist jede Zeile der Matrix Elemente der arithmetischen Folge enthalten).
4. Zusätzlich. Gegeben ist eine M × N-Matrix, deren Elemente in Reihen mit geraden Zahlen (2, 4, …) gedruckt werden. Zeigen Sie Elemente zeilenweise an, verwenden Sie nicht den Bedingungsoperator.

Die letzte Lektion Pascals wurde bereits am 7. März geschrieben, dann haben wir sie analysiert. Heute werden wir herausfinden, was es ist zweidimensionales Array in Pascal, wie es beschrieben wird und was es ist. Weitere Details weiter unten.

Was genau ist also ein zweidimensionales Array? Stellen wir uns zur leichteren Wahrnehmung ein eindimensionales Array als Linie vor, in dem alle Elemente horizontal nacheinander verlaufen, und ein zweidimensionales als Quadrat, in dem sich die Elemente sowohl horizontal als auch vertikal befinden. Ein zweidimensionales Array besteht aus Zeilen und Spalten, auch Matrix oder Matrixarray genannt.

Wie werden zweidimensionale Arrays beschrieben? Es gibt mehrere Möglichkeiten, zweidimensionale Arrays zu schreiben, ich werde 2 davon betrachten.

1 Möglichkeit, ein Array zu beschreiben: Array des Typs der Variablen im Array (Ganzzahl / Real / Byte);

2 Möglichkeiten, ein Array zu beschreiben: Array von Array des Typs der Variablen im Array;

Zuerst werden Zeilen (1..m) und dann Spalten (1..n) beschrieben.

Die zweite Methode beschreibt sozusagen zwei eindimensionale Arrays, die zusammen ein zweidimensionales bilden.

Ein zweidimensionales Array kann im Abschnitt Typ beschrieben werden, um später mehrmals darauf Bezug zu nehmen, oder im Abschnitt Variablenbeschreibung Var, ich möchte Sie darauf aufmerksam machen, dass Sie anstelle von m und n Zahlen ersetzen können, oder Sie können Konstanten verwenden.

Ein Beispiel für das Festlegen eines zweidimensionalen Arrays im Abschnitt zur Variablendeklaration:

Konst
m = 100;
n = 100;
var
a: Array von ganzen Zahlen;

In diesem Fall haben wir ein zweidimensionales Array a der Größe 100 mal 100 angegeben, also eine quadratische Matrix erhalten.

Ein Beispiel für die Definition eines Matrix-Arrays mithilfe des Abschnitts Typ:

Konst
m = 100;
n = 100;
Typ
Matrix = Array von ganzen Zahlen;
var
a: Matrix;
b: Matrix;

Im zweiten Beispiel haben wir zwei identische Matrix-Arrays mit den Dimensionen 100 mal 100 angegeben, bei der Beschreibung des b-Arrays mussten wir dessen Größe und Datentyp nicht noch einmal beschreiben.

Wie greife ich auf eine variable Zelle eines zweidimensionalen Arrays zu?

Um auf ein zweidimensionales Array zu verweisen, müssen Sie zunächst die Zeilennummer und dann die Spaltennummer wie folgt angeben:

x ist eine beliebige Variable, a ist der Name des Arrays, i ist die Zeilennummer, j ist die Spaltennummer.

Außerdem können i und j sowohl Variablen als auch ganze Zahlen sein.

Ein Beispiel für das Schreiben von Daten in ein Array:

For i: = 1 to n do // setze die Zeilennummer in der Schleife
For j: = 1 to m do // Zuweisung der Spaltennummer in der Schleife
a: = zufällig (100); // der Zelle mit der Zeilennummer i und der Spaltennummer j einen Zufallswert zuweisen

Wir haben das Array mit Zufallszahlen von 1 bis 100 gefüllt.

Ein Beispielprogramm mit einem zweidimensionalen Array, in dem wir das Array mit Zufallszahlen füllen und auf dem Bildschirm anzeigen:

Var // Beschreibung von Variablen und Array
Matrix: Array von Integern;
i, j: ganze Zahl;

Start // Start des Hauptprogramms
writeln ("Zweidimensionales Array:"); // Dialog mit dem Nutzer

Für i: = 1 bis 10 do // das Array füllen
für j: = 1 bis 10 do
Matrix: = zufällig (100);

For i: = 1 to 10 do begin // Array ausgeben
für j: = 1 bis 10 do
schreiben (Matrix, "");
schreiben
writeln ("Site"); // Optional können Sie löschen
Ende; // Programmende

// readln // Verwendet in Turbo Pascal