While - feladatok

Készítsünk felhasználói fiókot a pbinfo.ro oldalon. Itt programozás feladatok vannak, melyek megoldását ha beküldjük, a rendszer lefuttatja különböző bemenetekre és ellenőrzi, hogy jó-e a kimenetünk.

(HF) Próba-feladat: https://www.pbinfo.ro/probleme/939/sum00
Két számot kell beolvasni és az összegüket kiírni.

Feladatok pbinfo-ról:

1.

https://www.pbinfo.ro/probleme/3984/afisare-m2
Beolvassuk az a és b természetes számokat, ki kell írni az első b darab pozitív többszörösét a-nak.

 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 a,b;
    cin >> a >> b;

    int i = 1;

    while (i <= b) {
        cout << i*a << " ";
        i = i + 1;
    }

    cout << endl;
    return 0;
}

Más megoldás:

 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 a,b;
    cin >> a >> b;

    int i = a;

    while (i <= b*a) {
        cout << i << " ";
        i = i + a;
    }

    cout << endl;
    return 0;
}

2.

https://www.pbinfo.ro/probleme/330/afisarenumerepare
Beolvasunk egy n-t, ki kell írni az első n darab nem nulla páros számot.

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

    while (i <= n) {
        cout << i*2 << " ";
        i = i + 1;
    }

    cout << endl;
    return 0;
}

3.

https://www.pbinfo.ro/probleme/1362/p10
Adott n, ki kell írni 10n-t (nem kell kiszámolni, mert ahhoz túl nagy).

 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;

    cout << 1;

    int i = 1;

    while (i <= n) {
        cout << 0;
        i = i + 1;
    }

    cout << endl;
    return 0;
}

4.

https://www.pbinfo.ro/probleme/348/afisareputeri
Adott n és p esetén ki kell írni az n szám p-nél kisebb vagy egyenlő hatványait.

 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, p;
    cin >> n >> p;

    int szam = 1;

    while (szam <= p) {
        cout << szam << " ";
        szam = szam * n;
    }

    cout << endl;
    return 0;
}

5.

https://www.pbinfo.ro/probleme/4294/perechin
Adott n esetén ki kell írni az összes olyan x y számpárt, melyre x + y = n és 0 < x ≤ y.

 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;

    int x = 1;

    while (x <= n-x) {
        cout << x << " " << n-x << endl;
        x = x + 1;
     }

    return 0;
}

Ciklusok egymásban

6.

Adott n esetén írjuk ki az n értéket n x n-szer! Például n = 5-re a kimenet:

    5 5 5 5 5
    5 5 5 5 5
    5 5 5 5 5
    5 5 5 5 5
    5 5 5 5 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

#include <iostream>
using namespace std;

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

    int j = 1;
    while (j <= n) {
        // kiírunk egy sort:
        int i = 1;
        while (i <= n) {

            //cout << n << " ";
            cout << i << " ";

            i = i + 1;
        }
        cout << endl;

        j = j + 1;
    }

    return 0;
}

7.

https://www.pbinfo.ro/probleme/351/piramida
Adott n-re ki kell írni a leírásban látható háromszöget.

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

    while (i <= n) {

        // 1 2 ... i
        int j = 1;
        while (j <= i) {
            cout << j << " ";
            j = j + 1;
        }
        cout << endl;

        i = i + 1;
    }

    return 0;
}

8.

https://www.pbinfo.ro/probleme/1630/morisca
Adott n-re el kell készíteni az ábrán látható rajzot (kiírásokkal).

HF (opcionális)

Összegek, szorzatok kiszámítása

Példa összeg kiszámítására: adott n-re meghatározzuk az első n darab pozitív egész szám összegét:

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

#include <iostream>
using namespace std;

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

    int osszeg = 0;

    int i = 1;
    while (i <= n) {
        osszeg = osszeg + i;
        i = i + 1;
    }

    cout << osszeg << endl;
    return 0;
}

9.

Adott n ≥ 3 esetén írjuk ki az 1*2*3 + 2*3*4 + ... + (n-2)*(n-1)*n összeg értékét! Ha n < 3, akkor írjunk ki egy hibaüzenetet!

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

    if (n < 3) {
        cout << "tul kicsi n..." << endl;
    }
    else {
        int i = 1;
        while (i <= n-2) {
            osszeg = osszeg + i*(i+1)*(i+2);
            i = i + 1;
        }

        cout << osszeg << endl;
    }
    return 0;
}

Képlettel:

    S = sum(i*(i+1)(i+2),  i = 1, ... , n-2)
      = sum(i^3 + 3i^2 + 2*i,   ....)
      = (n-2)^2(n-1)^2/4
        + 3 * (n-2)(n-1)(2n-3)/6
        + 2 * (n-1)(n-1)/2

      = 1/4*(n-2)*(n-1) * (

            (n-2)(n-1) + 2*(2n-3) + 4

        )

      = 1/4*(n-2)*(n-1) * (n^2 + n)
      = 1/4*(n-2)*(n-1)*n*(n+1)

10.

Adott n esetén számítsuk ki az első n darab teljes köb összegét! Például n = 3-ra a kimenet 36 (mert 13 + 23 + 33 = 36).

 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;

    int osszeg = 0;

    int i = 1;
    while (i <= n) {
        osszeg = osszeg + i*i*i;
        i = i + 1;
    }

    cout << osszeg << endl;

    cout << n*(n+1)*n*(n+1)/4;
    return 0;
}

11.

Számítsuk ki az n-nél kisebb négyzetszámok öszegét! Például: n = 20 esetén a válasz legyen 30 (0 + 1 + 4 + 9 + 16).

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

    int i = 1;
    while (i*i < n) {
        osszeg = osszeg + i*i;
        i = i + 1;
    }

    cout << osszeg << endl;

    return 0;
}

12.

Számítsuk ki adott n pozitív egész faktoriálisát (n! = 1 * 2 * ... * n). Például n = 5 esetén a válasz legyen 120 (1*2*3*4*5).

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

#include <iostream>
using namespace std;

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

    int szorzat = 1;

    int i = 1;
    while (i <= n) {
        szorzat = szorzat * i;
        i = i + 1;
    }

    cout << szorzat << endl;
    return 0;
}

13.

Adott n esetén számítsuk ki az első n darab pozitív egész faktoriálisának összegét! Például n = 4 esetén a válasz legyen 33 (1+2+6+24).

 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

#include <iostream>
using namespace std;

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

    int osszeg = 0;

    int i = 1;
    while (i <= n) {

        // kiszámítjuk az i faktoriálisát
        int faktorialis = 1;

        int j = 1;
        while (j <= i) {
            faktorialis *= j;
            j++;
        }

        osszeg = osszeg + faktorialis;
        i++;
    }

    cout << osszeg << endl;
    return 0;
}

Ötlet: megjegyezzük az előző faktoriálist és abból számoljuk ki az újat egyetlen szorzással.

 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;
    int faktorialis = 1;

    int i = 1;
    while (i <= n) {
        faktorialis *= i;

        osszeg = osszeg + faktorialis;
        i++;
    }

    cout << osszeg << endl;
    return 0;
}

14. (+0.5 pont)

Adott az n természetes szám. Írjuk ki a valódi osztóinak összegét és a legnagyobb valódi osztóját (ha van).

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

    int i = 2;
    while (i <= n-1) {

        if (n % i == 0) {
            osszeg += i;
            utolso = i;
        }

        i++;
    }

    cout << "osszeg: " << osszeg << endl;
    if (utolso == -1)
        cout << "nincs valodi oszto" << endl;
    else
        cout << "a legnagyobb: " << utolso << endl;

    return 0;
}

15. (+1 pont)

Adott egy páratlan n érték. Készítsük egy n x n méretű ábrát, amin egy, az alábbihoz hasonló rombusz látható (a legtöbb #-et tartalmazó soron n darab kell legyen ebből).

Pl. n = 7 esetén:

       #
      ###
     #####
    #######
     #####
      ###
       #

Pl. n = 15 esetén:

           #
          ###
         #####
        #######
       #########
      ###########
     #############
    ###############
     #############
      ###########
       #########
        #######
         #####
          ###
           #