II.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
| #include <iostream>
#include <fstream>
#include <cstring>
using namespace std;
int main()
{
char s[100] = "elemente";
int k;
//-----------------------------------
// vizsgalapra:
for(k=strlen(s)-1;k>=0;k--)
{
if (s[k] == s[0]) {
for (int j = 0; j <= k; j++)
cout << s[j];
cout << " ";
/* VAGY:
char temp[100];
strcpy(temp, s);
temp[k+1] = '\0';
cout << temp << " ";
*/
}
}
// eddig a vizsgalap
//----------------------------------
cout << endl;
return 0;
}
|
III.1.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| void Putere (int n, int &x, int &p)
{
for (int i=2; i<=n; i++)
{
int szam=n;
p=0;
while (szam%i==0)
{
szam/=i;
p++;
}
if (szam==1)
{
x=i;
return;
}
}
}
|
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
| #include <iostream>
using namespace std;
int main() {
int n; cin>>n;
int t[21][21];
for (int i=1;i<=n;i++) {
cin>>t[1][i];
}
for (int i=2; i<=n;i++) {
for (int j=1;j<=n;j++) {
if (i+j>n+1) {
t[i][j]=-1;
}
else t[i][j]=(t[i-1][j]+t[i-1][j+1])%100;
}
}
for (int i=1; i<=n;i++) {
for (int j=1;j<=n;j++) {
cout<<t[i][j]<<" ";
}
cout<<endl;
}
return 0;
}
|
III.3
b.
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
| #include <iostream>
#include <fstream>
using namespace std;
int main()
{
ifstream fin("bac.in");
int x;
int minimum, maximum;
fin >> minimum;
maximum = minimum;
int poz = 2;
int elso = -1;
int utolso = -1;
while (fin >> x) {
if (x < minimum) {
minimum = x;
}
else if (x > maximum) {
maximum = x;
}
else {
//cout << poz << endl;
if (elso == -1)
elso = poz;
utolso = poz;
}
poz++;
}
if (elso == -1)
cout << "nu exista" << endl;
else
cout << elso << " " << utolso << endl;
return 0;
}
|
a.
Az algoritmus beolvassa az első számot,
majd a többi elem esetén figyeli, hogy
változik-e az eddigi minimum és maximum.
Azon elemek pozíciói közül, ahol nem változik,
megjegyezzük az elsőt és az utolsót egy-egy
változóban.
A program hatékony idő szempontjából, mert
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
csak egy-egy elemet tárol, nem az egész
sorozatot (összesen konstans mennyiségű
memóriát használ).