Tömbök

azonos típusú elemeket tárol egymás mellett a memóriában
szerkezet, deklaráció:

    alaptípus név[kapacitás];
                    ^^^ konstans érték

Példák

    int t[100];
        // lefoglal 100 x 4 bájtos

    double t2[20];

Elemek elérése (indexelés):

a tömb elemei sorszámozva vannak 0-tól (kapacitás-1)-ig
[index] használatával érünk el egy-egy elemet

Példák:

    int t[10];

    // t[0]  t[1]  t[2] ... t[9]

    t[0] = 23; // beállítja az első  elem értékét

    int x = t[0]; // lemásolja az első elemet

    t[9] = 5; // beállítja az utolsó (9-es indexű) elemet

Sorozat beolvasása tömbbe

Adott egy n hosszú sorozat egész számokból (n < 1000). Olvassuk be egy tömbbe, majd írjuk ki!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    
    int t[1000];

    // n elem: t[0], t[1], ..., t[n-1]
    for (int i = 0; i < n; i++) {
        cin >> t[i];
    }

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

    return 0;
}

Feladat: írjuk ki egy sorozat elemeit fordított sorrendben!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    
    int t[1000];
    for (int i = 0; i < n; i++) {
        cin >> t[i];
    }

    for (int i = n-1; i >= 0; i--) {
        cout << t[i] << " ";
    }
    cout << endl;

    return 0;
}

Tömbök inicializálása

“inicializálás” jelentése: kezdőérték(ek) beállítá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
#include <iostream>
using namespace std;

int main()
{
    int t[100];
        // nincs inicializálva
        // (nem tudjuk az elemek kezdőértékét)

    int a[5] = {2, 6, 3, 4, 5};
        // minden elemnek megadtuk a
        // kezdőértékét
        // t[0] == 2, t[1] == 6,
        // t[2] == 3, t[3] == 4
        // t[4] == 5

    int b[100] = {10,20,30};
        // az első három elem 10, 20, 30
        // a többi nulla

    int c[50] = {};
        // mind az 50 eleme 0

    return 0;
}

Indexelés 1-től

bár a nyelvben nincs ilyen, de megtehetjük, hogy nem használjuk a 0 indexű elemet, ekkor viszont 1-gyel nagyobbra kell méretezni a tömböt.

Példa: ha 100 elemet akarunk t[1]-től t[100]-ig, akkor a t legalább 101 méretű kell legyen

    int t[101];
    for (int i = 1; i <= 100; i++)
        t[i] = 2*i;

Feladatok:

1. (HF) https://www.pbinfo.ro/probleme/546/afisare0
Ki kell írni egy sorozat azon elemeit, melyek többszörösei az utolsónak.

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

int main()
{
    int n;
    cin >> n;

    int t[1000];

    // n elem: t[0], t[1], ..., t[n-1]
    for (int i = 0; i < n; i++) {
        cin >> t[i];
    }

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

    return 0;
}

2. Adott egy n elemű sorozat. Mennyi az első és utolsó páros elem között található elemek összege.

Példa:

    1 2 3 4 5 6   esetén a válasz 12 (3+4+5)

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

int main()
{
    int n;
    cin >> n;

    int t[1000];

    for (int i = 0; i < n; i++) {
        cin >> t[i];
    }

    int poz_elso = -1;
    int poz_utolso;

    for (int i = 0; i < n; i++) {
        if (t[i] % 2 == 0) {
            if (poz_elso == -1) {
                poz_elso = i;
            }
            poz_utolso = i;
        }
    }

    int s = 0;
    for (int i = poz_elso+1; i <= poz_utolso-1; i++)
    {
        s = s + t[i];
    }

    cout << s << endl;

    return 0;
}

3. Adott n elemű sorozat (n < 100). Minden elem esetén írjuk ki, hogy hány nála kisebb elem található a sorozatban.

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

int main()
{
    int n;
    cin >> n;

    int t[1000];

    for (int i = 0; i < n; i++) {
        cin >> t[i];
    }

    for (int i = 0; i < n; i++) {
        cout << t[i] << ": ";

        int db = 0;
        for (int j = 0; j < n; j++) {
            if (t[j] < t[i])
                db++;
        }

        cout << db << " darab" <<endl;
    }

    return 0;
}

4. (HF) Adott egy n elemű tömb. Írjuk ki a páros indexen levő elemeket az indexek növekvő sorrendjében, majd a páratlan indexen levő elemeket az indexek csökkenő sorrendjében! Az elemek 1-től sorszámozottak.
https://www.pbinfo.ro/probleme/488/afisare

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

int main()
{
    int n;
    cin >> n;

    int t[1001];

    for (int i = 1; i <= n; i++) {
        cin >> t[i];
    }

    for (int i = 2; i <= n; i+=2)
        cout << t[i] << " ";
    cout << endl;

    int utolso = n;
    if (utolso % 2 == 0)
        utolso--;

    for (int i = utolso; i >= 1; i-=2)
        cout << t[i] << " ";
    cout << endl;

    return 0;
}

5. (HF) Adott egy n elemű különböző értékeket tartalmazó tömb. Meg kell határozni a legkisebb és legnagyobb elem (1-től sorszámozott) indexét.
https://www.pbinfo.ro/probleme/553/pozminmax

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

int main()
{
    int n;
    cin >> n;

    int t[1001];

    for (int i = 1; i <= n; i++) {
        cin >> t[i];
    }

    int minimum = t[1];
    int minimum_helye = 1;

    int maximum = t[1];
    int maximum_helye = 1;

    for (int i = 1; i <= n; i++) {
        if (t[i] < minimum) {
            minimum = t[i];
            minimum_helye = i;
        }

        if (t[i] > maximum) {
            maximum = t[i];
            maximum_helye = i;
        }
    }

    cout << minimum_helye << " " << maximum_helye << endl;

    return 0;
}

6. Adott egy n elemű tömb. Meg kell határozni, hogy hány olyan eleme van, amely egyenlő a legnagyobb és legkisebb érték közötti különbséggel.
https://www.pbinfo.ro/probleme/547/numarare6

7. (+pont) Adott egy n elemű tömb. Meg kell határozni, hogy hány olyan elempár alkotható az elemeiből, amelynek mindkét tagjában ugyanaz a tízesek számjegye.
https://www.pbinfo.ro/probleme/4380/numarareperechi1

8. (+pont) Adott n elemű sorozat. Gyűjtsük össze egy új tömbbe azokat az elemeket, amelyek prímek, majd írjuk ki ezeket a megjelenésük fordított sorrendjében.