Kétdimenziós tömbök (mátrixok)

Értelmezés:

Valahány sorból és valahány oszlopból álló táblázatok azonos típusú elemekből.

Deklaráció (bejelentés):

    alaptípus név[sorok száma][oszlopok száma];

Példa:

    int m[100][20];  // 100*20 * 4B memória

A háttérben a mátrixnak annyi memória lesz fenntartva ahány eleme van (sorok száma x oszlopok száma) megszorozva egy elem méretével. A sorok pedig egymás után tárolódnak (és soron belül az elemek is).

Gondolhatunk a mátrixra tömbök tömbjeként (pl. m egy százelemű tömb, amiben 20 elemű tömbök vannak).

Használata / indexelés:

    név[i][j], ahol
        i a sorindex (0 <= i < sorok száma)
        j az oszlopindex (0 <= j < oszlopok száma)

Példa:

    int m[100][20];

esetén:
    bal felső sarok:  m[0][0]
    jobb felső sarok: m[0][19]
    bal alsó sarok:   m[99][0]
    jobb alsó sarok:  m[99][19]

Általában ha m egy r soros és c oszlopos mátrix (int m[r][c]), akkor az elemei:

                        j indexű oszlop
                               |
                               V
    m[0][0]   m[0][1]  ...  m[0][j]  ...  m[0][c-1]
    m[1][0]   m[1][1]  ...  m[1][j]  ...  m[1][c-1]
    ..........................................
    m[i][0]   m[i][1]  ...  m[i][j]  ...  m[i][c-1]  <- i indexű sor
    .......................................... 
    m[r-1][0] m[r-1][1] ... m[r-1][j] ... m[r-1][c-1]

Megjegyzés: a sorok és oszlopok száma egy mátrix bejelentésekor konstans érték kell legyen (mint tömböknél)

Mátrixok inicializálása:

 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
#include <iostream>
using namespace std;

int main()
{
    // sima tömböknél (egydimenziós)
    int t1[100]; // nincs inicializálva (memóriaszemét)
    int t2[100] = {1,2,3}; // inicializálva van:
                           // 1 2 3 0 0 0 ... 0
    int t3[100] = {}; // 0 0 0 ... 0
    int t4[] = {1,2,3,4}; // 4 elemű lesz a tömb

    // mátrixoknál:

    int m1[3][2] = { {1,2}, {3,4}, {5,6} };
        /*
            1 2
            3 4
            5 6
        */

    int m2[3][2] = { {1}, {2,3} };
        /*          ami nincs megadva az nulla lesz
            1 0
            2 3
            0 0
        */

    int m3[5][4] = {}; // minden eleme 0

    int m4[5][4];  // memóriaszemét


    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 4; j++)
            cout << m4[i][j] << " ";
        cout << endl;
    }

    return 0;
}

Feladat

Az input.txt fájlban adottak az n és m természetes számok (1 <= n, m <= 100), majd n x m darab egész, melyek egy kétdimenziós tömb elemei.

Olvassuk be és tároljuk, majd írjuk ki:

az egész tömböt
az elemek összegét
az elemek összegét soronként (n darab érték)
az elemek összegét oszloponként (m darab érték)

Példa

    bemenet:
        4 5
        1 2 3 4 5
        0 2 0 6 8
        1 3 2 6 4
        7 9 0 2 3

    kimenet:
        1 2 3 4 5
        0 2 0 6 8
        1 3 2 6 4
        7 9 0 2 3

        68
        15 16 16 21
        9 16 5 18 20

 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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ifstream bemenet("input.txt");

    int n, m;
    int t[100][100];

    bemenet >> n >> m;

    // beolvasás
    for (int i = 0; i < n; i++){ // i<n <=> i <= n-1
        for (int j = 0; j < m; j++){
            bemenet >> t[i][j];
        }
    }

    // a) kiírás
    for (int i = 0; i < n; i++){ // i<n <=> i <= n-1
        for (int j = 0; j < m; j++){
            cout << t[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;

    // b)
    int osszeg=0;
    for(int i = 0; i < n; i++){
        for (int j = 0; j < m; j++){
            osszeg+= t[i][j];
        }
    }
    cout <<osszeg<<endl;

    // c) összeg soronként
    for(int i = 0; i < n; i++){
        int osszeg_c = 0;
        for (int j = 0; j < m; j++){
            osszeg_c+= t[i][j];
        }
        cout <<osszeg_c<< " ";
    }
    cout << endl;
    
    /* VAGY:
    int osszeg_c=0;
    for(int i = 0; i < n; i++){
        for (int j = 0; j < m; j++){
            osszeg_c+= t[i][j];
        }
        cout <<osszeg_c<< " ";
        osszeg_c = 0;
    }
    cout << endl;
    */

    // d) felcseréljük a két for-t
    for (int j = 0; j < m; j++){
        int osszeg_d = 0;
        for(int i = 0; i < n; i++)
        {
            osszeg_d+= t[i][j];
        }
        cout <<osszeg_d<< " ";
    }
    cout << endl;

    return 0;
}