Szatmár megye, 2026. január 21.

Megoldások

III.1.

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

void kradical(int x[], int n, int k,
              long long&p, long long &q)
{
    int f[8] = {};

    for (int i = 0; i < n; i++) {
        int elem = x[i];

        int d = 2;
        while (elem > 1) {
            while (elem % d == 0) {
                elem /= d;
                f[d]++;
            }
            d++;
        }
    }

    p = 1;
    q = 1;

    for (int i = 2; i <= 7; i++) {
        int pben = f[i]/k;
        int qban = f[i]%k;

        for (int j = 1; j <= pben; j++)
            p = p * i;

        for (int j = 1; j <= qban; j++)
            q = q * i;
    }
}


int main()
{
    int x[100] = {2,5,8,9,6};
    int n = 5;
    int k = 3;

    long long p, q;

    kradical(x, n, k, p, q);

    cout << p << " " << q << endl;
    return 0;
}

III.2.

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

int main()
{
    char s[201];
    cin.getline(s, 201);

    char s2[201];
    strcpy(s2, s);

    int maximum = -1;

    char *p = strtok(s, " ");
    while (p != NULL) {

        int hossz = strlen(p);
        if (hossz > maximum)
            maximum = hossz;


        p = strtok(NULL, " ");
    }

    //cout << maximum << endl;

    char eredmeny[202] = "";

    p = strtok(s2, " ");
    while (p != NULL) {

        if (strlen(p) == maximum) {
            int i = 0;
            while (p[i] != '\0') {
                if (strchr("aeiou", p[i]) != NULL) {
                    for (int j = i; p[j] != '\0'; j++)
                        p[j] = p[j+1];
                }
                else {
                    i++;
                }
            }
        }

        strcat(eredmeny, p);
        strcat(eredmeny, " ");

        p = strtok(NULL, " ");
    }

    eredmeny[strlen(eredmeny)-1] = '\0';
    strcpy(s, eredmeny);
    cout << s << endl;
    return 0;
}

III.3.

 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
74
75
76
77
78
79
#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ifstream fin("schi.in");
    ofstream fout("schi.out");

    int n;
    fin >> n;

    int maximum = 1;

    int hossz = 1;
    int irany = 0;
        /*
            +1 -> növekvő a sorozatrész
            -1 -> csökkenő
            0 -> lehet majd bármilyen (még csak egy
                 elemű)
        */

    int elozo;
    fin >> elozo;

    for (int i = 2; i <= n; i++) {
        int akt;
        fin >> akt;

        if (elozo < akt) {
            if (irany == 1) {
                hossz++;
            }
            else if (irany == 0) {
                hossz++;
                irany = 1;
            }
            else { // -1
                if (hossz > maximum)
                    maximum = hossz;

                hossz = 2;
                irany = 1;
            }
        }
        else if (elozo > akt) {
            if (irany == -1) {
                hossz++;
            }
            else if (irany == 0) {
                hossz++;
                irany = -1;
            }
            else { // 1
                if (hossz > maximum)
                    maximum = hossz;

                hossz = 2;
                irany = -1;
            }
        }
        else { // ==
            if (hossz > maximum)
                maximum = hossz;

            hossz = 1;
            irany = 0;
        }

        elozo = akt;
    }

    if (hossz > maximum)
        maximum = hossz;

    fout << maximum << endl;
    return 0;
}

HF. fogalmazás

A program beolvassa a sorozat elemeit, közben megjegyzi az előzőt, az aktuális sípálya hosszát és azt, hogy ez növekvő, csökkenő vagy pedig még csak egy elemű.

Az aktuálisan beolvasott elemet az előzővel összehasonlítva eldöntjük, hogy folytatható-e az aktuális sípálya, vagy újat kell kezdeni (és annak 1 vagy 2 eleme van jelenleg).

Menet közben a hosszok maximumát is figyeljük és a végén kiírjuk.

Idő szempontjából az algoritmus hatékony mert csak egyszer halad végig a sorozat elemein mindegyikre konstans számú lépést végez.

Memória szempontjából azért hatékony, mert konstans mennyiségű memóriát használ (nem tárolja a sorozat minden elemét).

Más megoldási ötlet:

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

int main()
{
    ifstream fin("schi.in");
    ofstream fout("schi.out");

    int n;
    fin >> n;

    int maximum = 1;

    int hossz_nov = 1;
    int hossz_csokk = 1;

    int elozo;
    fin >> elozo;

    for (int i = 2; i <= n; i++) {
        int akt;
        fin >> akt;

        // nov.
        if (akt > elozo) {
            hossz_nov++;
        }
        else {
            if (maximum < hossz_nov)
                maximum = hossz_nov;

            hossz_nov = 1;
        }

        // csokk.
        if (akt < elozo) {
            hossz_csokk++;
        }
        else {
            if (maximum < hossz_csokk)
                maximum = hossz_csokk;

            hossz_csokk = 1;
        }

        elozo = akt;
    }

    if (hossz_nov > maximum)
        maximum = hossz_nov;

    if (hossz_csokk > maximum)
        maximum = hossz_csokk;

    fout << maximum << endl;
    return 0;
}