Számjegyes feladatok

Számok számjegyekre bontása

Adott természetes szám számjegyeit szeretnénk külön-külön feldolgozni (pl. kiírni, megszámolni, megszámolni a párosakat stb.).

Kérdés: hogy kapjuk meg a számjegyeket külön-külön?

Példa:

    253 -> {2, 3, 5}

Feladat: adott egy term szám, írjuk ki a számjegyeit (tetszőleges sorrendben) külön sorokba!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <iostream>
using namespace std;

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

    do {
        int szj = n % 10;
        cout << szj << endl;
        n = n / 10;
    } while (n > 0);

    return 0;
}

Megjegyzés: jobbról balra haladva kapjuk így meg a számjegyeket.

Meg lehet írni while-lal is, de akkor a nullát külön kell kezelni (másképp egy számjegy sem íródna ki):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>
using namespace std;

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

    if (n == 0)
        cout << 0 << endl;

    while (n > 0) {
        int szj = n % 10;

        cout << szj << endl;

        n = n / 10;
    }

    return 0;
}

Szám számjegyeinek meghatározása eredeti sorrendben

Feladat: adott szám számjegyeit írjuk ki külön sorokba eredeti sorrendben.

Példa:

    be: 253
    ki: 2
        5
        3

Ötlet: osztjuk a számot egyre kisebb tízhatványokkal és a hányados utolsó számjegyét figyeljük:

 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

#include <iostream>
using namespace std;

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

    int db = 0;

    int masolat = n;
    do {
        db++;
        masolat = masolat / 10;
    } while (masolat > 0);

    //cout << db << endl;

    // kiszámoljuk pow(10, db-1);
    int hatvany = 1;
    for (int i = 1; i <= db-1; i++)
        hatvany = hatvany * 10;

    //cout << hatvany << endl;

    while (hatvany > 0) {
        cout << (n / hatvany) % 10 << endl;
        hatvany = hatvany / 10;
    }

    return 0;
}

Egyszerűbben ugyanezt? Egyből felépíthetjük a szükséges tízhatványt.

 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 hatvany = 1;

    while (hatvany*10 <= n)
        hatvany = hatvany*10;

    while (hatvany > 0) {
        cout << (n / hatvany) % 10 << endl;
        hatvany = hatvany / 10;
    }

    return 0;
}

Feladatok

0. Adott termászetes szám esetén írjuk ki, hogy hány számjegye van!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <iostream>
using namespace std;

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

    int db = 0;

    do {
        db++;
        n = n / 10;
    } while (n > 0);

    cout << db << endl;
    return 0;
}

1. Adott természetes szám esetén számítsuk ki a számjegyeinek az összegét.

HF!

2. Adott természetes szám esetén számítsuk ki a páratlan számjegyeinek az átlagát.

 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

#include <iostream>
using namespace std;

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

    int osszeg = 0;
    int db = 0;

    do {
        int szj = n % 10;

        if (szj % 2 != 0) {
            // sum it up
            osszeg = szj + osszeg;
            db++;
        }

        n = n / 10;
    } while (n > 0);

    cout << (double) osszeg / db << endl;

    return 0;
}

Szám építése számjegyekből

1. eredeti sorrendben:

Adott n, majd n darab számjegy. Építsük fel azt a számot, ami ezeket a számjegyeket tartalmazza eredeti sorrendben. Írjuk ki a számot és a kétszeresét is!

Pl. bemenet:
        5
        1 3 2 4 0
    kimenet:
        13240
        26480

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
using namespace std;

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

    int eredmeny = 0;

    for (int i = 1; i <= n; i++) {
        int szj;
        cin >> szj;

        eredmeny = eredmeny*10 + szj;
    }

    cout << eredmeny << endl;
    cout << 2*eredmeny << endl;

    return 0;
}

2. fordított sorrendben:

Adott n, majd n darab számjegy. Építsük fel azt a számot, ami ezeket a számjegyeket tartalmazza fordított sorrendben. Írjuk ki a számot és a kétszeresét is!

Pl. bemenet:
        5
        3 1 2 4 1
    kimenet:
        14213
        28426

Ötlet: egyre nagyobb tízhatványokkal szorozzuk az új számjegyeket.

    3
    3 + 1*10 = 13
    13 + 2*100 = 213
    213 + 4*1000 = 4213
    4213 + 1*10000 = 14213

 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 szam = 0;
    int hatvany = 1;

    for (int i = 1; i <= n; i++) {
        int szj;
        cin >> szj;

        szam = szam + szj * hatvany;
        hatvany *= 10;
    }

    cout << szam << endl;
    cout << 2*szam << endl;
    return 0;
}

Feladatok:

1. Szám tükrözése

Adott egy szám, állítsuk elő a tükörképét! (Vagyis azt a számot, ami ugyanazokat a szj-eket tartalmazza fordított sorrendben).

    Pl.
        123  -> 321
        1042 -> 2401
        0 -> 0
        100 -> 1

    Ötlet:
        tukorkep <- 0

        123  --szj-re bontás-> 3 kör:
            szj = 3
                tukorkep <- 3
            szj = 2
                tukorkep <- 32
            szj = 1
                tukorkep <- 321

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
using namespace std;

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

    int tukorkep = 0;

    do {
        int szj = n % 10;

        tukorkep = tukorkep*10 + szj;

        n = n / 10;
    } while (n > 0);


    cout << tukorkep << endl;
    return 0;
}

2. Páros számjegyek törlése egy számból

Adott egy szám, azt a számot, ami az eredeti számnak csak a páratlan számjegyeit tartalmazza (eredeti sorrendben).

    Pl.
        123 -> 13
        245 -> 5
        200 -> 0
        0 -> 0
        3 -> 3
        135 -> 135

 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 eredmeny = 0;
    int p = 1;

    do {
        int szj = n%10;

        if (szj % 2 != 0) {
            eredmeny = eredmeny + szj * p;
            p *= 10;
        }

        n = n / 10;
    } while (n > 0);

    cout << eredmeny << endl;
    return 0;
}

Vagy balról lebontva a számot:

 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 eredmeny = 0;

    int hatvany = 1;
    while (hatvany*10 <= n)
        hatvany = hatvany*10;

    while (hatvany > 0) {
        int szj = (n / hatvany) % 10;

        if(szj % 2 == 1)
            eredmeny = eredmeny*10 + szj;

        hatvany = hatvany / 10;
    }

    cout << eredmeny << endl;

    // HF: nyomonkövetni n = 3478-ra
    return 0;
}

3.

Adott egy természetes szám.

  1. Mennyi a legnagyobb számjegye?
  2. Melyik helyiértéken van a legnagyobb számjegye? (Írjuk ki a neki megfelelő 10-hatványt, holtverseny esetén a legkisebb hatványt.)
  3. Cseréljük le a legnagyobb számjegyet 1-esre és írjuk ki az új számot! (holtverseny esetén az utolsó előfordulását)
  4. Adjuk meg azt a számot, amiből ez a számjegy hiányzik! (tehát a legnagyobb számjegy utolsó előfordulása)

Példák

    152  -> 5 10 112 12
    8058 -> 8 1 8051 805
    987  -> 9 100 187 87
    5    -> 5 1 1 0
    0    -> 0 1 1 0

4. (+pont)

https://www.pbinfo.ro/probleme/4870/banal