Riempi l'array bidimensionale esattamente fino all'espressione. Array a due mondi di Pascal: matrici. Una casa per il virtuosismo indipendente
Quando è presente un gran numero di dati dello stesso tipo, i dati variabili con nomi diversi, poiché non sono ordinati per indirizzi di memoria, complicano la programmazione. In questi casi, utilizziamo oggetti chiamati array.
- Si tratta di una memorizzazione continua di memoria per accogliere la sequenza di oggetti dello stesso tipo, designati con un nome.
Il massiccio è caratterizzato dai seguenti concetti fondamentali:
Elemento massiccio (significato di elemento massiccio)– il valore memorizzato nel vano di memoria, distribuito nell'array, nonché l'indirizzo di questo vano di memoria.
L'elemento pelle del massiccio è caratterizzato da tre valori:
- indirizzo dell'elemento - l'indirizzo della memoria cob in cui viene ruotato questo elemento;
- indice dell'elemento (numero ordinale dell'elemento nell'array);
- significato dell'elemento.
Indirizzi Massivu – indirizzi dell'elemento cob massivu.
Nome dell'array: un identificatore utilizzato per la suddivisione degli elementi dell'array.
La dimensione dell'array è il numero di elementi nell'array
La dimensione di un elemento è il numero di byte che occupano un elemento dell'array.
È possibile riorganizzare graficamente l'array nella memoria del computer osservando la pagina degli indirizzi continui.
Rappresenta una piccola matrice di q elementi con indici compresi tra 0 e q-1. Un elemento skin occupa k byte di memoria del computer e gli elementi vengono sostituiti in memoria in sequenza.
Gli indirizzi dell'i-esimo elemento dell'array hanno valori
Gli indirizzi dell'array sono l'indirizzo dell'elemento cob (zero) dell'array. Per la moltiplicazione degli elementi dell'array viene calcolato il numero di serie (indice) dell'elemento, il cui primo valore è uguale a 0. Pertanto, se un array contiene q elementi, gli indici degli elementi dell'array cambiano tra 0 e q-1.
Array Dovzhina: il numero di byte allocati in memoria per salvare tutti gli elementi dell'array.
Dovzhina Massivu = Dimensione dell'elemento * Quantità degli elementi
Per determinare la dimensione di un elemento dell'array, è possibile utilizzare la funzione
int dimensione(tipo);
Per esempio,
dimensionedi(carattere) = 1;
dimensionedi(int) = 4;
dimensionedi(float) = 4;
dimensione(doppio) = 8;
Stordimento e inizializzazione degli array
Per semplificare l'array nel linguaggio, viene utilizzata la seguente sintassi:
tipo nome [dimensione] = (inizializzazione);
L'inizializzazione è un insieme di valori cob di elementi dell'array, assegnati agli archi figurati e separati da virgole.
int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // array a con 10 numeri interi
Poiché nei bracci quadrati è indicato il numero di valori iniziali nei bracci ricci, inferiore al numero di elementi dell'array, tutti gli elementi che vengono persi nell'array (per i quali non è presente alcun valore di autorizzazione) verranno azzerati. Questo potere deve essere utilizzato manualmente per assegnare valori zero a tutti gli elementi dell'array.
int b = (0); // array b con 10 elementi, inizializzato a 0
Se una serie di pronunce è assordata, i valori cob costanti dei suoi elementi sono indicati attraverso le braccia della figura. In questo caso, alcuni elementi dei bracci quadrati possono essere omessi.
int a = (1, 2, 3, 4, 5, 6, 7, 8, 9);
Quando si espande la matrice in elementi, l'indice dell'elemento richiesto è indicato tra i bracci quadrati.
Culo in C
1
2
3
4
5
6
7
8
#includere
int principale()
{
int a = (5, 4, 3, 2, 1); // l'array a contiene 5 elementi
printf("%d%d%d%d\n", a, a, a, a, a);
getchar();
restituire 0;
}
Risultato del programma:
Tuttavia, spesso è necessario specificare i valori degli elementi dell'array durante il processo di programmazione. Il cui vikorist ha una massa stordita senza inizializzazione. In questo caso l'inserimento di più elementi nei bracci quadrati è rilegato.
intero a;
Per determinare i valori cob degli elementi di un array, viene spesso utilizzato un ciclo parametrico:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#includere
int principale()
{
intero a;
int io;
// Inserimento di elementi nell'array
per (i = 0; i<5; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
// Visualizza gli elementi dell'array
per (i = 0; i<5; i++)
printf("%d", a[i]); // C'è una lacuna nel formato
getchar(); getchar();
restituire 0;
}
Risultato del programma Vikonannya 
Massicci del mondo ricco
Potresti avere accesso a una vasta gamma di aree del mondo. L'importanza di un array ricco di dimensioni rispetto a un array unidimensionale è che in un array unidimensionale la posizione dell'elemento è indicata da un indice e in un array ricco di dimensioni da una decalcomania. Il calcio del ricco massiccio è la matrice.
La forma zagal dello stupore del massiccio del mondo ricco
nome tipo[dimensione1][dimension2]...[dimensionm];
Gli elementi dell'array rich world vengono ruotati nelle parti successive della memoria operativa dell'indirizzo crescente. Nella memoria del computer vengono ruotati gli elementi di un array ricco, ad esempio un array che ha 2 righe e 3 colonne,
intero a;
verrà ritoccato in memoria al prossimo grado
Il numero di elementi nella matrice bidimensionale indotta appare come
Numero di righe * Numero di righe = 2 * 3 = 6.
Il numero di byte di memoria richiesti per allocare l'array viene calcolato come
Numero di elementi * Dimensione elemento = 6 * 4 = 24 byte.
Inizializzazione dei massicci più ricchi del mondo
I valori degli elementi di un array multidimensionale, come nell'espressione unidimensionale, possono essere specificati da valori costanti nel caso della colonna, disposta a forma di arco (). Tuttavia, in questo caso, alcuni elementi delle righe e delle colonne possono essere rigorosamente indicati nei bracci quadrati.
Culo in C
1
2
3
4
5
6
7
8
9
#includere
int principale()
{
int a = (1, 2, 3, 4, 5, 6);
printf("%d%d%d\n", a, a, a);
getchar();
restituire 0;
}
Tuttavia, è più spesso necessario inserire i valori degli elementi di un ricco array durante il processo di programmazione. Con questo metodo è possibile analizzare manualmente gli inserimenti del ciclo parametrico.
Culo in C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#define _CRT_SECURE_NO_WARNINGS
#includere
int principale()
{
intero a; // array con 2 righe e 3 righe
int i, j;
// Inserimento di elementi nell'array
per (i = 0; i<2; i++) // esegue il ciclo in righe
{
per (j = 0; j<3; j++) // scorre cento elementi
{
printf("a[%d][%d] = ", i, j);
scanf("%d", &a[i][j]);
}
}
// Visualizza gli elementi dell'array
per (i = 0; i<2; i++) // esegue il ciclo in righe
{
per (j = 0; j<3; j++) // scorre cento elementi
{
printf("%d", a[i][j]);
}
printf("\n"); // Trasferito in una nuova riga
}
getchar(); getchar();
restituire 0;
}
Passaggio di un array a una funzione
L'elaborazione degli array può essere organizzata manualmente utilizzando funzioni speciali aggiuntive. Per elaborare l'array come argomenti di funzione, è necessario passare
- indirizzi masivu,
- dimensione del massiccio.
È necessario impostare le funzioni di elaborazione delle righe, quindi è sufficiente trasferirle all'indirizzo.
Quando si passano modifiche come argomenti a una funzione, i dati vengono passati come copie. Ciò significa che nel mezzo della funzione verrà modificato il valore del parametro, ma non in alcun modo sul valore nel mezzo della funzione che viene chiamata.
Se l'indirizzo della modifica (o l'indirizzo dell'array) viene passato alla funzione, tutte le operazioni che coinvolgono la funzione con dati che rientrano nella visibilità dell'indirizzo designato vengono eseguite sui dati originali, quindi l'array di output (o il valore minnoy) può essere modificato dalla funzione che grida.
Testa su C Dato un array di 10 elementi. Scambia gli elementi massimo e di output dell'array. Per cercare l'elemento massimo e scambiare, utilizzare la funzione.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#define _CRT_SECURE_NO_WARNINGS
#includere
// Funzione di scambio
cambiamento vuoto(int * x, int n)
{
// x - puntatore all'array (indirizzi all'array)
// n - dimensione dell'array
int io;
int massimo, indice;
massimo = x;
indice = 0;
// Cerca l'elemento massimo
per (i = 1; i
se (x[i]>max)
{
massimo = x[i];
indice = io;
}
}
// Scambio
x = x;
x = massimo;
}
// Funzione della testa
int principale()
{
intero a;
int io;
per (i = 0; i<10; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
cambiamento(a, 10); // fai clic sulla funzione di scambio
// Visualizza gli elementi dell'array
per (i = 0; i<10; i++)
printf("%d", a[i]);
getchar();
getchar();
ritorno
p = p*x[i];
}
restituire p;
}
// Funzione della testa
int principale()
{
intero a; // array vuoto a con 5 elementi
int io;
int pr;
// Inserimento di elementi nell'array
per (i = 0; i<5; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]); // &a[i] - indirizzi dell'i-esimo elemento dell'array
}
pr = funzione(a, 5); // Calcolo della creatività
printf("\npr = %d",pr); // Sto creando alcuni nuovi elementi
getchar(); getchar();
restituire 0;
}
Diviso: Informatica
Soggetto: Massiccio dei due mondi. Prenotazione del massiccio dei due mondi secondo una determinata regola.
Obiettivi: impara come lavorare con gli elementi di un array a due mondi, impara a memorizzare array a due mondi secondo una determinata regola, impara a dedurre la posizione tra il numero di riga e il numero di colonna; sviluppo del pensiero logico degli scienziati.
LAVORO NASCOSTO
1. Aggiornamento delle conoscenze
Gli array le cui posizioni degli elementi sono descritte da due indici sono detti bidimensionali. La struttura di tale array può essere rappresentata da una matrice lineare. All’elemento pelle della matrice viene assegnato in modo univoco il numero della fila e il numero della traversina, numero della fila – i, numero della traversina – j.
Consideriamo una matrice di dimensione n*m:
| un 11 | un 12 | un 13 | un 14 |
| un 21 | un 22 | un 23 | un 24 |
| un 31 | un 32 | un 33 | un 34 |
Matrice con 3 righe e 4 colonne, numero di righe n=3, numero di colonne m=4. Un elemento in pelle ha il proprio numero, composto da due numeri: il numero della riga in cui si trova l'elemento e il numero della riga. Ad esempio, a23 è un elemento che si trova nell'altra riga e nella terza colonna.
La disposizione a due mondi di Turbo Pascal può essere descritta in diversi modi. Per descrivere un array bidimensionale è necessario sapere che tipo di elemento è e come è numerato (che tipo di indice è). Esistono diversi modi per descrivere un array bidimensionale.
Cost maxN = ...; (Valori massimi per il numero di righe)
maxM=…; (Valori massimi per il numero di clienti)
1 modo
Digitare Mas = array di<тип элементов>; (array unidimensionale)
Digitare TMas = array di Mas; (array unidimensionale, i cui elementi sono array unidimensionali)
Metodo 2
Digitare TMas = array di array di<тип
элементов>;
(array unidimensionale, i cui elementi sono array unidimensionali)
3 vie
Tipo<имя типа>= matrice di<тип элементов>; (Massiccio dei Due Mondi)
Il vantaggio è dato al terzo metodo per descrivere la matrice bidimensionale.
Per esempio:
Cost. N=3; M=4;
Digitare TMas = array di numeri interi; (Array bidimensionale di numeri interi)
La formazione di un array bidimensionale può essere effettuata in diversi modi: inserendo dalla tastiera tramite un generatore di numeri casuali, mediante una determinata regola o utilizzando un file aggiuntivo.
1) Formazione di un array bidimensionale utilizzando input aggiuntivi dalla tastiera e un algoritmo per la visualizzazione in righe di elementi della matrice.
Cost N = 10; M = 10;
Digitare Tmas = array di numeri interi;
Var A: Tmas; i,j:intero;
Inizio
(Introduzione degli elementi di matrice)
Per i:=1 a N fai
Per j:=1 a M fai
Leggi un);
(Visualizzazione degli elementi della matrice)
Per i:=1 fino a N iniziano
Per j:=1 a M fai
Scrivi(A:4); (Combattimenti in prima fila)
Writeln (Sposta in una nuova riga)
FINE;
FINE.
2) Un frammento del programma per formare un array bidimensionale tramite un generatore di numeri casuali.
Inizio
Rendi casuale; (Inizializzazione del generatore di numeri casuali)
(Introduzione degli elementi di matrice)
Per i:=1 a N fai
Per j:=1 a M fai
A:=casuale(45)-22;
2. Introduzione di nuovo materiale. Prenotazione del massiccio secondo la regola
Diamo un'occhiata ad alcuni frammenti di programmi per riempire la matrice dei due mondi dietro la legge attuale. A questo scopo è necessario ricavare una regola pratica.
1. Riempire il massiccio A con la dimensione n*m in questo ordine, ad esempio
1
2
3
4
5
6
7 8
16 15
14 13
12 11
10 9
17 18
19 20
21 22
23 24
32 31
30 29
28 27
26 25
33 34
35 36
37 38
39 40
48 47
46 45
44 43
42 41
Massiv seguirà il principio del “serpente”. Regola di sostituzione: se il numero di riga è un numero spaiato, allora A=(i-1)*m+j, altrimenti A=i*m-j+1.
programma M1A;
n, m, i, j: intero;
inizio
leggiln(n,m);
per i:=1 an iniziano
per j:=1 a m fai
inizio
se i mod 2 = 1 allora
A=(i-1)*m+j
altro
A=i*m-j+1;
scrivi(A:3);
FINE;
scrivere;
FINE;
leggere;
FINE.
Diamo un'occhiata al programma in un altro modo per seguire la regola data:
programma M1B;
var A:array di numeri interi;
n, m, i, j: intero;
c:intero;
inizio
leggiln(n,m);
c:=1;
per i:=1 an fare
inizio
per j:=1 a m fai
inizio
A:=c;
se (i mod 2 = 0) e (j<>m) poi
dicembre(c)
altro
inc(c);
scrivi(A:3);
FINE;
c:=c+m-1;
scrivere;
FINE;
leggere;
FINE.
2. Memorizzare l'array A utilizzando il seguente principio:
1
0
2
0
3
0 4
0
5
0
6
0
7 0
8
0
9
0
10
0 11
0
12
0
13
0
14 0
programma M2;
var A:array di numeri interi;
n, m, i, j: intero;
c:intero;
inizio
leggiln(n,m);
c:=0;
per i:=1 an fare
inizio
per j:=1 a m fai
inizio
se (i-1+j) mod 2 = 0 allora
R:=0
altro
inizio
inc(c);
A:=c;
FINE;
scrivi(A:5);
FINE;
scrivere;
FINE;
leggere;
FINE.
3. Memorizzare l'array A utilizzando il seguente principio:
1
12 13
24 25
36
2
11 14
23 26
35
3
10 15
22 27
34
4
9
16 21
28 33
5
8
17 20
29 32
6
7
18 19
30 31
var A:array di numeri interi;
n, m, i, j: intero;
c:intero;
inizio
leggiln(n,m);
c:=1;
per j:=1 a m fai
inizio
per i:=1 an fare
inizio
A:=c;
se (j mod 2 = 0) e (i<>n) allora
dicembre(c)
altro
inc(c);
FINE;
c:=c+n-1;
FINE;
per i:=1 an fare
inizio
per j:=1 a m fai
scrivi(A:5);
scrivere;
FINE;
leggere;
FINE.
4. Memorizzare l'array A utilizzando il seguente principio:
1
2
3
4 5
2
3
4
5 1
3
4
5
1 2
4
5
1
2 3
5
1
2
3 4
var i,j,m,c,d: intero;
inizio
c:=1;
leggiln(m);
per j:=1 a m fai
inizio
io:=c;
d:=1;
ripetere
A:=d;
inc(i);
se lo sono allora
io:=1;
inc(d);
fino a quando i=c;
dec(c);
se c<= 0 then
c:=m-c;
FINE;
for i:=1 a m fai
inizio
per j:=1 a m fai
scrivi(A:2);
scrivere;
FINE;
FINE.
5. Memorizzare l'array A utilizzando il seguente principio:
1
0
0
0 1
0
1
0
1 0
0
0
1
0 0
0
1
0
1 0
1
0
0
0 1
var m,i,j: intero;
A:array di numeri interi;
inizio
leggiln(m);
for i:=1 a m fai
inizio
per j:=1 a m fai
inizio
se (i=j) o (m-i+1=j) allora
R:=1
altro
A:=0;
scrivi(A:2);
FINE;
scrivere;
FINE;
FINE.
3. Progettare per risultati indipendenti
6
5
4
3
2 1
7
8
9
10 11
12
18 17
16 15
14 13
19 20
21 22
23 24
30 29
28 27
26 25
31 32
33 34
35 36
36
25 24
13 12
1
35 26
23 14
11 2
34 27
22 15
10 3
33 28
21 16
9 4
32 29
20 17
8 5
31 30
19 18
7 6
0
1
1
1 0
1
0
1
0 1
1
1
0
1 1
1
0
1
0 1
0
1
1
1 0
4) Memorizzare l'array utilizzando il seguente principio:
31
32 33
34 35
36
25 26
27 28
29 30
19 20
21 22
23 24
13 14
15 16
17 18
7
8
9
10 11
12
1
2
3
4
5 6
5) Memorizzare l'array utilizzando il seguente principio:
31
25 19
13
7 1
32 26
20 14
8 2
33 27
21 15
9 3
34 28
22 16
10 4
35 29
23 17
11 5
36 30
24 18
12 6
Decorazioni per la casa:
1) Memorizzare l'array utilizzando il seguente principio:
6
7
18 19
30 31
5
8
17 20
29 32
4
9
16 21
28 33
3
10 15
22 27
34
2
11 14
23 26
35
1
12 13
24 25
36
2) Memorizzare l'array utilizzando il seguente principio:
31
32 33
34 35
36
30 29
28 27
26 25
19 20
21 22
23 24
18 17
16 15
14 13
7
8
9
10 11
12
6
5
4
3
2 1
3) Memorizzare l'array utilizzando il seguente principio:
0
1
1
1 0
1
0
1
0 1
1
1
0
1 1
1
0
1
0 1
0
1
1
1 0
Un array è la struttura di dati, presentata sotto forma di un gruppo di dati dello stesso tipo, riuniti sotto un unico nome. I vicoristi massicci vengono utilizzati per elaborare un gran numero di dati simili. Ho una serie di coloro che riconosceranno gli stessi indicatori un po' più tardi. L'area circostante di questi massicci è chiamata elemento di matrice. Gli elementi dell'array possono essere assegnati a qualsiasi tipo. Le masse possono generare uno o morire più di uno. È necessario dividere il numero di array virtuali in array unidimensionali, array bidimensionali, array tridimensionali e fino a un array n-dimensionale. Molto spesso, i vicoristi programmati hanno array a uno e due mondi, quindi esamineremo entrambi gli array.
Array unidimensionali C++
Una matrice unidimensionale è una matrice con un parametro che caratterizza il numero di elementi in una matrice unidimensionale. In effetti, un array unidimensionale è un array che può avere più di una riga e l'ennesimo numero di colonne. Gli elementi in un array unidimensionale sono elementi dell'array. La piccola immagine 1 mostra la struttura di un array unidimensionale UN. La dimensione di questo massiccio è di 16 unità.
Malyunok 1 - Masivi in C++
Si noti che l'indice massimo di un array unidimensionale UNè maggiore di 15, ma la dimensione dell'array è di 16 centri, poiché la numerazione dei centri dell'array inizia da 0. L'indice del centro è un numero completamente sconosciuto, che può essere utilizzato per calcolare il centro della pelle dell'array array e konuvati be-yaki dіi sopra di esso (al centro).
//sintassi per svuotare un array unidimensionale C++: /*tipo di dati*/ /*nome di un array unidimensionale*/; // parte finale dello straordinario array unidimensionale rappresentato dal bambino 1: int a;
de, interi interi;
A - il nome di un array unidimensionale;
16 - la dimensione di un array unidimensionale, 16 centri.
Immediatamente dopo il nome dell'array ci sono dei bracci quadrati in cui viene impostata la dimensione dell'array unidimensionale e l'array viene diviso per risolvere le modifiche.
//un altro modo per attenuare gli array unidimensionali int mas, a;
Sono stati annunciati due array unidimensionali di mas con dimensioni di 10 e 16 per linea. Inoltre, in questo metodo, tutti gli array richiedono un nuovo tipo di dati, int - int.
// gli array possono essere inizializzati quando sono vuoti: int a = (5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); //Inizializzazione di un array unidimensionale
L'inizializzazione dell'array unidimensionale è indicata dai bracci ricci dopo il segno. uno, l'elemento cutaneo del massiccio è rafforzato in corrispondenza della coma anteriore.
Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); //Inizializza l'array senza specificarne la dimensione.
Una volta che il compilatore stesso determina la dimensione dell'array unidimensionale. Non è necessario specificare la dimensione dell'array solo per la sua inizializzazione, ma in caso di emergenza è necessario che l'array indichi la dimensione dell'array. Sviluppiamo un semplice programma per elaborare un array unidimensionale.
// array.cpp: definisce il punto di ingresso per il programma della console. #include "stdafx.h" #include
// codice Codice::Blocchi
// Codice Dev-C++
// array.cpp: definisce il punto di ingresso per il programma della console. #includere
U righe 10 - 11 Un array unidimensionale intero con le dimensioni di array1, la cui dimensione è uguale a 16 numeri, è vuoto e inizializzato, in modo che tale array possa memorizzare 16 numeri. Se la lavorazione del massiccio viene eseguita in una sola volta o in cicli. Qual è il ciclo di selezione per la lavorazione del massiccio? È più adatto per questo compito. Il contatore del medico sarà vinto per espandersi agli elementi dell'array unidimensionale array1. Se la continuazione del ciclo for ha segno negativo, non ci sono frammenti del sedicesimo indice nell'array unidimensionale array1. Poiché la numerazione dei centri inizia da zero, l'array ha 16 elementi Nel ciclo per l'operatore cout, ci sono altri elementi di un array unidimensionale (ce ne sono 2 piccoli).
Elaborazione degli indici massiva elemento massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 arra1 premere un tasto qualsiasi. . .
Malyunok 2 - Masivi in C++
Costruiamo un altro programma per elaborare un array C++ unidimensionale. Il programma deve leggere in sequenza dieci numeri immessi dalla tastiera. Tutti i numeri immessi vengono sommati e il risultato viene visualizzato sullo schermo.
// array_sum.cpp: definisce il punto di ingresso per il programma della console. #include "stdafx.h" #include
// codice Codice::Blocchi
// Codice Dev-C++
// array_sum.cpp: definisce il punto di ingresso per il programma della console. #includere
Prima di concludere l'elaborazione della matrice, è necessario votare e la dimensione della matrice unidimensionale è superiore a 10, poiché è determinata dal compito mentale. La variabile sum accumula la somma degli elementi di un array unidimensionale. Il primo ciclo for riempie un array unidimensionale con i numeri immessi dalla tastiera, righe 12 - 13. La variabile contatore viene utilizzata per l'accesso sequenziale agli elementi dell'array della stessa dimensione array1, a partire dall'indice da 0 a 9 compreso. Un altro ciclo for visualizza una serie di elementi sullo schermo, righe 15 - 16. Il terzo ciclo legge in sequenza gli elementi di un array unidimensionale e li somma, la somma si accumula nella variabile sum. righe 17 - 18. Il risultato del programma robotico è meravigliarsi del piccolo 3.
Immettere elemento massiccio: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 Per continuare, premere un tasto qualsiasi. . .
Malyunok 3 - Masivi in C++
Innanzitutto, tutti i 10 numeri sono stati inseriti in sequenza, dopodiché è stata visualizzata una matrice unidimensionale e la somma dei numeri è stata aggiunta alla matrice.
Array a due mondi C++
Fino a che punto abbiamo visto i massicci del mondo unico di cui potremo essere circondati per sempre. È possibile che sia necessario elaborare i dati dalla tabella. La tabella ha due caratteristiche: il numero di righe e il numero di colonne. Anche in un array bidimensionale, oltre al numero di elementi nell'array, ci sono caratteristiche come il numero di righe e il numero di colonne nell'array bidimensionale. Quindi, visivamente, esiste un array a due mondi: la tabella primaria con righe e colonne. In effetti, un array bidimensionale è un array unidimensionale di array unidimensionali. Di seguito è mostrata la struttura di un array bidimensionale con dimensioni a, dimensione m per n (divisione 4).
Malyunok 4 - Masivi in C++
de, m - numero di righe di un array a due mondi;
n - il numero di persone nel massiccio dei due mondi;
m * n – numero di elementi nell'array.
// sintassi per svuotare un array bidimensionale /*tipo di dati*/ /*nome dell'array*/;
In un array bidimensionale assordato, così come in un array unidimensionale assordato, è necessario inserire:
- tipo di dati;
- Sono enorme.
Pertanto, i primi bracci quadrati indicano un numero di righe di una matrice bidimensionale, mentre gli altri bracci quadrati indicano un numero di righe di una matrice bidimensionale. La matrice bidimensionale è visivamente suddivisa da un'altra coppia di bracci quadrati. Diamo un'occhiata al calcio dello sbalordito massiccio dei due mondi. Forse dobbiamo valutare un array bidimensionale con un massimo di 15 elementi. Questo array bidimensionale può avere tre righe e cinque colonne o cinque righe e tre colonne.
// Testa dell'array dvomirny stordito: int a;
- a - il nome di un intero array
- il numero dei primi bracci quadrati indica il numero di righe di una matrice bidimensionale, ciascuna di 5;
- Il numero degli altri bracci quadrati mostra il numero di elementi dell'array bidimensionale, per uno di essi ce ne sono 3.
// inizializzazione di un array bidimensionale: int a = ((4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );
Questa matrice ha 5 righe, 3 colonne. Dopo il segno di assegnazione si pongono al centro degli archi sagomati, al centro dei quali si trovano tante coppie di bracci sagomati quante sono le file di una disposizione bidimensionale, e tali bracci vengono divisi in gruppi. In una coppia di archi sagomati nella pelle, gli elementi della matrice bidimensionale vengono registrati attraverso il coma. Tutti i bracci sagomati presentano una serie di elementi che possono essere combinati. Poiché la matrice ha cinque righe, ci sono anche cinque paia di bracci interni. Gli archi interni hanno tre elementi e alcuni archi hanno tre elementi. Graficamente il nostro array apparirà come una doppia tabella (divisione 5).
Malyunok 5 - Masivi in C++
Nel centro della pelle del massiccio a doppio strato UN viene mostrato il valore, nella casella in basso a destra viene mostrato l'indirizzo dell'azienda. L'indirizzo al centro dell'array bidimensionale è il nome dell'array, il numero di riga e il numero di colonna.
Abbiamo sviluppato un programma molto complicato per l'elaborazione di un massiccio bidimensionale chiamato “Labyrinth”. Il labirinto contiene stimoli basati su una matrice bidimensionale. La dimensione del labirinto sarà scelta a discrezione delle autorità.
// array2.cpp: definisce il punto di ingresso per il programma della console. #include "stdafx.h" #include
// codice Codice::Blocchi
// Codice Dev-C++
// array2.cpp: definisce il punto di ingresso per il programma della console. #includere
Il modo corretto e quello sbagliato potrebbero essere designati con uno o lo stesso numero, ad esempio zero, o, per precisione, il modo corretto dei valori con il numero 2. L'inizializzazione dell'array è stata eseguita manualmente, solo per semplificare il programma. Poiché il programma sta elaborando un array bidimensionale, sono necessari due cicli per passare da un elemento all'altro dell'array bidimensionale. Il primo ciclo for consiste nell'alternare le righe di un array bidimensionale. I frammenti di righe nell'array bidimensionale sono 33, quindi il change-doctor i viene incrementato da 0 a 33, riga 46. A metà del primo ciclo c'è un ciclo for, che alterna gli elementi di una riga di un array bidimensionale. In un altro ciclo for, nel mezzo c'è un'operazione unaria di trasformazione del tipo di dati - static_cast<>() , che è un altro simbolo numerato 176. L'operazione di conversione dei tipi di dati viene duplicata per aumentare la larghezza del labirinto. Il risultato del programma robotico (div. Figura 6).
Malyunok 6 - Masivi in C++
Masiv (Anche Matrice di indici, inode tavolo, riga) - denominare (ordinare) un insieme dello stesso tipo di modifiche (dati), recuperati dalla memoria uno per uno, il cui accesso è soggetto a indice. Nel modo più semplice massiccio Funziona continuamente e salva unità di dati dello stesso tipo.
Indice w masiwu: numero tse Totale, che indica un elemento specifico dell'array
Il numero di indici nell'array da cercare può variare. Vengono chiamati array con un indice unidimensionale, due - bidimensionale eccetera.
Unidimensionale L'array non corrisponde esattamente vettore in matematica, bidimensionale - matrici . Molto spesso il massiccio diventa stagnante uno o altro due si incontrano anche raramente indici, a volte tre, anche più indici.
L'array è descritto come segue:
Il tipo più comune di indice è un intervallo, ad esempio:
Meglio descrivere matrice B, Cosa si sviluppa con 5 elementi e simbolici matrice R, Cosa si sviluppa con 34 elementi. Per Masiwu U Verranno visualizzati 5 * 6 = 30 byte di memoria (poiché sotto il tipo modificabile Vero appare 6 byte di memoria), per l'array R - 1*34=34 byte di memoria (in tipo modificabile Car - 1 byte). Tipo base Gli elementi dell'array possono essere strutturati in qualsiasi modo, ad esempio, o strutturati, ad eccezione del file! Il massiccio può essere espresso su Wikoristanny Vlasny tipo:
Ciclo Può essere definita una sequenza di istruzioni altamente concisa, organizzata in qualche modo (ad esempio, per facilitare la transizione mentale).
Viene chiamato un singolo ciclo del corpo iterazione. Viraz, il che significa che la prossima volta sarai incasinato iterazione, O ciclo fine - tse umova uscita chi la fine del ciclo(Inoltre, è possibile e continuazione intellettuale). Viene richiamata la memoria che salva il numero di riga dell'iterazione iterazione del guaritore il ciclo è semplice medico ciclo. Ciclo non è obbligatorio vendicarsi medico.
I cicli infuriano:
- Ciclo con un medico, in cui l'azione cambia il suo valore rispetto al valore specificato pannocchia valore fino a Kintsevogo significato dell'azione coccodrillo e il valore della pelle del ciclo di cambiamento del corpo viene completato una volta. Implementato dall'operatore per
culo. Salva massiccio:
E così puoi ricordare bidimensionale vettore: 
- Ciclo con ripensamento, che sta concludendo mentre davanti alla sua pannocchia è indicato il vero lavoro della mente. Implementato dall'operatore Mentre.
- Ciclo con postumova In cui la mente viene ricontrollata dopo che il corpo ha terminato il ciclo, e poi il corpo viene ricostituito almeno una volta. In mov Pascal questo ciclo è implementato dall'operatore ripeti... fino a
La prima operazione salta l'iterazione, se nell'iterazione del thread cicloÈ necessario saltare tutti i comandi fino alla fine del ciclo completato. In questo caso non è il ciclo stesso a essere responsabile dell'interruzione, ma piuttosto della continuazione, ma l'output è responsabile del rango iniziale. Implementato dall'operatore Continua.
Inoltre, nei cicli, il comando è spesso vikorizzato uscita pre-stringa dal loop Ad esempio, se, quando il corpo è terminato, il ciclo mostra una pausa, dopo ogni ulteriore lavoro il ciclo non danneggia i sensi. Implementato dall'operatore USCITA o altro rottura.
Passiamo alla pannocchia, o meglio alla pannocchia culo. Dobbiamo capire cosa fare con questo piccolo software:
Venendo da quanto detto, vikorystvovany massiccio dei due mondi UN- questa è la dimensione della matrice N X N. Il ciclo viene vicorizzato con un medico da uno a N, potrebbe essere stato indicato in precedenza.
Metà del ciclo: cambiamento H memorizza i valori di un array bidimensionale con un indice (c:=A), Proprio adesso . Quindi, al posto di questo elemento nell'array, vengono inseriti i valori dell'elemento dello stesso array, nonché con l'indice (A:=A), o quando k:=1 (A:=A). Tobto. gli elementi della prima riga sono inclusi, perché Il primo numero nell'indice indica il numero di riga nella matrice - [ io j), e all'altro per il numero della stazione - . Infine, al posto dell'elemento con l'indice , essere inserito come primo valore dell'elemento dell'array UN con indice , mentre venivamo portati a fine pasto H (A:=c).
E con ogni iterazione del nostro ciclo di significato io aumenta di uno. Semplice per i coccodrilli. Parti ora :
h:=A A:=A A:=c
h:=A A:=A A:=c
h:=A A:=A A:=c
SÌ N volte prima . Tobto. I valori delle diagonali della matrice sono dritti verso destra e verso il basso. IO Gli elementi di questa diagonale cambiano con i valori degli elementi Primo drenaggi della matrice(O K-Quella fila). Quindi, la risposta corretta è: opzione 3: Questo algoritmo cambia posto elementi diagonaliKesima colonna della tabella.
Pascal tratta un array bidimensionale come un array unidimensionale, il cui tipo di elementi è anch'esso un array (un array di array). Le posizioni degli elementi negli array bidimensionali di Pascal sono descritte da due indici. Possono essere presentati sotto forma di tabella o matrice rettangolare.
Diamo un'occhiata all'array bidimensionale di Pascal con dimensioni 3*3, quindi ci saranno tre righe e tre elementi in ciascuna riga:
Un elemento in pelle ha il proprio numero, come negli array a strato singolo, ma il numero è composto anche da due numeri: il numero della riga in cui si trova l'elemento e quel numero viene combinato. In questo modo il numero dell'elemento è indicato dalla traversa della riga e della colonna. Ad esempio, un 21 è un elemento che si trova nell'altra riga e nella prima colonna.
Descrizione dell'array a due mondi di Pascal.
Esistono diversi modi per far esplodere la matrice bidimensionale di Pascal.
Possiamo già descrivere array unidimensionali, i cui elementi possono essere di qualsiasi tipo, e quindi gli elementi stessi possono essere array. Diamo un'occhiata alla seguente descrizione delle tipologie e delle modifiche:
Un esempio di descrizione dell'array a due mondi di PascalTipo
Vettore = array di<тип_элементов>;
Matrice = array di vettori;
Var m: matrice;
Abbiamo chiamato m l'array bidimensionale di Pascal, che consiste di 10 righe, ciascuna con 5 righe. In questo caso, m [i] può essere aggiunto alla i-esima riga della skin e m [i, j] può essere applicato al j-esimo elemento della skin al centro della i-esima riga.
I valori dei tipi per gli array Pascal bidimensionali possono essere specificati in una riga:
Tipo
Matrice = array di array di< тип элементов >;
o ancora più semplice:
tipo
matrice = matrice di<тип элементов>;
L'arrotolamento fino agli elementi di un array bidimensionale appare come: M [i, j]. Ciò significa che vogliamo rimuovere l'elemento aggiunto alla i-esima riga e alla j-esima colonna. Qui non possiamo confondere le file con i piani di lavoro, perché possiamo ridurre ancora una volta la bestia a un elemento inconcepibile. Ad esempio, salendo sull'elemento M è possibile creare la forma corretta dell'immissione oppure è possibile richiamare la richiesta dal programma del robot.
Operazioni di base con gli array bidimensionali di Pascal
Tutto quello che è stato detto riguardo le azioni principali con gli array unidimensionali vale anche per le matrici. L'unica azione che può essere eseguita su matrici dello stesso tipo nel loro insieme è il prezzo. Quindi, quando i programmi descrivono due matrici dello stesso tipo, ad esempio,
tipo
matrice = array di numeri interi;
var
a, b: matrice;
poi durante l'editing del programma è possibile assegnare le matrici UN valori della matrice B(a: = b). Tutte le altre azioni vengono aggiunte elemento per elemento e tutte le operazioni valide possono essere aggiunte agli elementi, come definito per il tipo di questi elementi dell'array. Ciò significa che se un array è costituito da numeri interi, sui suoi elementi è possibile eseguire operazioni destinate a numeri interi, se un array è costituito da simboli, prima di essi è possibile eseguire operazioni destinate a lavorare con i simboli.
Introduzione dell'array a due mondi di Pascal.
Per introdurre in sequenza gli elementi di un array unidimensionale, abbiamo utilizzato un ciclo for, in cui abbiamo modificato i valori dell'indice da 1 al resto. La posizione di un elemento in un array Pascal bidimensionale è indicata da due indici: il numero di riga e il numero di colonna. Ciò significa che dovremo cambiare costantemente il numero della riga da 1 a quello rimanente e nella riga della skin ordinare gli elementi delle righe da 1 a quello rimanente. Ora abbiamo bisogno di due cicli for, uno dei quali annidato nell'altro.
Diamo un'occhiata all'esempio di immissione dell'array bidimensionale di Pascal dalla tastiera:
Esempio di programma per inserire l'array bidimensionale di Pascal dalla tastieratipo
matrice = array di numeri interi;
var
a: matrice;
i, j: intero; (Indice massiccio)
inizio
for i:=da 1 a 5 do (ciclo per scorrere tutte le righe)
readln(a[i, j]); (inserire da tastiera l'elemento che si trova nella i-esima riga e nella j-esima colonna)
Il massiccio dei due mondi di Pascal può essere memorizzato in modo semplice. Utilizzare la funzione casuale (N) e assegnare anche il valore di un particolare virus all'elemento pelle della matrice. Il metodo di riempimento dell'array bidimensionale di Pascal viene scelto in base all'attività da svolgere, ma in ogni caso la colpa è dei valori dell'elemento skin nella riga e nella colonna skin.
Portare sullo schermo la matrice dei due mondi di Pascal.
Anche la derivazione degli elementi dell'array bidimensionale di Pascal procede in sequenza, è necessario allungare gli elementi della riga skin e della colonna skin. Chi vorrebbe che gli elementi, come quelli in fila, andassero mano nella mano, allora. in fila e gli elementi dormienti erano disposti uno dopo l'altro. Per quello che occorre fare, ecco la sequenza delle azioni (guardiamo un frammento del programma per l'array, descritto nell'esempio precedente):
Esempio del programma dei due mondi di Pascalfor i:=da 1 a 5 do (ciclo per scorrere tutte le righe)
inizio
per j:=da 1 a 10 do (ordinamento di tutti gli elementi della riga per traversine)
scrivere(a[i, j]: 4); (gli altri elementi dovrebbero trovarsi nella i-esima riga della matrice in una riga dello schermo, con la quale vengono inserite 4 posizioni per visualizzare l'elemento skin)
scrivere; (Prima modifica il numero di riga nella matrice, devi spostare il cursore all'inizio della nuova riga dello schermo)
FINE;
Rispetto ( È importante!): Molto spesso, i programmi degli studenti riscontrano problemi quando l'input dalla tastiera o dal display sullo schermo viene forzato a verificarsi nel seguente ordine: readln(a), writeln(a), de UN- Questo è importante per il tipo di massiccio. In questo caso, rimangono sorpresi dalle informazioni del compilatore secondo cui è impossibile acquisire o applicare una modifica a questo tipo. Forse capirai perché non puoi guadagnare qualcosa se vedi N kuklov in fila e nelle tue mani, ad esempio, un bollitore d'acqua. Riesci a seguire il comando "versa acqua" e riempire tutti i mucchi in una volta? Se non lo bagnassi, dovresti versare un po' di okramo nella giacca di pelle. Anche il riempimento e la visualizzazione degli elementi dell'array sullo schermo deve essere effettuato in sequenza ed elemento per elemento, perché Nella memoria EOM gli elementi dell'array crescono in sequenze successive.
Un omaggio alla disposizione dei due mondi di Pascal in memoria
Gli elementi dell'array astratto nella memoria della macchina vengono espansi fisicamente in sequenza con la descrizione. In questo caso, l'elemento skin occupa un gran numero di byte in memoria, il che ne indica la dimensione. Ad esempio, se un array è costituito da elementi di tipo intero, ciascun elemento occupa due byte. E l'intero array occupa S 2 byte, dove S è il numero di elementi nell'array.
In quanti posti porterai i massicci, cosa con i massicci, allora. matrice? Ovviamente: S i^S j, dove S i è il numero di righe e S j è il numero di elementi in ciascuna riga. Ad esempio, per il tipo massiccio
Matrice = array di numeri interi;
Sono necessari 12 byte di memoria.
Come possiamo ricordare gli elementi di questo massiccio? Diamo un'occhiata al layout della matrice di tipo M dell'array in memoria.
Sotto l'elemento skin intero di tipo M ci sono due scomparti di memoria. La posizione della memoria è “dal basso verso l’alto”. Gli elementi sono posizionati nell'ordine in cui cambiano gli indici, il che illustra lo schema dei cicli nidificati: la prima riga viene posizionata per prima, poi l'altra, la terza... Al centro della riga, gli elementi vanno in ordine: il primo , l'altro, ecc.
Come sappiamo, l'accesso a qualsiasi modifica è possibile solo inserendo l'indirizzo al centro della memoria in cui è salvata la modifica. Una memoria specifica è visibile per la modifica quando utilizzata dai programmi, in modo che venga stabilita una corrispondenza reciproca tra la memoria modificabile e l'indirizzo del computer. Se abbiamo denominato la modifica come un array, il programma conosce l'indirizzo del cob dell'array, quindi il primo elemento. Come si ottiene l'accesso a tutti gli altri elementi dell'array? Quando effettivamente si accede alla memoria in cui è memorizzato l'elemento bidimensionale dell'array, il sistema ne calcola gli indirizzi utilizzando la formula:
Ind + SizeElem * Cols * (I -1) + SizeElem * (J -1),
de Addr – l'effettivo indirizzo root in cui risiede l'array in memoria; I, J – indici degli elementi in un array bidimensionale; SizeElem – dimensione dell'elemento dell'array (ad esempio, due byte per elementi di tipo intero); Cols – numero di elementi in fila.
Viraz SizeElem * Cols * (I -1) + SizeElem * (J -1) è chiamato lo spostamento del massiccio della pannocchia.
Quanta memoria è disponibile per l'array?
Consideriamo non tanto la quantità di memoria visibile sotto l'array (di cui abbiamo discusso nella sezione precedente), ma la dimensione massima consentita dell'array, che è responsabile della cura della memoria.
Per i programmi robotici, la memoria è vista in segmenti di 64 KB ciascuno e l'ultimo di essi è designato come segmento di dati. L'asse di questo segmento sono gli stessi dati elaborati dal programma. Tuttavia, i programmi che cambiano non possono essere espansi più di una volta in un segmento. Pertanto, poiché è presente una sola modifica nel segmento, viene descritto come un array e non è possibile estrarre più di 65536 byte. Eppure, oltre all'array nel segmento dati, ci saranno descrizioni di altre modifiche, quindi la memoria reale, che può essere vista sotto l'array, si troverà sotto la formula: 65536-S, dove S è il memoria, anche le visioni cambiano.
Che cosa ti serve sapere? Per non essere sorpreso, durante la compilazione, il traduttore visualizzerà una notifica sulla compilazione di un array di vecchia data, se nel programma è presente una descrizione (corretta nella sintassi):
Digitare myArray = array di numeri interi;
Sai già che, utilizzando numeri interi a doppio byte, puoi effettivamente leggere un array con molti elementi, che è uguale a 65536/2 –1=32767. Ed è solo perché non ci saranno altri cambiamenti. Gli array a due mondi di madri colpevoli hanno confini ancora più piccoli tra gli indici.
Applicare problemi di disaccoppiamento da array Pascal bidimensionali.
Zavdannya: Trova il numero di elementi diversi da zero della matrice.
Decisione:
- Per il compito più importante, abbiamo bisogno delle seguenti modifiche: una matrice, che consiste, ad esempio, di interi elementi; P – addizione degli elementi sussunti sotto 0; I, J – indici di array; N, M – numero di righe e colonne nella matrice.
- I dati di input sono N, M: i loro valori vengono immessi dalla tastiera; matrice – l'introduzione della matrice può quindi essere formalizzata come una procedura per riempire la matrice con un ordine speciale. per la funzione aggiuntiva random().
- I dati di output saranno il valore P (solido) modificabile.
- Per verificare la correttezza della visualizzazione del programma, è necessario visualizzare la matrice sullo schermo, per la quale formuleremo la procedura per la visualizzazione della matrice.
- Avanzamento del compito:
Parliamo dell'implementazione iniziale del programma principale, l'implementazione delle procedure verrà discussa poco dopo:
- inserire i valori N e M;
- Introduciamo l'array bidimensionale di Pascal, che va alla procedura vvod (a), dove a è una matrice;
- Creiamo una matrice, per la quale andiamo alla procedura print(a);
- Variazione del valore della pannocchia di Nadamo P = 1;
- Itereremo in sequenza tutte le righe I dalla 1 alla N, per la riga skin itereremo attraverso tutte le colonne J dalla 1 alla M, per l'elemento skin della matrice è verificabile mentalmente: cos'è un ij ? 0, tvir P sarà moltiplicato per l'elemento a ij (P = P * a ij);
- I valori degli elementi aggiuntivi diversi da zero della matrice vengono visualizzati sullo schermo - P;
Parliamo ora delle procedure.
Rispetto (questo è importante!) Un parametro di procedura può essere modificato nel tipo assegnato, il che significa che per passare un array alla procedura come parametro, il suo tipo è soggetto alle descrizioni dietro di esso. Per esempio:
Tipo
Matrice = array di numeri interi;
primer della procedura(a: matrice);
..............................
Passiamo ora alle nostre procedure.
La procedura per inserire una matrice è chiamata parametro vvod della procedura: una matrice e, di conseguenza, viene trasferita al programma principale e il parametro deve essere trasmesso. Quindi l'intestazione della nostra procedura è simile a questa:
Procedura vvod (var m: matrice);
Per implementare i cicli di inserimento della procedura, abbiamo bisogno di cambiavalute locali, ad esempio k e h. L'algoritmo per riempire la matrice è già stato discusso, quindi non lo ripeteremo.
La procedura per visualizzare una matrice sullo schermo si chiama stampa, il parametro della procedura è la matrice, e in questo caso insieme ai valori viene passato anche il parametro di input. Il titolo di questa procedura sarà simile al seguente:
Procedura print(m: matrice);
E ancora, per l'implementazione dei cicli di investimento nel mezzo della procedura, avremo bisogno dei medici, lascia che siano chiamati così: k e h. L'algoritmo per la visualizzazione della matrice sullo schermo è stato descritto più velocemente in questa descrizione.
Il punto focale del programma dei due mondi di PascalProgramma prodotto;
Tipo
Matrice = array di numeri interi;
Var
A: matrice;
N, m, i, j: byte;
P: intero;
Procedura vvod (var m: matrice);
Var k, h: byte;
Inizio
Per i:=1 to n do (cambia n per la procedura, che è globale e anche “visibile”)
Per j:=1 to m do (la modifica m per la procedura è globale, che significa “visibile”)
M:= casuale(10);
FINE;
Procedura print(m: matrice);
Var k, h: byte;
Inizio
Per i:=1 an fare
inizio
Per j:=1 a m fai
Scrivi(M:4);
Scrivi;
FINE;
FINE;
Begin (inizio del programma principale)
Writeln("Inserisci la dimensione della matrice:");
Leggiln(N, M);
Vvod(a);
Stampa(a);
P:=1;
Per i:=1 a N fai
Per j:=1 a M fai
Se un<>0 allora p:=p*a;
Scriviln(p);
FINE.
