Számjegyek feldolgozása

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 (vegyük a 253-at és próbáljuk ismételten osztani 10-zel):

    253 % 10 == 3   (utolsó számjegy)
    253 / 10 == 25  (a többi számjegyet tartalmazó szám)

    25 % 10 == 5
    25 / 10 == 2

    2 % 10 == 2
    2 / 10 == 0

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
17

#include <iostream>
using namespace std;

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

    do {
        int utolso = n % 10;
        cout << utolso << endl;

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

    return 0;
}

VAGY (while-lal és külön kezelve a 0-t):

 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;

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

    while (n > 0) {
        int utolso = n % 10;
        cout << utolso << 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

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

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

    while (p >= 1) {

        int szj = (n / p) % 10;
        cout << szj << endl;

        p = p / 10;
    }

    return 0;
}

HF. Kövessük nyomon mindkét algoritmust a következőkre: 0, 7, 54, 981.

Feladatok

0. (HF) 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
19
20
21
22

#include <iostream>
using namespace std;

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

    int hany = 0;

    do {
        int utolso = n % 10;

        hany++;

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

    cout << hany << endl;

    return 0;
}

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

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

    do {
        int utolso = n % 10;

        osszeg = osszeg + utolso;

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

    cout << osszeg << endl;

    return 0;
}

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

#include <iostream>
using namespace std;

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

    int osszeg = 0;
    int hany = 0;

    do {
        int utolso = n % 10;

        if (utolso % 2 == 1) {
            osszeg = osszeg + utolso;
            hany++;
        }

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

    cout << (double)osszeg / hany << 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

Ötletek:

    n    | 5  |   |   |
    -----+----+---+---+-----
    szj  |    | 1 | 3 | 2   4     0
    -----+----+---+---+-----
    szam | 0  | 1 | 13| 132 1324  13240


    132 * 10 + 4 = 1324
    szam <- szam * 10 + szj

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

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

        szam = szam * 10 + szj;
    }

    cout << szam << endl;
    cout << 2*szam << 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

Ötletek:

    n    | 5
    -----+---+---+---+-----+------+-------
    szj  |   | 3 | 1 | 2   | 4    | 1
    -----+---+---+---+-----+------+-------
    szam | 0 | 3 | 13| 213 | 4213 | 14213


    13 + 2 * 100 = 213
    213 + 4 * 1000 = 4213

    szam <- szam + szj * tizhatvany
    tizhatvany <- tizhatvany * 10

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

#include <iostream>
using namespace std;

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

    int szam = 0;
    int p = 1;

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

        szam = szam + szj * p;
        p = p * 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 szam = 0;

    do {
        int ut = n % 10;

        szam = szam * 10 + ut;

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

    cout << szam << 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
26
27

#include <iostream>
using namespace std;

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

    int szam = 0;

    int hatvany = 1;

    do {
        int ut = n % 10;

        if (ut % 2 != 0) {
            szam = szam + ut * hatvany;
            hatvany = hatvany * 10;
        }

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

    cout << szam << endl;

    return 0;
}

3. Csak páratlan számjegyek és fordítva

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

    Pl.
        123 -> 31
        245 -> 5
        200 -> 0
        0 -> 0
        3 -> 3
        135 -> 531

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

#include <iostream>
using namespace std;

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

    int szam = 0;

    do {
        int ut = n % 10;

        if (ut % 2 != 0) {
            szam = szam * 10 + ut;
        }

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

    cout << szam << endl;

    return 0;
}

4. Páros számjegyek megduplázva

Adott természetes szám esetén építsük fel azt a számot, ami ennek a páros számjegyeit megduplázva tartalmazza (a páratlanokat pedig csak egyszer) eredeti sorrendben.

    Pl.
        123 -> 1223
        245 -> 22445
        200 -> 220000
        0 -> 0
        2 -> 22
        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
26
27
28
29
30

#include <iostream>
using namespace std;

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

    int szam = 0;

    int hatvany = 1;

    do {
        int ut = n % 10;

        szam = szam + ut * hatvany;
        hatvany = hatvany * 10;

        if (ut % 2 == 0) {
            szam = szam + ut * hatvany;
            hatvany = hatvany * 10;
        }

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

    cout << szam << endl;

    return 0;
}

5.

https://www.pbinfo.ro/probleme/65/produscifreimpare
Meg kell határozni egy beolvasott szám páratlan számjegyeinek szorzatá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
28
29
30

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    
    int szorzat = 1;
    int db = 0;
    
    do
    {
        int szj = n % 10;
        
        if (szj % 2 == 1) {
            szorzat = szorzat * szj;
            db++;
        }
        
        n = n / 10;
    } while (n > 0);
    
    if (db >= 1)
        cout << szorzat << endl;
    else 
        cout << -1;
    
    return 0;
}

6.

https://www.pbinfo.ro/probleme/3979/suma37
Meg kell határozni egy természetes szám azon számjegyeinek összegét, amik 3-nál nagyobb vagy egyenlőek és 7-nél kisebb vagy egyenlőek.

7.

https://www.pbinfo.ro/probleme/4570/numaruldecifre1
Adott természetes szám páros és páratlan számjegyeinek darabszámát kell meghatározni.

 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 paros = 0;
    int paratlan = 0;
    
    do {
        int ut = n % 10;
        
        if (ut%2==0) {
            paros++;
        }
        else {
            paratlan++;
        }
        
        n = n / 10;
    } while(n > 0);

    cout << paros << " " << paratlan;
    return 0;
}

8.

https://www.pbinfo.ro/probleme/4933/numarnou0
Adott n esetén állítsuk elő és írjuk ki azt a számot, amit n-ből úgy kapunk, hogy minden páros számjegyét nullára cseréljük.

9.

https://www.pbinfo.ro/probleme/3077/suma-prefixe
Számoljuk ki adott n szám összes előtagjának (prefixének) összegét (ld. a példában).

Példák:

    128 -> 1 + 12 + 128

        n:    128     12    1    0

        n%10: 8       2     1
        n/10: 12      1     0



    573 -> 5 + 57 + 573

        n:    573     57    5    0

        n%10: 3       7     5
        n/10: 57      5     0


    10200 -> 1 + 10 + 102 +1020 + 10200

    7 -> 7

    15 -> 1 + 15

 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;

    long long osszeg = 0;

    do{
        osszeg = osszeg + n;
        n = n / 10;
    } while (n > 0);
    
    cout<< osszeg << endl;
    return 0;
}

Ugyanaz while-lal:

 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;

    long long osszeg = 0;

    while (n > 0) {
        osszeg = osszeg + n;
        n = n / 10;
    }
    
    cout<< osszeg << endl;
    return 0;
}