ЕГЭ 2016_инф_11 кл_тренир 5_12.05.2016_235 мин_крит_вар ИН10501-4_64 стр


Чтобы посмотреть этот PDF файл с форматированием и разметкой, скачайте его и откройте на своем компьютере.
. 11

Ɉɬɜɟɬɚɦɢ
123
ɱɢɫɥɨ
ɭɤɚɡɚɧɧɨɦ
5
ɰɟɥɵɯ
ɡɚɩɢɫɚɧɧɵɯ
; 11111000
+ 20
ɮɪɚɝɦɟɧɬ
ɫɨɞɟɪɠɚɳɢɣ
Ɉɩɪɟɞɟɥɢɬɟ
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
. 1
. 2
. 3
??? ??? ??? F
x, y, z


ɫɨɨɬɜɟɬɫɬɜɭɸɳɚɹ
ɛɭɤɜɚɦɢ
ɡɚɞɚɧɨ
. 2
??? ??? F
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
ɩɟɪɟɦɟɧɧɚɹ
ɫɜɟɞɟɧɢɹ
1
2
3
4
5
6
7
8
1
15 20 18
2
15
25
25
24 22
20
12

13 16 17
24 13
15
12 16
18 22 17 15
Ɉɩɪɟɞɟɥɢɬɟ
ID_
2227 2272
2227 2299
2228 2272
2228 2299
2272 2240
2272 1202
2272 1217
2299 2356
2299 2378
2322 2356
2322 2378
2331 2240
2331 1202
2331 1217
2387 2261
2387 2293

ɩɟɪɟɞɚɱɢ
ɫɭɦɦɚɪɧɚɹ
ɹɜɥɹɟɬɫɹ
ɫɥɨɜɚ
Ʉɨɞɵ
ɬɪɟɬɶɹ
ɧɟɭɛɵɜɚɧɢɹ
ɪɚɡɞɟɥɢɬɟɥɟɣ
= 14; 5 + 7 = 12; 7 + 5 = 12.
: 1214.
ɱɢɫɥɨ
ɧɟɤɨɬɨɪɵɟ
ɹɱɟɣɤɢ
ɡɚɩɢɫɚɧɵ
ɱɢɫɥɚ
0 1 2 3 4 5
10
20
30
40
50
ɢɫɩɨɥɶɡɭɟɬɫɹ
ɩɪɟɞɫɬɚɜɥɟɧɚ
S = 0
N = 0
WHILE S 165
S = S + 15
N = N + 2
PRINT N

s = 0
n = 0
while s 165:
s = s + 15
n = n + 2
print(n)


begin
s := 0;
n := 0;
while s 165 do
s := s + 15;
n := n + 2
end;
writeln(n)
end.

{
while (s 165) {
ɱɚɫɬɨɬɨɣ
Ɉɩɪɟɞɟɥɢɬɟ
ɛɥɢɠɚɣɲɟɟ
ɰɟɥɨɟ
A, B, C, D, E, X,
X
1
Ʉɚɠɞɚɹ
ɤɨɥɢɱɟɫɬɜɨ
ɜɫɬɪɟɱɚɬɶɫɹ
ȼɚɞɢɦ
ɪɟɤɭɪɫɢɜɧɵɟ
F
� IF n 2 THEN
F = F(n-1)+G(n-1)+F(n-2)
F = n
END IF
END FUNCTION
� IF n 2 THEN
G = G(n-1)+F(n-1)+G(n-2)
ELSE
END IF
END FUNCTION
begin
� if n 2 then
else
F := n;
end;
begin
� if n 2 then
G := G(n-1)+F(n-1)+G(n-2)
G := 3-n;
end;
� if (n 2)
� n 2
:= F(n-1)+G(n-1)+F(n-2)
:= n
G(
n)
� n 2
:= G(n-1)+F(n-1)+G(n-2)
:= 3-n
. 11


� if n 2:
ɛɭɞɟɬ
ɩɪɢ
ɜɵɩɨɥɧɟɧɢɢ
TCP/IP
ɦɚɫɤɨɣ
IP-
ɫɟɬɢ
ɤɚɤɚɹ

ɫɬɚɪɲɢɯ
ɡɚɬɟɦ

Ɉɛɵɱɧɨ
IP-
ɜɢɞɟ
ɩɨɥɭɱɚɟɬɫɹ
ɪɟɡɭɥɶɬɚɬɟ
IP-
231.32.255.131,
231.32.240.0.
IP-
195.227.196.12
195.227.192.0.
ɩɨɥɶɡɨɜɚɬɟɥɸ
ɜɵɞɚɺɬɫɹ
ɫɨɫɬɨɹɳɢɣ
20
ɫɨɞɟɪɠɚɳɢɣ
12-
, F, G, H, K, L, M, N.
ɫɢɦɜɨɥɵ
Ʉɪɨɦɟ
ɩɚɪɨɥɹ
ɩɨɥɶɡɨɜɚɬɟɥɹ
ɫɢɫɬɟɦɟ
ɫɜɟɞɟɧɢɹ
ɩɨɥɶɡɨɜɚɬɟɥɟɣ
20
400
ɨɥɢɱɟɫɬɜɨ
Ɋɟɞɚɤɬɨɪ
ɜɯɨɞ
ɜɵɩɨɥɧɹɬɶ
w
ɇɚɩɪɢɦɟɪ
ɤɨɦɚɧɞɵ
ɩɪɨɜɟɪɹɟɬ
ɤɨɦɚɧɞɚ
ɜɨɡɜɪɚɳɚɟɬ
ɡɧɚɱɟɧɢɟ
ɋɬɪɨɤɚ
ȿɋɅɂ
Ɋɟɞɚɤɬɨɪ
ɫɬɪɨɤɚ
101,
1,
ɫɬɪɨɤɚ
ɩɪɢɦɟɧɟɧɢɹ
. 11




80
ɡɚɩɢɫɵɜɚɟɬɫɹ
62.
Ɉɩɪɟɞɟɥɢɬɟ
ɫɢɫɬɟɦɵ
ɫɟɪɜɟɪɚ
ɥɨɝɢɱɟɫɤɨɣ
ɫɢɦɜɨɥ
|,
ɞɥɹ
ɡɚɩɪɨɫɵ
ɤɨɥɢɱɟɫɬɜɨ
ɂɧɬɟɪɧɟɬ
|
ɋɚɬɭɪɧ
ɤɨɥɢɱɟɫɬɜɨ
ɋɚɬɭɪɧ
ɜɫɟ
ɫɨɞɟɪɠɚɳɢɯ
ɜɪɟɦɹ
ɱɟɪɟɡ
ɧɚɢɦɟɧɶɲɟɝɨ
ɡɧɚɱɟɧɢɟ
1
ɧɟɨɬɪɢɰɚɬɟɥɶɧɨɦ
A
0
10.
4, 3, 6, 8, 5, 8, 4, 2, 10, 9, 4
. A[0] = 4, A[1] = 3
Ɉɩɪɟɞɟɥɢɬɟ
ɡɧɚɱɟɧɢɟ
Python
FOR i = 1 TO 9
IF A(i) = A(0) THEN
c = c + 1
t = A(i+1)
A(i) = t
END IF
NEXT i
c = 0
for i in range(1,10):
if A[i] == A[0]:
c = c + 1
t = A[i+1]
A[i] = t
i
1
9
A[i] = A[0]
t := A[i+1]
A[i+1] := A[i]
A[i] := t

for i := 1 to 9 do begin
if A[i] = A[0] then begin
c := c + 1;
t := A[i+1];
A[i+1] := A[i];
A[i] := t;
end;
for (i = 1; i 10; i++) {
c++;
t = A[i+1];
A[i+1] = A[i];
A[i] = t;
}
}

ɍɤɚɠɢɬɟ
ɬɚɤɨɟ
100)
ɩɟɱɚɬɚɟɬ
Python
INPUT X
L = X - 30
M = X + 30
�WHILE L M
� IF L M THEN
L = L M
ELSE
M = M L
WEND
PRINT M
x = int(input())
L = x-30
M = x+30
while L != M:
� if L M:
L = L - M
else:
M = M - L
print(M)

x, L, M
x
M := x+30

� L M
� L M
L := L M
M := M L
M
begin
readln(x);
L := x-30;
� while L M do begin
� if L M
then L := L - M
else M := M L;
end;
writeln(M);
end.
int main()
{
int x, L, M;
scanf("%d", &x);
L = x-30;
M = x+30;
while (L != M) {
else M = M - L;
}
printf("%d", M);

Ɉɩɪɟɞɟɥɢɬɟ
ɩɪɨɝɪɚɦɦɚ
Python
I = 1
WHILE F(I) G(I)
WEND
PRINT I
F = N * N
END FUNCTION
G = 1000*N + 3
END FUNCTION
def f(n):
i

f(i) g(i)

i
f(
n)
:= n * n
g(
n)
:= 1000*n + 3
i : longint;
begin
end;
begin
g := 1000*n + 3;
end;
i := 1;
while f(i) g(i) do
i := i*2;
writeln(i)
end.
. 11


long f(long n) {
ɷɤɪɚɧɟ
2
3
1,
2,
ɭɦɧɨɠɚɟɬ
ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ
ɤɨɦɚɧɞ
ɩɪɢ
2
ɹɜɥɹɟɬɫɹ
26

ɞɥɹ
ɬɪɚɟɤɬɨɪɢɹ
ɫɭɳɟɫɬɜɭɟɬ
x1, x2, x3, x4, x5, x6, x7, x8,
ɭɤɚɡɚɧɧɨɦɭ
ɜɫɟ
ɭɤɚɡɚɬɶ
ɤɨɥɢɱɟɫɬɜɨ
. 11

(2427)
ɫɧɚɱɚɥɚ
(24, 25


ɛɥɢɠɚɣɲɢɯ
ɜɨɡɪɚɫɬɚɧɢɹ
ɱɢɫɥɚ
1936
2025 (1936 = 44
9.
ɩɪɨɝɪɚɦɦɚ
Python
INPUT N
K = 1
WHILE K*K = N
K = K + 1
WEND
PRINT K-1, K
END
n = int(input())
k = 1
while k*k = n:
k = k + 1
print(k-1,k)
n, k
n

k*k = n

k-1, " ", k
begin
k := 1;
while k*k = n do
k := k + 1;
writeln(k-1, " ", k)
end.
int main(){
int n, k;
scanf("%d", &n);
k = 1;
while (k*k = n)
k = k + 1;
printf("%d %d", k-1, k);
24
ɡɧɚɱɟɧɢɟ
ɜɫɟ
ɭɤɚɡɚɬɶ
ɫɩɨɫɨɛ
ɩɪɢɜɟɞɺɧɧɭɸ
ɬɨɥɶɤɨ
ɨɲɢɛɨɱɧɵɟ
2016
ɱɢɫɟɥ
1000.
ɷɥɟɦɟɧɬɨɜ
ɲɟɫɬɢ
ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ
2, 3, 1, 5, 6, 4,
ɜɫɟɯ
ɷɥɟɦɟɧɬɨɜ
Python
-
#
m, k
a = []
N = 2016
for i in range(0, N):
a.append(int(input()))

. 11

int i, m, k; for (i=0; iN; i++) scanf("%d", &a[i]);
ɦɨɠɟɬɟ
ɹɡɵɤɟ
ɢɫɩɨɥɶɡɭɟɦɭɸ
Free Pascal 2.4).
ɫɥɭɱɚɟ
ɤɚɦɧɟɣ
ɨɞɢɧ
10
ɤɚɦɧɟɣ
11,
30
ɞɟɥɚɬɶ
ɡɚɜɟɪɲɚɟɬɫɹ
ɤɚɦɧɟɣ
ɩɪɟɜɵɲɚɟɬ
ɛɵɥɨ
ɩɪɨɬɢɜɧɢɤɚ
Ɉɩɢɫɚɬɶ
ɢɝɪɨɤɚ

ɡɧɚɱɢɬ
ɡɚɞɚɧɢɹ
1
ɱɢɫɥɚ
ɜɵɢɝɪɚɬɶ
ɡɧɚɱɟɧɢɹ
ɬɚɤɨɟ
ɡɧɚɱɟɧɢɟ
ɉɟɬɹ
ɩɪɢ
ɜɵɢɝɪɚɬɶ
3
ɡɧɚɱɟɧɢɹ
ɂɧɮɨɪɦɚɬɢɤɚ
ɤɥɚɫɫ
ȼɚɪɢɚɧɬɂɇ
1050118
ɋɬɚɬȽɪɚɞ
2015−2016
ɫɜɨɢɦɜɬɨɪɵɦɯɨɞɨɦ
ɧɟɡɚɜɢɫɢɦɨɨɬɬɨɝɨ
ɤɚɤɛɭɞɟɬɯɨɞɢɬɶȼɚɧɹ
Ⱦɥɹ
ɭɤɚɡɚɧɧɵɯɡɧɚɱɟɧɢɣ
ɨɩɢɲɢɬɟɜɵɢɝɪɵɲɧɭɸɫɬɪɚɬɟɝɢɸɉɟɬɢ
Ɂɚɞɚɧɢɟ
ɍɤɚɠɢɬɟɬɚɤɨɟɡɧɚɱɟɧɢɟ
ɩɪɢɤɨɬɨɪɨɦɭȼɚɧɢɟɫɬɶɜɵɢɝɪɵɲɧɚɹɫɬɪɚɬɟɝɢɹ
ɩɨɡɜɨɥɹɸɳɚɹ
ɦɭɜɵɢɝɪɚɬɶɩɟɪɜɵɦɢɥɢɜɬɨɪɵɦɯɨɞɨɦɩɪɢɥɸɛɨɣɢɝɪɟɉ
ɢɩɪɢɷɬɨɦɭȼɚɧɢɧɟɬɫɬɪɚɬ
ɝɢɢ
ɤɨɬɨɪɚɹɩɨɡɜɨɥɢɬ
ɦɭɝɚɪɚɧɬɢɪɨɜɚɧɧɨ
ɜɵɢɝɪɚɬɶɩ
ɪɜɵɦɯɨɞɨɦ
Ⱦɥɹɭɤɚɡɚɧɧɨɝɨɡɧɚɱɟɧɢɹ
ɨɩɢɲɢɬɟɜɵɢɝɪɵɲɧɭɸɫɬɪɚɬɟɝɢɸȼɚɧɢ
ɉɨɫɬɪɨɣɬɟɞɟɪɟɜɨɜɫɟɯɩɚɪɬɢɣ
ɜɨɡɦɨɠɧɵɯɩɪɢɷɬɨɣɜɵɢɝɪɵɲɧɨɣɫɬɪɚɬɟɝɢɢ
ȼɚɧɢ
ɜɜɢɞɟɪɢɫɭɧɤɚɢɥɢɬɚɛɥɢɰɵ
ɇɚɪɺɛɪɚɯɞɟɪɟɜɚɭɤɚɡɵɜɚɣɬɟ
ɤɬɨɞɟɥɚɟɬ
ɯɨɞ
ɜɭɡɥɚɯ

ɤɨɥɢɱɟɫɬɜɨɤɚɦɧɟɣɜɩɨɡɢɰɢɢ
ɇɚɩɥɨɫɤɨɫɬɢɡɚɞɚɧɨɦɧɨɠɟɫɬɜɨɬɨɱɟɤɫɰɟɥɨɱɢɫɥɟɧɧɵɦɢɤɨɨɪɞɢɧɚɬɚɦɢ
ɧɢɤɚɤɢɟɞɜɟɢɡɤɨɬɨɪɵɯɧɟɫɨɜɩɚɞɚɸɬɢɧɢɤɚɤɢɟɬɪɢɧɟɥɟɠɚɬɧɚɨɞɧɨɣ
ɩɪɹɦɨɣ
ɇɟɨɛɯɨɞɢɦɨɧɚɣɬɢɤɨɥɢɱɟɫɬɜɨɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɨɛɥɚɞɚɸɳɢɯ
ɫɥɟɞɭɸɳɢɦɢɫɜɨɣɫɬɜɚɦɢ
ɜɫɟɜɟɪɲɢɧɵɬɪɟɭɝɨɥɶɧɢɤɚɩɪɢɧɚɞɥɟɠɚɬɡɚɞɚɧɧɨɦɭɦɧɨɠɟɫɬɜɭ
ɧɢɨɞɧɚɜɟɪɲɢɧɚɧɟɥɟɠɢɬɧɚɨɫɹɯɤɨɨɪɞɢɧɚɬ
ɬɪɟɭɝɨɥɶɧɢɤɧɟɩɟɪɟɫɟɤɚɟɬɫɹɫɨɫɶɸ
ɧɨɩɟɪɟɫɟɤɚɟɬɫɹɫɨɫɶɸ
ɇɚɩɢɲɢɬɟɷɮɮɟɤɬɢɜɧɭɸɩɨɜɪɟɦɟɧɢɢɩɨɢɫɩɨɥɶɡɭɟɦɨɣɩɚɦɹɬɢɩɪɨɝɪɚɦɦɭ
ɞɥɹɪɟɲɟɧɢɹɷɬɨɣɡɚɞɚɱɢ
ɉɪɨɝɪɚɦɦɚɫɱɢɬɚɟɬɫɹɷɮɮɟɤɬɢɜɧɨɣɩɨɜɪɟɦɟɧɢ
ɟɫɥɢɩɪɢɭɜɟɥɢɱɟɧɢɢ
ɤɨɥɢɱɟɫɬɜɚɬɨɱɟɤɜ
ɪɚɡɜɪɟɦɹɪɚɛɨɬɵɜɨɡɪɚɫɬɚɟɬɧɟɛɨɥɟɟɱɟɦɜ
ɉɪɨɝɪɚɦɦɚɫɱɢɬɚɟɬɫɹɷɮɮɟɤɬɢɜɧɨɣɩɨɩɚɦɹɬɢ
ɟɫɥɢɪɚɡɦɟɪɩɚɦɹɬɢɞɥɹ
ɯɪɚɧɟɧɢɹɜɫɟɯɧɟɨɛɯɨɞɢɦɵɯɞɚɧɧɵɯɧɟɡɚɜɢɫɢɬɨɬɤɨɥɢɱɟɫɬɜɚɬɨɱɟɤɢɧɟ
ɩɪɟɜɵɲɚɟɬ
1
ɤɢɥɨɛɚɣɬɚ
ɉɟɪɟɞɬɟɤɫɬɨɦɩɪɨɝɪɚɦɦɵɤɪɚɬɤɨɨɩɢɲɢɬɟɚɥɝɨɪɢɬɦɪɟɲɟɧɢɹɢɭɤɚɠɢɬɟ
ɹɡɵɤɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹɢɟɝɨɜɟɪɫɢɸ
ȼɯɨɞɧɵɟɞɚɧɧɵɟ
ȼɩɟɪɜɨɣɫɬɪɨɤɟɡɚɞɚɺɬɫɹ

ɤɨɥɢɱɟɫɬɜɨɬɨɱɟɤɜɡɚɞɚɧɧɨɦɦɧɨɠɟɫɬɜɟ
Ʉɚɠɞɚɹɢɡɫɥɟɞɭɸɳɢɯɫɬɪɨɤ
ɫɨɞɟɪɠɢɬɞɜɚɰɟɥɵɯɱɢɫɥɚ

ɤɨɨɪɞɢɧɚɬɵ
ɨɱɟɪɟɞɧɨɣɬɨɱɤɢ
Ƚɚɪɚɧɬɢɪɭɟɬɫɹ
1
10000, –1000
x, y
1000,
ɧɢɤɚɤɢɟɞɜɟɬɨɱɤɢɧɟɫɨɜɩɚɞɚɸɬ
ɧɢɤɚɤɢɟɬɪɢɧɟɥɟɠɚɬɧɚɨɞɧɨɣɩɪɹɦɨɣ
ɉɪɢɦɟɪɜɯɨɞɧɵɯɞɚɧɧɵɯ
ȼɵɯɨɞɧɵɟɞɚɧɧɵɟ
ɇɟɨɛɯɨɞɢɦɨɜɵɜɟɫɬɢɟɞɢɧɫɬɜɟɧɧɨɟɱɢɫɥɨ
ɤɨɥɢɱɟɫɬɜɨɭɞɨɜɥɟɬɜɨɪɹɸɳɢɯ
ɬɪɟɛɨɜɚɧɢɹɦɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɉɪɢɦɟɪɜɵɯɨɞɧɵɯɞɚɧɧɵɯɞɥɹɩɪɢɜɟɞɺɧɧɨɝɨɜɵɲɟɩɪɢɦɟɪɚɜɯɨɞɧɵɯɞɚɧɧɵɯ
ɫɨɫɬɨɢɬ
27
1
23
2
4
ɦɢɧɭɬ
123
ɜɢɞɟ
ɜɵɩɨɥɧɟɧɢɹ
2427
ɉɨɫɬɚɪɚɣɬɟɫɶ
ɥɨɝɢɱɟɫɤɨɟ
/\
ɥɨɝɢɱɟɫɤɨɟ
\/
ɨɛɨɡɧɚɱɚɟɬɫɹ
B);
A
B
A
B
1
ɪɚɜɧɨɫɢɥɶɧɵɦɢ
(
\/
/\
ɧɟɪɚɜɧɨɫɢɥɶɧɵ
ɡɧɚɱɟɧɢɹ
ɢɧɜɟɪɫɢɹ
ɨɬɪɢɰɚɧɢɟ
ɤɨɧɴɸɧɤɰɢɹ
ɫɥɟɞɨɜɚɧɢɟ
/\
\/
/\ D
/\
/\
ɜɦɟɫɬɨ
/\
Ɇɛɚɣɬ
ɫɦɵɫɥɟ

ɜɵɪɚɠɚɟɬɫɹ
ɫɬɟɩɟɧɶɸ
. 11

Ɉɬɜɟɬɚɦɢ
123
ɱɢɫɥɨ
ɭɤɚɡɚɧɧɨɦ
5
ɰɟɥɵɯ
ɱɢɫɟɥ
ɮɪɚɝɦɟɧɬ
ɫɨɞɟɪɠɚɳɢɣ
Ɉɩɪɟɞɟɥɢɬɟ
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
. 1
. 2
. 3
??? ??? ??? F
x, y, z


ɫɨɨɬɜɟɬɫɬɜɭɸɳɚɹ
ɛɭɤɜɚɦɢ
ɡɚɞɚɧɨ
. 2
??? ??? F
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
ɩɟɪɟɦɟɧɧɚɹ
ɫɜɟɞɟɧɢɹ
1
2
3
4
5
6
7
8
1
15 20 18
2
15
25
25
24 22
20
12

13 16 17
24 13
15
12 16
18 22 17 15
ɩɭɧɤɬɨɜ
ɝɪɚɮɟ
Ɉɩɪɟɞɟɥɢɬɟ
ɩɪɟɞɫɬɚɜɥɟɧɵ
ID_
ID_
2227 2272
2227 2299
2228 2272
2228 2299
2272 2240
2272 1202
2272 1217
2299 2356
2299 2378
2322 2356
2322 2378
2331 2240
2331 1202
2331 1217
2387 2261
2387 2293

, B, C, D, E, F.
ɩɟɪɟɞɚɱɢ
A, B, C
ɫɭɦɦɚɪɧɚɹ
ɹɜɥɹɟɬɫɹ
ɫɥɨɜɚ
Ʉɨɞɵ
ɬɪɟɬɶɹ
9 + 5 = 14; 5 + 7 = 12; 7 + 5 = 12.
: 1214.
ɱɢɫɥɨ
ɧɟɤɨɬɨɪɵɟ
ɹɱɟɣɤɢ
ɡɚɩɢɫɚɧɵ
ɱɢɫɥɚ
10
20
30
40
50
D3
ɡɚɩɢɫɚɥɢ
=D$1+$A3.
D3
$
ɢɫɩɨɥɶɡɭɟɬɫɹ
Ⱦɥɹ
S = 0
N = 0
WHILE S 165
S = S + 15
N = N + 5
PRINT N
n = 0
while s 165:
s = s + 15
n = n + 5
print(n)
n, s
s := 0
s 165
n := n + 5

n

begin
s := 0;
n := 0;
while s 165 do
s := s + 15;
n := n + 5
end;
writeln(n)
end.
int main()
{
while (s 165) {
s = s + 15;
n = n + 5;
}
printf("%d\n", n);
ɱɟɬɵɪɺɯɤɚɧɚɥɶɧɚɹ
32
ɤȽɰ
32-
3
ɮɚɣɥ
Ɉɩɪɟɞɟɥɢɬɟ
ɫɥɨɜ
ɢɫɩɨɥɶɡɭɟɬ
ɱɟɬɵɪɺɯɛɭɤɜɟɧɧɵɟ
A, B, C, D, E, F, X,
X
1
ɪɚɡɥɢɱɧɵɯ
ɪɟɤɭɪɫɢɜɧɵɟ
F
� IF n 2 THEN
F = F(n-1)+G(n-1)+F(n-2)
ELSE
F = n
END IF
END FUNCTION
G = G(n-1)+F(n-1)+G(n-2)
ELSE
G = 3-n
END IF
END FUNCTION
begin
� if n 2 then
F := F(n-1)+G(n-1)+F(n-2)
else
F := n;
end;
� if n 2 then
G := G(n-1)+F(n-1)+G(n-2)
else
G := 3-n;
end;
� if (n 2)
� n 2
:= F(n-1)+G(n-1)+F(n-2)
:= n
G(
n)
� n 2
:= G(n-1)+F(n-1)+G(n-2)
:= 3-n
. 11


� if n 2:
ɛɭɞɟɬ
ɩɪɢ
ɜɵɩɨɥɧɟɧɢɢ
TCP/IP
ɦɚɫɤɨɣ
IP-
ɫɟɬɢ

ɫɬɚɪɲɢɯ
ɡɚɬɟɦ

Ɉɛɵɱɧɨ
IP-
ɜɢɞɟ
ɩɨɥɭɱɚɟɬɫɹ
ɪɟɡɭɥɶɬɚɬɟ
IP-
231.32.255.131,
231.32.240.0.
IP-
227.195.208.12
227.195.192.0.
ɩɨɥɶɡɨɜɚɬɟɥɸ
ɜɵɞɚɺɬɫɹ
ɫɨɫɬɨɹɳɢɣ
15
ɫɨɞɟɪɠɚɳɢɣ
12-
, F, G, H, K, L, M, N.
ɫɢɦɜɨɥɵ
Ʉɪɨɦɟ
ɩɚɪɨɥɹ
ɩɨɥɶɡɨɜɚɬɟɥɹ
ɫɢɫɬɟɦɟ
ɫɜɟɞɟɧɢɹ
ɩɨɥɶɡɨɜɚɬɟɥɟɣ
20
400
ɨɥɢɱɟɫɬɜɨ
Ɋɟɞɚɤɬɨɪ
ɜɯɨɞ
ɜɵɩɨɥɧɹɬɶ
w
ɇɚɩɪɢɦɟɪ
ɤɨɦɚɧɞɵ
ɩɪɨɜɟɪɹɟɬ
ɤɨɦɚɧɞɚ
ɜɨɡɜɪɚɳɚɟɬ
ɡɧɚɱɟɧɢɟ
ɋɬɪɨɤɚ
ȿɋɅɂ
Ɋɟɞɚɤɬɨɪ
99,
1,
. 11




77
ɡɚɩɢɫɵɜɚɟɬɫɹ
52.
Ɉɩɪɟɞɟɥɢɬɟ
ɫɢɫɬɟɦɵ
ɩɨɢɫɤɨɜɨɝɨ
ɥɨɝɢɱɟɫɤɨɣ
ɫɢɦɜɨɥ
|,
ɂɧɬɟɪɧɟɬ
|
ɋɚɬɭɪɧ
ɤɨɥɢɱɟɫɬɜɨ
ɋɚɬɭɪɧ
ɫɨɞɟɪɠɚɳɢɯ
ɜɪɟɦɹ
ɱɟɪɟɡ
ɧɚɢɦɟɧɶɲɟɝɨ
ɡɧɚɱɟɧɢɟ
1
ɧɟɨɬɪɢɰɚɬɟɥɶɧɨɦ
ɢɫɩɨɥɶɡɭɟɬɫɹ
A
0
10.
Ɂɧɚɱɟɧɢɹ
4, 3, 6, 8, 4, 8, 2, 10, 9, 14, 4
. A[0] = 4, A[1] = 3
Ɉɩɪɟɞɟɥɢɬɟ
ɡɧɚɱɟɧɢɟ
Python
FOR i = 1 TO 9
IF A(i) = A(0) THEN
c = c + 1
t = A(i+1)
A(i) = t
END IF
NEXT i
c = 0
for i in range(1,10):
if A[i] == A[0]:
c = c + 1
t = A[i+1]
A[i] = t
i
1
9
A[i] = A[0]
t := A[i+1]
A[i+1] := A[i]

for i := 1 to 9 do begin
if A[i] = A[0] then begin
c := c + 1;
t := A[i+1];
A[i+1] := A[i];
end;
end;
for (i = 1; i 10; i++) {
if (A[i] == A[0]) {
c++;
t = A[i+1];
A[i+1] = A[i];
A[i] = t;
}
}

ɍɤɚɠɢɬɟ
200)
ɩɟɱɚɬɚɟɬ
Python
INPUT X
L = X - 30
M = X + 30
�WHILE L M
� IF L M THEN
ELSE
M = M L
END IF
WEND
PRINT M
x = int(input())
L = x-30
M = x+30
while L != M:
� if L M:
L = L - M
M = M - L
print(M)

x, L, M
x
M := x+30

� L M
� L M
L := L M
M := M L
M
begin
readln(x);
M := x+30;
� while L M do begin
� if L M
then L := L - M
else M := M L;
end;
end.
int main()
{
int x, L, M;
scanf("%d", &x);
M = x+30;
while (L != M) {
� if(L M) L = L - M;
else M = M - L;
}
printf("%d", M);

Ɉɩɪɟɞɟɥɢɬɟ
ɩɪɨɝɪɚɦɦɚ
Python
I = 1
WHILE F(I) G(I)
WEND
PRINT I
F = N * N
END FUNCTION
G = 2000*N + 3
END FUNCTION
def f(n):
i

f(i) g(i)

i
f(
n)
:= n * n
g(
n)
:= 2000*n + 3
i : longint;
begin
end;
begin
g := 2000*n + 3;
end;
i := 1;
while f(i) g(i) do
i := i*2;
writeln(i)
end.
. 11


long f(long n) {
ɷɤɪɚɧɟ
2
3
1,
2,
ɭɦɧɨɠɚɟɬ
ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ
ɤɨɦɚɧɞ
ɩɪɢ
2
ɹɜɥɹɟɬɫɹ
28

ɞɥɹ
ɬɪɚɟɤɬɨɪɢɹ
ɫɭɳɟɫɬɜɭɟɬ
x1, x2, x3, x4, x5, x6, x7, x8,
ɭɤɚɡɚɧɧɨɦɭ
x1, x2, x3, x4, x5, x6, x7, x8,
ɤɨɬɨɪɵɯ
ɜɵɩɨɥɧɟɧɨ
ɭɤɚɡɚɬɶ
ɤɨɥɢɱɟɫɬɜɨ
. 11

(2427)
ɫɧɚɱɚɥɚ
(24, 25


ɧɟɨɬɪɢɰɚɬɟɥɶɧɨɟ
ɤɜɚɞɪɚɬ
ɩɪɨɝɪɚɦɦɚ
Python
INPUT N
K = 1
WHILE K*K = N
K = K + 1
WEND
PRINT (K-1)*(K-1), K*K
END
n = int(input())
k = 1
while k*k = n:
k = k + 1
print((k-1)*(k-1),k*k)
n, k
n

k*k = n

(k-1)*(k-1), " ", k*k
begin
k := 1;
while k*k = n do
k := k + 1;
writeln((k-1)*(k-1)," ",k*k)
end.
int main(){
int n, k;
scanf("%d", &n);
k = 1;
while (k*k = n)
k = k + 1;
printf("%d %d", (k-1)*(k-1), k*k);
24
ɡɧɚɱɟɧɢɟ
ɞɨɩɭɳɟɧɚ
ɭɤɚɡɚɬɶ
ɫɩɨɫɨɛ
ɩɪɢɜɟɞɺɧɧɭɸ
ɬɨɥɶɤɨ
ɨɲɢɛɨɱɧɵɟ
2016
ɩɨɥɨɠɢɬɟɥɶɧɵɯ
1000.
ɷɥɟɦɟɧɬɨɜ
ɲɟɫɬɢ
ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ
2, 3, 1, 5, 6, 4,
ɧɢɠɟ
Python
-
#
m, k
a = []
N = 2016
for i in range(0, N):
a.append(int(input()))

. 11

int i, m, k; for (i=0; iN; i++) scanf("%d", &a[i]);
ɦɨɠɟɬɟ
ɹɡɵɤɟ
ɢɫɩɨɥɶɡɭɟɦɭɸ
Free Pascal 2.4).
ɫɥɭɱɚɟ
ɤɚɦɧɟɣ
ɨɞɢɧ
10
ɤɚɦɧɟɣ
11,
30
ɟɫɬɶ
ɡɚɜɟɪɲɚɟɬɫɹ
ɤɚɦɧɟɣ
ɩɪɟɜɵɲɚɟɬ
ɛɵɥɨ
ɩɪɨɬɢɜɧɢɤɚ
Ɉɩɢɫɚɬɶ
ɢɝɪɨɤɚ

ɡɧɚɱɢɬ
ɡɚɞɚɧɢɹ
1
ɜɵɢɝɪɚɬɶ
ɡɧɚɱɟɧɢɹ
ɬɚɤɨɟ
ɡɧɚɱɟɧɢɟ
ɉɟɬɹ
ɩɪɢ
ɜɵɢɝɪɚɬɶ
3
ɡɧɚɱɟɧɢɹ
ɭɤɚɡɚɧɧɵɯ
ɡɧɚɱɟɧɢɣ
ɟɫɬɶ
ɜɵɢɝɪɵɲɧɚɹ
ɢɥɢ
ɤɨɥɢɱɟɫɬɜɨ
ɰɟɥɨɱɢɫɥɟɧɧɵɦɢ
ɫɜɨɣɫɬɜɚɦɢ
ɜɟɪɲɢɧɵ
ɡɚɞɚɧɧɨɦɭ
ɩɟɪɟɫɟɤɚɟɬɫɹ
ɤɨɥɢɱɟɫɬɜɚ
ɡɚɞɚɺɬɫɹ

Ʉɚɠɞɚɹ

ɤɨɨɪɞɢɧɚɬɵ
1
10000, 1000
x, y
1000,
ɫɨɜɩɚɞɚɸɬ
ɞɚɧɧɵɟ
ɤɨɥɢɱɟɫɬɜɨ
ɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɫɨɫɬɨɢɬ
27
1
23
2
4
ɦɢɧɭɬ
123
ɜɢɞɟ
ɜɵɩɨɥɧɟɧɢɹ
2427
ɉɨɫɬɚɪɚɣɬɟɫɶ
ɥɨɝɢɱɟɫɤɨɟ
/\
ɥɨɝɢɱɟɫɤɨɟ
\/
ɨɛɨɡɧɚɱɚɟɬɫɹ
B);
A
B
A
B
1
ɪɚɜɧɨɫɢɥɶɧɵɦɢ
(
\/
/\
ɧɟɪɚɜɧɨɫɢɥɶɧɵ
ɡɧɚɱɟɧɢɹ
ɢɧɜɟɪɫɢɹ
ɨɬɪɢɰɚɧɢɟ
ɤɨɧɴɸɧɤɰɢɹ
ɫɥɟɞɨɜɚɧɢɟ
/\
\/
/\ D
/\
/\
ɜɦɟɫɬɨ
/\
Ɇɛɚɣɬ
ɫɦɵɫɥɟ

ɜɵɪɚɠɚɟɬɫɹ
ɫɬɟɩɟɧɶɸ
. 11

Ɉɬɜɟɬɚɦɢ
123
ɱɢɫɥɨ
ɭɤɚɡɚɧɧɨɦ
5
ɰɟɥɵɯ
ɡɚɩɢɫɚɧɧɵɯ
; 11111000
+ 20
ɮɪɚɝɦɟɧɬ
ɫɨɞɟɪɠɚɳɢɣ
Ɉɩɪɟɞɟɥɢɬɟ
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
. 1
. 2
. 3
??? ??? ??? F
x, y, z


ɫɨɨɬɜɟɬɫɬɜɭɸɳɚɹ
ɛɭɤɜɚɦɢ
ɡɚɞɚɧɨ
. 2
??? ??? F
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
ɩɟɪɟɦɟɧɧɚɹ
ɫɜɟɞɟɧɢɹ
1
2
3
4
5
6
7
8
1
15 20 18
2
15
25
25
24 22
20
12

13 16 17
24 13
15
12 16
18 22 17 15
Ɉɩɪɟɞɟɥɢɬɟ
ɩɪɟɞɫɬɚɜɥɟɧɵ
ID_
ID_
2227 2272
2227 2299
2228 2272
2228 2299
2272 2240
2272 1202
2272 1217
2299 2356
2299 2378
2322 2356
2322 2378
2331 2240
2331 1202
2331 1217
2387 2261
2387 2293

, B, C, D, E, F.
ɩɟɪɟɞɚɱɢ
A, B, C
ɫɭɦɦɚɪɧɚɹ
ɹɜɥɹɟɬɫɹ
ɫɥɨɜɚ
Ʉɨɞɵ
ɬɪɟɬɶɹ
9 + 5 = 14; 5 + 7 = 12; 7 + 5 = 12.
: 1214.
ɱɢɫɥɨ
ɧɟɤɨɬɨɪɵɟ
ɹɱɟɣɤɢ
ɡɚɩɢɫɚɧɵ
ɱɢɫɥɚ
10
20
30
40
50
ɹɱɟɣɤɟ
D3
= D$1 + $A3.
D3
$
ɢɫɩɨɥɶɡɭɟɬɫɹ
Ⱦɥɹ
ɩɪɟɞɫɬɚɜɥɟɧɚ
S = 0
N = 0
WHILE S 165
S = S + 15
N = N + 5
WEND
PRINT N
n = 0
while s 165:
s = s + 15
n = n + 5
print(n)
n, s
s := 0

s 165
n := n + 5
n

begin
s := 0;
n := 0;
while s 165 do
begin
s := s + 15;
n := n + 5
writeln(n)
end.
int main()
{
int s = 0, n = 0;
while (s 165) {
s = s + 15;
}
printf("%d\n", n);
ɱɚɫɬɨɬɨɣ
32-
3
Ɉɩɪɟɞɟɥɢɬɟ
ɛɥɢɠɚɣɲɟɟ
ɰɟɥɨɟ
ɫɥɨɜ
ɢɫɩɨɥɶɡɭɟɬ
ɱɟɬɵɪɺɯɛɭɤɜɟɧɧɵɟ
A, B, C, D, E, F, X,
X
1
ɪɚɡɥɢɱɧɵɯ
ɪɟɤɭɪɫɢɜɧɵɟ
F
� IF n 2 THEN
ELSE
F = n
END IF
END FUNCTION
� IF n 2 THEN
G = G(n-1)+F(n-1)+G(n-2)
G = 3-n
END IF
END FUNCTION
begin
F := F(n-1)+G(n-1)+F(n-2)
else
F := n;
end;
begin
� if n 2 then
else
G := 3-n;
end;
� if (n 2)
� n 2
:= F(n-1)+G(n-1)+F(n-2)
:= n
G(
n)
� n 2
:= G(n-1)+F(n-1)+G(n-2)
:= 3-n
. 11


� if n 2:
ɛɭɞɟɬ
ɩɪɢ
ɜɵɩɨɥɧɟɧɢɢ
TCP/IP
ɦɚɫɤɨɣ
IP-
ɫɟɬɢ

ɫɬɚɪɲɢɯ
ɡɚɬɟɦ

Ɉɛɵɱɧɨ
IP-
ɜɢɞɟ
ɩɨɥɭɱɚɟɬɫɹ
ɪɟɡɭɥɶɬɚɬɟ
IP-
231.32.255.131,
231.32.240.0.
IP-
227.195.208.12
227.195.192.0.
ɩɨɥɶɡɨɜɚɬɟɥɸ
ɜɵɞɚɺɬɫɹ
ɫɨɫɬɨɹɳɢɣ
20
ɫɨɞɟɪɠɚɳɢɣ
12-
, F, G, H, K, L, M, N.
ɫɢɦɜɨɥɵ
Ʉɪɨɦɟ
ɩɚɪɨɥɹ
ɩɨɥɶɡɨɜɚɬɟɥɹ
ɫɢɫɬɟɦɟ
ɫɜɟɞɟɧɢɹ
ɩɨɥɶɡɨɜɚɬɟɥɟɣ
20
400
ɨɥɢɱɟɫɬɜɨ
Ɋɟɞɚɤɬɨɪ
ɜɯɨɞ
ɜɵɩɨɥɧɹɬɶ
ɇɚɩɪɢɦɟɪ
ɤɨɦɚɧɞɵ
ɤɨɦɚɧɞɚ
ɜɨɡɜɪɚɳɚɟɬ
ɡɧɚɱɟɧɢɟ
ɋɬɪɨɤɚ
Ɋɟɞɚɤɬɨɪ
. 11
.

10
2016
.





,
,
,
,
,
,
,
,
,
,
.







.






?
ɡɚɩɢɫɵɜɚɟɬɫɹ
Ɉɩɪɟɞɟɥɢɬɟ
ɫɢɫɬɟɦɵ
ɫɟɪɜɟɪɚ
ɥɨɝɢɱɟɫɤɨɣ
ɫɢɦɜɨɥ
ɞɥɹ
ɡɚɩɪɨɫɵ
ɤɨɥɢɱɟɫɬɜɨ
ɂɧɬɟɪɧɟɬ
&

274
& (
|
467
ɋɚɬɭɪɧ
ɋɚɬɭɪɧ
ɜɫɟ
ɫɨɞɟɪɠɚɳɢɯ
ɜɪɟɦɹ
ɱɟɪɟɡ
ɧɚɢɦɟɧɶɲɟɝɨ
ɡɧɚɱɟɧɢɟ
1
ɧɟɨɬɪɢɰɚɬɟɥɶɧɨɦ
ɢɫɩɨɥɶɡɭɟɬɫɹ
A
0
10.
Ɂɧɚɱɟɧɢɹ
4, 3, 6, 8, 5, 8, 4, 2, 10, 9, 4
. A[0] = 4, A[1] = 3
Ɉɩɪɟɞɟɥɢɬɟ
ɡɧɚɱɟɧɢɟ
Python
FOR i = 1 TO 9
IF A(i) = A(0) THEN
c = c + 1
t = A(i+1)
A(i) = t
END IF
NEXT i
c = 0
for i in range(1,10):
if A[i] == A[0]:
c = c + 1
t = A[i+1]
A[i] = t
i
1
9
A[i] = A[0]
t := A[i+1]
A[i+1] := A[i]
A[i] := t

for i := 1 to 9 do begin
if A[i] = A[0] then begin
c := c + 1;
t := A[i+1];
A[i+1] := A[i];
A[i] := t;
end;
for (i = 1; i 10; i++) {
c++;
t = A[i+1];
A[i+1] = A[i];
A[i] = t;
}
}

ɍɤɚɠɢɬɟ
200)
ɩɟɱɚɬɚɟɬ
Python
INPUT X
L = X - 30
M = X + 30
�WHILE L M
� IF L M THEN
ELSE
M = M L
END IF
WEND
PRINT M
x = int(input())
L = x-30
M = x+30
while L != M:
� if L M:
L = L - M
M = M - L
print(M)

x, L, M
x
M := x+30

� L M
� L M
L := L M
M := M L
M
begin
readln(x);
M := x+30;
� while L M do begin
� if L M
then L := L - M
else M := M L;
end;
end.
int main()
{
int x, L, M;
scanf("%d", &x);
M = x+30;
while (L != M) {
� if(L M) L = L - M;
else M = M - L;
}
printf("%d", M);

Ɉɩɪɟɞɟɥɢɬɟ
ɩɪɨɝɪɚɦɦɚ
Python
I = 1
WHILE F(I) G(I)
WEND
PRINT I
F = N * N
END FUNCTION
G = 1000*N + 3
END FUNCTION
def f(n):
i

f(i) g(i)

i
f(
n)
:= n * n
g(
n)
:= 1000*n + 3
i : longint;
begin
end;
begin
g := 1000*n + 3;
end;
i := 1;
while f(i) g(i) do
i := i*2;
writeln(i)
end.
. 11


long f(long n) {
ɷɤɪɚɧɟ
2
3
1,
2,
ɭɦɧɨɠɚɟɬ
ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ
ɤɨɦɚɧɞ
ɩɪɢ
2
ɹɜɥɹɟɬɫɹ
28

ɞɥɹ
ɬɪɚɟɤɬɨɪɢɹ
ɫɭɳɟɫɬɜɭɟɬ
x1, x2, x3, x4, x5, x6, x7, x8,
ɭɤɚɡɚɧɧɨɦɭ
ɜɫɟ
ɭɤɚɡɚɬɶ
ɤɨɥɢɱɟɫɬɜɨ
. 11

(2427)
ɫɧɚɱɚɥɚ
(24, 25


ɧɟɨɬɪɢɰɚɬɟɥɶɧɨɟ
ɤɜɚɞɪɚɬ
ɩɪɨɝɪɚɦɦɚ
Python
INPUT N
K = 1
WHILE K*K = N
K = K + 1
WEND
PRINT (K-1)*(K-1), K*K
END
n = int(input())
k = 1
while k*k = n:
k = k + 1
print((k-1)*(k-1),k*k)
n, k
n

k*k = n

(k-1)*(k-1), " ", k*k
begin
k := 1;
while k*k = n do
k := k + 1;
writeln((k-1)*(k-1)," ",k*k)
end.
int main(){
int n, k;
scanf("%d", &n);
k = 1;
while (k*k = n)
k = k + 1;
printf("%d %d", (k-1)*(k-1), k*k);
24
ɡɧɚɱɟɧɢɟ
ɞɨɩɭɳɟɧɚ
ɭɤɚɡɚɬɶ
ɫɩɨɫɨɛ
ɩɪɢɜɟɞɺɧɧɭɸ
ɬɨɥɶɤɨ
ɨɲɢɛɨɱɧɵɟ
2016
ɱɢɫɟɥ
1000.
ɷɥɟɦɟɧɬɨɜ
ɲɟɫɬɢ
ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ
2, 3, 1, 5, 6, 4,
ɜɫɟɯ
ɷɥɟɦɟɧɬɨɜ
Python
-
#
m, k
a = []
N = 2016
for i in range(0, N):
a.append(int(input()))

. 11

int i, m, k; for (i=0; iN; i++) scanf("%d", &a[i]);
ɦɨɠɟɬɟ
ɹɡɵɤɟ
ɢɫɩɨɥɶɡɭɟɦɭɸ
Free Pascal 2.4).
ɫɥɭɱɚɟ
ɤɚɦɧɟɣ
ɨɞɢɧ
10
ɤɚɦɧɟɣ
11,
30
ɟɫɬɶ
ɡɚɜɟɪɲɚɟɬɫɹ
ɤɚɦɧɟɣ
ɩɪɟɜɵɲɚɟɬ
ɛɵɥɨ
ɩɪɨɬɢɜɧɢɤɚ
Ɉɩɢɫɚɬɶ
ɢɝɪɨɤɚ

ɡɧɚɱɢɬ
ɡɚɞɚɧɢɹ
1
ɜɵɢɝɪɚɬɶ
ɡɧɚɱɟɧɢɹ
ɬɚɤɨɟ
ɡɧɚɱɟɧɢɟ
ɉɟɬɹ
ɩɪɢ
ɜɵɢɝɪɚɬɶ
3
ɡɧɚɱɟɧɢɹ
ɂɧɮɨɪɦɚɬɢɤɚ
ɤɥɚɫɫ
ȼɚɪɢɚɧɬɂɇ
1050318
ɋɬɚɬȽɪɚɞ
2015−2016
ɫɜɨɢɦɜɬɨɪɵɦɯɨɞɨɦ
ɧɟɡɚɜɢɫɢɦɨɨɬɬɨɝɨ
ɤɚɤɛɭɞɟɬɯɨɞɢɬɶȼɚɧɹ
Ⱦɥɹ
ɭɤɚɡɚɧɧɵɯɡɧɚɱɟɧɢɣ
ɨɩɢɲɢɬɟɜɵɢɝɪɵɲɧɭɸɫɬɪɚɬɟɝɢɸɉɟɬɢ
Ɂɚɞɚɧɢɟ
ɍɤɚɠɢɬɟɬɚɤɨɟɡɧɚɱɟɧɢɟ
ɩɪɢɤɨɬɨɪɨɦɭȼɚɧɢɟɫɬɶɜɵɢɝɪɵɲɧɚɹɫɬɪɚɬɟɝɢɹ
ɩɨɡɜɨɥɹɸɳɚɹɟɦɭɜɵɢɝɪɚɬɶɩɟɪɜɵɦɢɥɢɜɬɨɪɵɦɯɨɞɨɦɩɪɢɥɸɛɨɣɢɝɪ
ɉɟɬɢ
ɢɩɪɢɷɬɨɦɭȼɚɧɢɧɟɬɫɬɪɚɬɟɝɢɢ
ɤɨɬɨɪɚɹɩɨɡɜɨɥɢɬ
ɦɭɝɚɪɚɧɬɢɪɨɜɚɧɧɨ
ɜɵɢɝɪɚɬɶɩɟɪɜɵɦɯɨɞɨɦ
Ⱦɥɹɭɤɚɡɚɧɧɨɝɨɡɧɚɱɟɧɢɹ
ɨɩɢɲɢɬɟɜɵɢɝɪɵɲɧɭɸɫɬɪɚɬɟɝɢɸȼɚɧɢ
ɉɨɫɬɪɨɣɬɟɞɟɪɟɜɨɜɫɟɯɩɚɪɬɢɣ
ɜɨɡɦɨɠɧɵɯɩɪɢɷɬɨɣɜɵɢɝɪɵɲɧɨɣɫɬɪɚɬɟɝɢɢ
ȼɚɧɢ
ɜɜɢɞɟɪɢɫɭɧɤɚɢɥɢɬɚɛɥɢɰɵ
ɇɚɪɺɛɪɚɯɞɟɪɟɜɚɭɤɚɡɵɜɚɣɬɟ
ɤɬɨɞɟɥɚɟɬ
ɯɨɞ
ɜɭɡɥɚɯ

ɤɨɥɢɱɟɫɬɜɨɤɚɦɧɟɣɜɩɨɡɢɰɢɢ
ɇɚɩɥɨɫɤɨɫɬɢɡɚɞɚɧɨɦɧɨɠɟɫɬɜɨɬɨɱɟɤɫɰɟɥɨɱɢɫɥɟɧɧɵɦɢɤɨɨɪɞɢɧɚɬɚɦɢ
ɧɢɤɚɤɢɟɞɜɟɢɡɤɨɬɨɪɵɯɧɟɫɨɜɩɚɞɚɸɬɢɧɢɤɚɤɢɟɬɪɢɧɟɥɟɠɚɬɧɚɨɞɧɨɣ
ɩɪɹɦɨɣ
ɇɟɨɛɯɨɞɢɦɨɧɚɣɬɢɤɨɥɢɱɟɫɬɜɨɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɨɛɥɚɞɚɸɳɢɯ
ɫɥɟɞɭɸɳɢɦɢɫɜɨɣɫɬɜɚɦɢ
ɜɫɟɜɟɪɲɢɧɵɬɪɟɭɝɨɥɶɧɢɤɚɩɪɢɧɚɞɥɟɠɚɬɡɚɞɚɧɧɨɦɭɦɧɨɠɟɫɬɜɭ
ɧɢɨɞɧɚɜɟɪɲɢɧɚɧɟɥɟɠɢɬɧɚɨɫɹɯɤɨɨɪɞɢɧɚɬ
ɬɪɟɭɝɨɥɶɧɢɤɧɟɩɟɪɟɫɟɤɚɟɬɫɹɫɨɫɶɸ
ɧɨɩɟɪɟɫɟɤɚɟɬɫɹɫɨɫɶɸ
ɇɚɩɢɲɢɬɟɷɮɮɟɤɬɢɜɧɭɸɩɨɜɪɟɦɟɧɢɢɩɨɢɫɩɨɥɶɡɭɟɦɨɣɩɚɦɹɬɢɩɪɨɝɪɚɦɦɭ
ɞɥɹɪɟɲɟɧɢɹɷɬɨɣɡɚɞɚɱɢ
ɉɪɨɝɪɚɦɦɚɫɱɢɬɚɟɬɫɹɷɮɮɟɤɬɢɜɧɨɣɩɨɜɪɟɦɟɧɢ
ɟɫɥɢɩɪɢɭɜɟɥɢɱɟɧɢɢ
ɤɨɥɢɱɟɫɬɜɚɬɨɱɟɤɜ
ɪɚɡɜɪɟɦɹɪɚɛɨɬɵɜɨɡɪɚɫɬɚɟɬɧɟɛɨɥɟɟɱɟɦɜ
ɉɪɨɝɪɚɦɦɚɫɱɢɬɚɟɬɫɹɷɮɮɟɤɬɢɜɧɨɣɩɨɩɚɦɹɬɢ
ɟɫɥɢɪɚɡɦɟɪɩɚɦɹɬɢɞɥɹ
ɯɪɚɧɟɧɢɹɜɫɟɯɧɟɨɛɯɨɞɢɦɵɯɞɚɧɧɵɯɧɟɡɚɜɢɫɢɬɨɬɤɨɥɢɱɟɫɬɜɚɬɨɱɟɤɢɧɟ
ɩɪɟɜɵɲɚɟɬ
1
ɤɢɥɨɛɚɣɬɚ
ɉɟɪɟɞɬɟɤɫɬɨɦɩɪɨɝɪɚɦɦɵɤɪɚɬɤɨɨɩɢɲɢɬɟɚɥɝɨɪɢɬɦɪɟɲɟɧɢɹɢɭɤɚɠɢɬɟ
ɹɡɵɤɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹɢɟɝɨɜɟɪɫɢɸ
ȼɯɨɞɧɵɟɞɚɧɧɵɟ
ȼɩɟɪɜɨɣɫɬɪɨɤɟɡɚɞɚɺɬɫɹ

ɤɨɥɢɱɟɫɬɜɨɬɨɱɟɤɜɡɚɞɚɧɧɨɦɦɧɨɠɟɫɬɜɟ
Ʉɚɠɞɚɹɢɡɫɥɟɞɭɸɳɢɯɫɬɪɨɤ
ɫɨɞɟɪɠɢɬɞɜɚɰɟɥɵɯɱɢɫɥɚ

ɤɨɨɪɞɢɧɚɬɵ
ɨɱɟɪɟɞɧɨɣɬɨɱɤɢ
Ƚɚɪɚɧɬɢɪɭɟɬɫɹ
1
10000, –1000
x, y
1000,
ɧɢɤɚɤɢɟɞɜɟɬɨɱɤɢɧɟɫɨɜɩɚɞɚɸɬ
ɧɢɤɚɤɢɟɬɪɢɧɟɥɟɠɚɬɧɚɨɞɧɨɣɩɪɹɦɨɣ
ɉɪɢɦɟɪɜɯɨɞɧɵɯɞɚɧɧɵɯ
ȼɵɯɨɞɧɵɟɞɚɧɧɵɟ
ɇɟɨɛɯɨɞɢɦɨɜɵɜɟɫɬɢɟɞɢɧɫɬɜɟɧɧɨɟɱɢɫɥɨ
ɤɨɥɢɱɟɫɬɜɨɭɞɨɜɥɟɬɜɨɪɹɸɳɢɯ
ɬɪɟɛɨɜɚɧɢɹɦɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɉɪɢɦɟɪɜɵɯɨɞɧɵɯɞɚɧɧɵɯɞɥɹɩɪɢɜɟɞɺɧɧɨɝɨɜɵɲɟɩɪɢɦɟɪɚɜɯɨɞɧɵɯɞɚɧɧɵɯ
ɫɨɫɬɨɢɬ
27
1
23
2
4
ɦɢɧɭɬ
123
ɜɢɞɟ
ɜɵɩɨɥɧɟɧɢɹ
2427
ɉɨɫɬɚɪɚɣɬɟɫɶ
ɥɨɝɢɱɟɫɤɨɟ
/\
ɥɨɝɢɱɟɫɤɨɟ
\/
ɨɛɨɡɧɚɱɚɟɬɫɹ
B);
A
B
A
B
1
ɪɚɜɧɨɫɢɥɶɧɵɦɢ
(
\/
/\
ɧɟɪɚɜɧɨɫɢɥɶɧɵ
ɡɧɚɱɟɧɢɹ
ɢɧɜɟɪɫɢɹ
ɨɬɪɢɰɚɧɢɟ
ɤɨɧɴɸɧɤɰɢɹ
ɫɥɟɞɨɜɚɧɢɟ
/\
\/
/\ D
/\
/\
ɜɦɟɫɬɨ
/\
Ɇɛɚɣɬ
ɫɦɵɫɥɟ

ɜɵɪɚɠɚɟɬɫɹ
ɫɬɟɩɟɧɶɸ
. 11

Ɉɬɜɟɬɚɦɢ
123
ɱɢɫɥɨ
ɭɤɚɡɚɧɧɨɦ
5
ɰɟɥɵɯ
ɱɢɫɟɥ
ɮɪɚɝɦɟɧɬ
ɫɨɞɟɪɠɚɳɢɣ
Ɉɩɪɟɞɟɥɢɬɟ
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
. 1
. 2
. 3
??? ??? ??? F
x, y, z


ɫɨɨɬɜɟɬɫɬɜɭɸɳɚɹ
ɛɭɤɜɚɦɢ
ɡɚɞɚɧɨ
. 2
??? ??? F
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
ɩɟɪɟɦɟɧɧɚɹ
ɫɜɟɞɟɧɢɹ
1
2
3
4
5
6
7
8
1
15 20 18
2
15
25
25
24 22
20
12
5
13 16 17
24 13
15
12 16
18 22 17 15
ɩɭɧɤɬɨɜ
ɝɪɚɮɟ
Ɉɩɪɟɞɟɥɢɬɟ
ID_
2227 2272
2227 2299
2228 2272
2228 2299
2272 2240
2272 1202
2272 1217
2299 2356
2299 2378
2322 2356
2322 2378
2331 2240
2331 1202
2331 1217
2387 2261
2387 2293

, B, C, D, E, F.
ɩɟɪɟɞɚɱɢ
A, B, C
ɫɭɦɦɚɪɧɚɹ
ɹɜɥɹɟɬɫɹ
ɫɥɨɜɚ
Ʉɨɞɵ
ɬɪɟɬɶɹ
9 + 5 = 14; 5 + 7 = 12; 7 + 5 = 12.
: 1214.
ɱɢɫɥɨ
ɧɟɤɨɬɨɪɵɟ
ɹɱɟɣɤɢ
ɡɚɩɢɫɚɧɵ
ɱɢɫɥɚ
10
20
30
40
50
D3
ɡɚɩɢɫɚɥɢ
=D$1+$A3.
D3
$
ɢɫɩɨɥɶɡɭɟɬɫɹ
ɩɪɟɞɫɬɚɜɥɟɧɚ
S = 0
N = 0
WHILE S 165
S = S + 15
N = N + 2
PRINT N
n = 0
while s 165:
s = s + 15
n = n + 2
print(n)
n, s
s := 0
s 165
n := n + 2

n
begin
s := 0;
n := 0;
while s 165 do
s := s + 15;
n := n + 2
end;
writeln(n)
end.
int main()
{
while (s 165) {
s = s + 15;
n = n + 2;
}
printf("%d\n", n);
ɱɟɬɵɪɺɯɤɚɧɚɥɶɧɚɹ
32
ɤȽɰ
32-
3
ɮɚɣɥ
Ɉɩɪɟɞɟɥɢɬɟ
A, B, C, D, E, X,
X
1
Ʉɚɠɞɚɹ
ɤɨɥɢɱɟɫɬɜɨ
ɜɫɬɪɟɱɚɬɶɫɹ
ȼɚɞɢɦ
ɪɟɤɭɪɫɢɜɧɵɟ
F
� IF n 2 THEN
F = F(n-1)+G(n-1)+F(n-2)
ELSE
F = n
END IF
� IF n 2 THEN
G = G(n-1)+F(n-1)+G(n-2)
ELSE
G = 3-n
END IF
END FUNCTION
begin
� if n 2 then
F := F(n-1)+G(n-1)+F(n-2)
else
F := n;
begin
� if n 2 then
G := G(n-1)+F(n-1)+G(n-2)
else
G := 3-n;
end;
� if (n 2)
� n 2
:= F(n-1)+G(n-1)+F(n-2)
:= n
G(
n)
� n 2
:= G(n-1)+F(n-1)+G(n-2)
:= 3-n
. 11

� if n 2:
ɛɭɞɟɬ
ɩɪɢ
ɜɵɩɨɥɧɟɧɢɢ
TCP/IP
ɦɚɫɤɨɣ
IP-
ɫɟɬɢ
ɤɚɤɚɹ

ɫɬɚɪɲɢɯ
ɡɚɬɟɦ

Ɉɛɵɱɧɨ
IP-
ɜɢɞɟ
ɩɨɥɭɱɚɟɬɫɹ
ɪɟɡɭɥɶɬɚɬɟ
IP-
231.32.255.131,
231.32.240.0.
IP-
195.227.196.12
195.227.192.0.
ɩɨɥɶɡɨɜɚɬɟɥɸ
ɜɵɞɚɺɬɫɹ
ɫɨɫɬɨɹɳɢɣ
15
ɫɨɞɟɪɠɚɳɢɣ
12-
, F, G, H, K, L, M, N.
ɫɢɦɜɨɥɵ
Ʉɪɨɦɟ
ɩɚɪɨɥɹ
ɩɨɥɶɡɨɜɚɬɟɥɹ
ɫɢɫɬɟɦɟ
ɫɜɟɞɟɧɢɹ
ɩɨɥɶɡɨɜɚɬɟɥɟɣ
20
400
ɨɥɢɱɟɫɬɜɨ
Ɋɟɞɚɤɬɨɪ
ɜɯɨɞ
ɜɵɩɨɥɧɹɬɶ
w
ɇɚɩɪɢɦɟɪ
ɤɨɦɚɧɞɵ
ɩɪɨɜɟɪɹɟɬ
ɤɨɦɚɧɞɚ
ɜɨɡɜɪɚɳɚɟɬ
ɡɧɚɱɟɧɢɟ
ɋɬɪɨɤɚ
ȿɋɅɂ
Ɋɟɞɚɤɬɨɪ
ɫɬɪɨɤɚ
101,
1,
ɫɬɪɨɤɚ
ɩɪɢɦɟɧɟɧɢɹ
. 11




80
ɡɚɩɢɫɵɜɚɟɬɫɹ
62.
Ɉɩɪɟɞɟɥɢɬɟ
ɫɢɫɬɟɦɵ
ɩɨɢɫɤɨɜɨɝɨ
ɥɨɝɢɱɟɫɤɨɣ
ɫɢɦɜɨɥ
|,
ɂɧɬɟɪɧɟɬ
|
ɋɚɬɭɪɧ
ɤɨɥɢɱɟɫɬɜɨ
ɋɚɬɭɪɧ
ɫɨɞɟɪɠɚɳɢɯ
ɜɪɟɦɹ
ɱɟɪɟɡ
ɧɚɢɦɟɧɶɲɟɝɨ
ɡɧɚɱɟɧɢɟ
1
ɧɟɨɬɪɢɰɚɬɟɥɶɧɨɦ
ɢɫɩɨɥɶɡɭɟɬɫɹ
A
0
10.
Ɂɧɚɱɟɧɢɹ
4, 3, 6, 8, 4, 8, 2, 10, 9, 14, 4
. A[0] = 4, A[1] = 3
Ɉɩɪɟɞɟɥɢɬɟ
ɡɧɚɱɟɧɢɟ
Python
FOR i = 1 TO 9
IF A(i) = A(0) THEN
c = c + 1
t = A(i+1)
A(i) = t
END IF
NEXT i
c = 0
for i in range(1,10):
if A[i] == A[0]:
c = c + 1
t = A[i+1]
A[i] = t
i
1
9
A[i] = A[0]
t := A[i+1]
A[i+1] := A[i]

for i := 1 to 9 do begin
if A[i] = A[0] then begin
c := c + 1;
t := A[i+1];
A[i+1] := A[i];
end;
end;
for (i = 1; i 10; i++) {
if (A[i] == A[0]) {
c++;
t = A[i+1];
A[i+1] = A[i];
A[i] = t;
}
}

ɍɤɚɠɢɬɟ
ɬɚɤɨɟ
100)
ɩɟɱɚɬɚɟɬ
Python
INPUT X
L = X - 30
M = X + 30
�WHILE L M
� IF L M THEN
ELSE
M = M L
END IF
WEND
PRINT M
x = int(input())
L = x-30
M = x+30
while L != M:
� if L M:
L = L - M
M = M - L
print(M)

x, L, M
x
M := x+30

� L M
� L M
L := L M
M := M L
M
begin
readln(x);
M := x+30;
� while L M do begin
� if L M
then L := L - M
else M := M L;
end;
end.
int main()
{
int x, L, M;
scanf("%d", &x);
M = x+30;
while (L != M) {
� if(L M) L = L - M;
else M = M - L;
}
printf("%d", M);

Ɉɩɪɟɞɟɥɢɬɟ
ɩɪɨɝɪɚɦɦɚ
Python
I = 1
WHILE F(I) G(I)
WEND
PRINT I
F = N * N
END FUNCTION
G = 2000*N + 3
END FUNCTION
def f(n):
i

f(i) g(i)

i
f(
n)
:= n * n
g(
n)
:= 2000*n + 3
i : longint;
begin
end;
begin
g := 2000*n + 3;
end;
i := 1;
while f(i) g(i) do
i := i*2;
writeln(i)
end.
. 11


long f(long n) {
ɷɤɪɚɧɟ
2
3
1,
2,
ɭɦɧɨɠɚɟɬ
ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ
ɤɨɦɚɧɞ
ɩɪɢ
2
ɹɜɥɹɟɬɫɹ
26

ɞɥɹ
ɬɪɚɟɤɬɨɪɢɹ
ɫɭɳɟɫɬɜɭɟɬ
x1, x2, x3, x4, x5, x6, x7, x8,
ɭɤɚɡɚɧɧɨɦɭ
x1, x2, x3, x4, x5, x6, x7, x8,
ɤɨɬɨɪɵɯ
ɜɵɩɨɥɧɟɧɨ
ɭɤɚɡɚɬɶ
ɤɨɥɢɱɟɫɬɜɨ
. 11
.

15
2016
.
2





(24–27)

ɫɧɚɱɚɥɚ



.




.
ɛɥɢɠɚɣɲɢɯ
ɜɨɡɪɚɫɬɚɧɢɹ
ɱɢɫɥɚ
9.
ɩɪɨɝɪɚɦɦɚ
INPUT N
K = 1
K = K + 1
WEND
PRINT K-1, K
END
n = int(input())
k = 1
while k*k = n:
print(k-1,k)



begin
read(n);
k := 1;
k := k + 1;
writeln(k-1, " ", k)
end.

int n, k;
k = 1;
while (k*k = n)
ɫɩɨɫɨɛ
ɩɪɢɜɟɞɺɧɧɭɸ
ɬɨɥɶɤɨ
ɨɲɢɛɨɱɧɵɟ
ɩɨɥɨɠɢɬɟɥɶɧɵɯ
ɷɥɟɦɟɧɬɨɜ
ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ
2, 3, 1, 5, 6, 4,
DIM A(N) AS INTEGER
DIM I, M, K AS INTEGER
FOR I = 1 TO N
INPUT A(I)

END
#


#
a.append(int(input()))




i
N=2016;
var
a: array [1..N] of integer;
i, m, k: integer;
for i:=1 to N do
end.
. 11

int i, m, k; for (i=0; iN; i++) scanf("%d", &a[i]);
ɦɨɠɟɬɟ
ɹɡɵɤɟ
ɢɫɩɨɥɶɡɭɟɦɭɸ
Free Pascal 2.4).
ɫɥɭɱɚɟ
ɤɚɦɧɟɣ
ɨɞɢɧ
10
ɤɚɦɧɟɣ
11,
30
ɞɟɥɚɬɶ
ɡɚɜɟɪɲɚɟɬɫɹ
ɤɚɦɧɟɣ
ɩɪɟɜɵɲɚɟɬ
ɛɵɥɨ
ɩɪɨɬɢɜɧɢɤɚ
Ɉɩɢɫɚɬɶ
ɢɝɪɨɤɚ

ɡɧɚɱɢɬ
ɡɚɞɚɧɢɹ
1
ɱɢɫɥɚ
ɜɵɢɝɪɚɬɶ
ɡɧɚɱɟɧɢɹ
ɬɚɤɨɟ
ɡɧɚɱɟɧɢɟ
ɉɟɬɹ
ɩɪɢ
ɜɵɢɝɪɚɬɶ
3
ɡɧɚɱɟɧɢɹ
ɭɤɚɡɚɧɧɵɯ
ɡɧɚɱɟɧɢɣ
ɟɫɬɶ
ɜɵɢɝɪɵɲɧɚɹ
ɢɥɢ
ɤɨɥɢɱɟɫɬɜɨ
ɰɟɥɨɱɢɫɥɟɧɧɵɦɢ
ɫɜɨɣɫɬɜɚɦɢ
ɜɟɪɲɢɧɵ
ɡɚɞɚɧɧɨɦɭ
ɩɟɪɟɫɟɤɚɟɬɫɹ
ɤɨɥɢɱɟɫɬɜɚ
ɡɚɞɚɺɬɫɹ

Ʉɚɠɞɚɹ

ɤɨɨɪɞɢɧɚɬɵ
1
10000, 1000
x, y
1000,
ɫɨɜɩɚɞɚɸɬ
ɞɚɧɧɵɟ
ɤɨɥɢɱɟɫɬɜɨ
ɬɪɟɭɝɨɥɶɧɢɤɨɜ
2016
ɛɥɢɠɚɣɲɢɯ
ɜɨɡɪɚɫɬɚɧɢɹ
ɱɢɫɥɚ
9.
ɩɪɨɝɪɚɦɦɚ
INPUT N
K = 1
WHILE K*K = N
K = K + 1
PRINT K-1, K
END
n = int(input())
k = 1
while k*k = n:
k = k + 1
print(k-1,k)



read(n);
k := 1;
while k*k = n do
k := k + 1;
end.

int n, k;
k = 1;
while (k*k = n)
k = k + 1;
printf("%d %d", k-1, k);
2016
ɫɩɨɫɨɛ
ɩɪɢɜɟɞɺɧɧɭɸ
ɦɨɠɟɬɟ
ɬɨɥɶɤɨ
ɦɨɠɟɬɟ
ɨɲɢɛɨɱɧɵɟ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
ɜɟɬɟ

ɩɨɞɯɨɞɹɳɟɟ
ɡɧɚɱɟɧɢɟ
ɤɜɚɞɪɚɬɨɜ
ɤɨɬɨɪɵɟ
ɱɚɟɬɫɹ
ɡɧɚɱɟɧɢɟ
ɬɪɟɛɭɟɬɫɹ
ɨɲɢɛɨɱɧɵɟ
ɚɥɝɨɪɢɬɦɢɱɟɫɤɨɦ
ɇɟɡɧɚɱɢɬɟɥɶɧɨɣ
ɨɩɢɫɤɨɣ
ɜɥɢɹɸɳɟɣ
ɨɰɟɧɤɭ
2016
ɬɪɢ
ɗɤɡɚɦɟɧɭɟɦɵɣ
ɩɨɥɭɱɟɧ
ɭɤɚɡɚɬɶ
ɱɢɫɥɨ
ɫɱɢɬɚɟɬɫɹ
ɗɤɡɚɦɟɧɭɟɦɵɣ
ɫɱɢɬɚɟɬɫɹ
ɜɟɪɧɵɟ
ɤɚɱɟɫɬɜɟ
ɞɨɩɭɫɤɚɸɬɫɹ
ɧɟɡɧɚɱɢɬɟɥɶɧɵɟ
ɫɢɧɬɚɤɫɢɱɟɫɤɢɟ
ɨɲɢɛɤɢ
ɫɥɭɠɟɛɧɵɯ
ɫɱɢɬɚɟɬɫɹ
ɫɥɟɞɭɸɳɢɯ
ɭɤɚɡɚɧɚ
ɤɚɱɟɫɬɜɟ
ɩɨɫɬɚɜɢɬɶ
3
ɩɪɨɝɪɚɦɦɟ
ɫɬɪɨɤɚ
ɧɚɡɜɚɧɚ
ɧɚɣɞɟɧɵ
ɫɬɪɨɤɚ
ɧɚɡɜɚɧɚ
ɨɞɧɨ
ɨɲɢɛɨɱɧɨɣ
2016
ɩɨɫɬɚɜɢɬɶ
2
3
ɧɟɫɭɳɟɫɬɜɟɧɧɨ
ɩɟɪɜɵɯ
ɂɫɩɪɚɜɥɟɧɚ
ɱɟɦ
ɧɚɡɜɚɧɚ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ
3
2016
ɱɢɫɟɥ
1000.
ɷɥɟɦɟɧɬɨɜ
ɲɟɫɬɢ
ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ
2, 3, 1, 5, 6, 4,
ɜɫɟɯ
ɷɥɟɦɟɧɬɨɜ
Python
-
#
m, k
a = []
N = 2016
for i in range(0, N):
a.append(int(input()))

25
2016
int i, m, k; for (i=0; iN; i++) scanf("%d", &a[i]);
ɦɨɠɟɬɟ
ɹɡɵɤɟ
ɢɫɩɨɥɶɡɭɟɦɭɸ
Free Pascal 2.4).
ɫɥɭɱɚɟ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
ɷɥɟɦɟɧɬɨɜ
ɜɵɱɢɫɥɹɬɶ
ɤɚɤ
ɩɟɪɟɩɨɥɧɟɧɢɹ
ɷɥɟɦɟɧɬɨɜ
ɡɧɚɱɟɧɢɸ
for i:=1 to N do begin
� if (a[i] mod 2 = 0) and (a[i]m)
then m := a[i];
� if (a[i] mod 2 = 1) and (a[i]k)
then k := a[i];
end;
�if m 0
then writeln(m)
ȼɨɡɦɨɠɧɨ
ɫɪɚɜɧɢɜɚɸɬɫɹ
ɷɥɟɦɟɧɬɨɜ
ɫɬɚɧɨɜɢɬɫɹ
2016
for i:=2 to N do begin
� if (a[i] mod 2 = m mod 2) and (a[i] m) or
(a[i] mod 2 = 0) and (m mod 2 = 1)
end;
writeln(m)
ȼɨɡɦɨɠɧɵ
ɧɟɫɤɨɥɶɤɨ

ɢɫɩɨɥɶɡɭɸɳɚɹ
ɹɡɵɤ
ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ
ɞɨɩɭɫɤɚɟɬɫɹ
ɹɡɵɤɨɦ
ɨɥɢɱɟɫɬɜɨ
ɡɚɦɵɫɥɚ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ
ɪɟɲɟɧɢɟ
ɩɨɜɬɨɪɹɟɬɫɹ
ɫɱɢɬɚɟɬɫɹ
ȼɵɱɢɫɥɟɧɢɟ
ɫɪɚɜɧɟɧɢɹ
ɨɩɪɟɞɟɥɟɧɢɢ
ɦɚɤɫɢɦɭɦɚ
ɦɚɤɫɢɦɭɦɚ
ɢɳɟɬɫɹ
ɷɥɟɦɟɧɬɚ
ɡɧɚɱɟɧɢɹ
ɜɦɟɫɬɨ
ɧɟɱɺɬɧɨɝɨ
).
ɪɟɦɟɧɧɚɹ
2016
ɦɟɧɹɟɬɫɹ
ɦɟɧɹɟɬɫɹ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ
2
ɤɚɦɧɟɣ
ɨɞɢɧ
10
ɤɚɦɧɟɣ
11,
30
ɞɟɥɚɬɶ
ɡɚɜɟɪɲɚɟɬɫɹ
ɤɚɦɧɟɣ
ɩɪɟɜɵɲɚɟɬ
ɛɵɥɨ
ɩɪɨɬɢɜɧɢɤɚ
Ɉɩɢɫɚɬɶ
ɢɝɪɨɤɚ

ɡɧɚɱɢɬ
ɡɚɞɚɧɢɹ
1
ɜɵɢɝɪɚɬɶ
ɡɧɚɱɟɧɢɹ
ɬɚɤɨɟ
ɡɧɚɱɟɧɢɟ
ɉɟɬɹ
ɩɪɢ
ɜɵɢɝɪɚɬɶ
3
ɡɧɚɱɟɧɢɹ
ɜɬɨɪɵɦ
ɧɟɡɚɜɢɫɢɦɨ
ɯɨɞɢɬɶ
ɜɵɢɝɪɵɲɧɭɸ
ɫɬɪɚɬɟɝɢɸ
ɟɫɬɶ
ɜɵɢɝɪɵɲɧɚɹ
ɫɬɪɚɬɟɝɢɹ
ɜɵɢɝɪɚɬɶ
ɫɬɪɚɬɟɝɢɸ
ɢɥɢ
ɱɟɫɬɜɨ
2016
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
= 19, , 54.
ɦɟɧɶɲɢɯ
55
ɤɚɦɧɟɣ
ɉɟɬɟ
ɤɚɦɧɟɣ
= 18
ɩɨɫɥɟ
54
ȼɚɧɹ
ɭɜɟɥɢɱɢɜɚɟɬ
ȼɨɡɦɨɠɧɵɟ
ɡɧɚɱɟɧɢɹ
Ɉɞɧɚɤɨ
18
ɤɚɦɧɟɣ
S
2
1
18
ɩɪɨɬɢɜɧɢɤ
ȼɨɡɦɨɠɧɨɟ
ɡɧɚɱɟɧɢɟ
16
45
45
3
ɩɟɪɜɵɦ
ɋɢɬɭɚɰɢɹ
16
17
ɤɚɦɧɟɣ
ɬɟɩɟɪɶ
ɫɜɨɢɦ
ɫɬɪɚɬɟɝɢɢ
ɩɨɞɱɺɪɤɧɭɬɵ
ɫɩɨɫɨɛɚ
ɩɨɫɥɟ
ɨɱɟɪɟɞɧɵɯ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ







2016



ɤɚɤ
ɩɨɤɚɡɚɧɨ
ɞɪɭɝɢɦ
ɇɚɩɪɢɦɟɪ
ɜɡɚɢɦɧɨ
ɫɨɨɬɜɟɬɫɬɜɢɢ
54
1
ɭɤɚɡɵɜɚɬɶ
2016
Ʉɨɥɢɱɟɫɬɜɨ
ɤɨɥɢɱɟɫɬɜɭ
ɩɨɞɪɨɛɧɟɟ
ɢɫɤɚɠɚɸɳɚɹ
ɡɚɦɵɫɥɚ
ɧɟɜɟɪɧɨɦɭ
ɤɨɥɢɱɟɫɬɜɚ
ɭɱɢɬɵɜɚɟɬɫɹ
ɡɚɞɚɧɢɢ
ɩɪɢɜɟɫɬɢ
ɡɧɚɱɟɧɢɹ
ɫɨɨɬɜɟɬɫɬɜɭɸɳɭɸ
(
ɡɚɞɚɧɢɟ
ɫɬɪɚɬɟɝɢɸ
ɫɬɪɚɬɟɝɢɢ
ɤɚɤ
ɫɞɟɥɚɧɨ
ɞɚɥɟɟ
ɞɨɩɭɫɤɚɸɬɫɹ
3
ɡɚɞɚɧɢɟ
ɩɨɫɬɚɜɢɬɶ
2
3
ɡɚɞɚɧɢɟ
ɡɚɞɚɧɢɟ
ɭɫɥɨɜɢɣ
1, 2
3
ɰɟɥɨɱɢɫɥɟɧɧɵɦɢ
ɫɜɨɣɫɬɜɚɦɢ
ɜɟɪɲɢɧɵ
ɡɚɞɚɧɧɨɦɭ
ɩɟɪɟɫɟɤɚɟɬɫɹ
2016
ɡɚɜɢɫɢɬ
ɤɨɥɢɱɟɫɬɜɚ
ɡɚɞɚɺɬɫɹ

ɤɨɥɢɱɟɫɬɜɨ
Ʉɚɠɞɚɹ
ɫɥɟɞɭɸɳɢɯ

ɤɨɨɪɞɢɧɚɬɵ
ɱɬɨ
1
10000, 1000
x, y
1000,
ɫɨɜɩɚɞɚɸɬ
ɞɚɧɧɵɟ
ɤɨɥɢɱɟɫɬɜɨ
ɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
ɥɟɠɚɬɶ
ɨɞɧɨɣ
ɩɨɥɭɩɥɨɫɤɨɫɬɢ
Ox
ɉɨɥɭɱɚɟɬɫɹ
ɜɟɪɲɢɧɵ
ɱɟɬɜɟɪɬɟɣ
ɦɨɠɧɨ
ɱɟɬɜɟɪɬɢ


2016
ɉɚɫɤɚɥɶ
var
N: integer; {
}
x,y: integer; {
}
n1, n2, n3, n4: integer;
{
}
s: integer; {
}
i: integer;
begin
readln(N);
n1:=0; n2:=0; n3:=0; n4:=0;
for i:=1 to N do begin
readln(x,y);
�� if (x0) and (y0) then n1 := n1+1;
� an; y0; if (x0) and (y0) then n2 := n2+1;
if (x0) and (y0) then n3 := n3+1;
end;
s := (n1*n2*(n1+n2-2) + n3*n4*(n3+n4-2)) div 2;
writeln(s)
end.
ɩɪɨɢɡɜɨɥɶɧɨɝɨ
ɧɚɥɢɱɢɟ
ɬɟɤɫɬɟ
ɧɟɜɟɪɧɨ
ɹɡɵɤɚ
ɨɩɟɪɚɰɢɹ
ɞɥɹ
ɚɟɬɫɹ
ɧɟɫɤɨɥɶɤɨ
ɫɱɢɬɚɟɬɫɹ
ɩɨɫɬɚɜɢɬɶ
4
ɷɬɨɦ
ɡɚɜɢɫɢɬ
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
ɤɨɥɢɱɟɫɬɜɚ
ɫɬɟɦɚɯ
ɩɟɪɟɦɟɧɧɵɟ
ɡɧɚɱɟɧɢɟ
0.
ɫɱɢɬɚɬɶ
ɫɪɚɜɧɟɧɢɹ
ɥɟɠɚɳɢɟ
2016
ɧɚɩɪɢɦɟɪ
2
ɚɧɚɥɨɝɢɱɧɨɦ
ɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɪɟɲɟɧɢɢ
ɚɧɚɥɨɝɢɱɧɨɦ
ɤɪɢɬɟɪɢɹɯ
ɩɨɫɬɚɜɢɬɶ
3
4
2
ɨɰɟɧɢɜɚɸɬɫɹ
ɜɫɟ
3
ɛɚɥɥɚ
ɩɨɫɬɚɜɢɬɶ
2, 3
4
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ
4


2016
ɨɰɟɧɢɜɚɧɢɹ
ɧɟɨɬɪɢɰɚɬɟɥɶɧɨɟ
ɤɜɚɞɪɚɬ
ɩɪɨɝɪɚɦɦɚ
Python
INPUT N
K = 1
K = K + 1
WEND
PRINT (K-1)*(K-1), K*K
END
n = int(input())
k = 1
while k*k = n:
print((k-1)*(k-1),k*k)
n, k
n

k*k = n

(k-1)*(k-1), " ", k*k
begin
read(n);
k := 1;
k := k + 1;
writeln((k-1)*(k-1)," ",k*k)
end.
int main(){
int n, k;
scanf("%d", &n);
k = 1;
while (k*k = n)
k = k + 1;
printf("%d %d", (k-1)*(k-1), k*k);
24
2016
ɡɧɚɱɟɧɢɟ
ɞɨɩɭɳɟɧɚ
ɭɤɚɡɚɬɶ
ɫɩɨɫɨɛ
ɩɪɢɜɟɞɺɧɧɭɸ
ɦɨɠɟɬɟ
ɬɨɥɶɤɨ
ɦɨɠɟɬɟ
ɨɲɢɛɨɱɧɵɟ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
ɨɬɜɟɬɟ
0
= 0
ɩɨɞɯɨɞɹɳɟɟ
ɡɧɚɱɟɧɢɟ
ɱɢɫɟɥ
Ⱦɥɹ
0
1
ɱɢɫɥɚ
ɩɨɷɬɨɦɭ
= 0
ɩɨɥɭɱɚɬɶɫɹ
Ɉɞɧɚɤɨ
0 1
1 4,
ɡɧɚɱɟɧɢɟ
ɬɪɟɛɭɟɬɫɹ
ɨɲɢɛɤɚ
ɇɟɡɧɚɱɢɬɟɥɶɧɨɣ
ɨɩɢɫɤɨɣ
ɜɥɢɹɸɳɟɣ
ɨɰɟɧɤɭ
ɩɨɫɥɟ
2016
ɬɪɢ
ɗɤɡɚɦɟɧɭɟɦɵɣ
ɩɨɥɭɱɟɧ
ɭɤɚɡɚɬɶ
ɱɢɫɥɨ
ɫɱɢɬɚɟɬɫɹ
ɫɱɢɬɚɟɬɫɹ
ɭɤɚɡɚɧɵ
ɜɟɪɧɵɟ
ɤɚɱɟɫɬɜɟ
ɢɫɩɪɚɜɥɟɧɧɨɣ
ɞɨɩɭɫɤɚɸɬɫɹ
ɫɢɧɬɚɤɫɢɱɟɫɤɢɟ
ɨɲɢɛɤɢ
ɫɥɭɠɟɛɧɵɯ
ɫɱɢɬɚɟɬɫɹ
ɫɥɟɞɭɸɳɢɯ
ɭɤɚɡɚɧɚ
ɤɚɱɟɫɬɜɟ
ɩɨɫɬɚɜɢɬɶ
3
ɢɫɩɪɚɜɥɟɧɚ
ɫɬɪɨɤɚ
ɧɚɡɜɚɧɚ
ɨɞɧɚ
2016
ɩɨɫɬɚɜɢɬɶ
2
3
ɧɟɫɭɳɟɫɬɜɟɧɧɨ
ɨɲɢɛɤɢ
ɱɟɦ
ɩɪɚɜɢɥɶɧɨ
ɜɵɩɨɥɧɟɧɵ
1
ɂɫɩɪɚɜɥɟɧɚ
ɱɟɦ
ɧɚɡɜɚɧɚ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ
2016
ɩɨɥɨɠɢɬɟɥɶɧɵɯ
1000.
ɷɥɟɦɟɧɬɨɜ
ɲɟɫɬɢ
ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ
2, 3, 1, 5, 6, 4,
ɧɢɠɟ
Python
-
#
m, k
a = []
N = 2016
for i in range(0, N):
a.append(int(input()))
2016
int i, m, k; for (i=0; iN; i++) scanf("%d", &a[i]);
ɦɨɠɟɬɟ
ɹɡɵɤɟ
ɢɫɩɨɥɶɡɭɟɦɭɸ
Free Pascal 2.4).
ɫɥɭɱɚɟ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
ɷɥɟɦɟɧɬɨɜ
ɜɵɱɢɫɥɹɬɶ
ɤɚɤ
ɩɟɪɟɩɨɥɧɟɧɢɹ
ɷɥɟɦɟɧɬɨɜ
ɡɧɚɱɟɧɢɸ
for i:=1 to N do begin
if (a[i] mod 2 = 0) and (a[i]m)
then m := a[i];
if (a[i] mod 2 = 1) and (a[i]k)
then k := a[i];
if m 1001
then writeln(m)
else writeln(k)
ȼɨɡɦɨɠɧɨ
ɫɪɚɜɧɢɜɚɸɬɫɹ
ɷɥɟɦɟɧɬɚ
ɷɥɟɦɟɧɬɨɜ
ɫɬɚɧɨɜɢɬɫɹ
2016
for i:=2 to N do begin
if (a[i] mod 2 = m mod 2) and (a[i] m) or
(a[i] mod 2 = 0) and (m mod 2 = 1)
end;
writeln(m)
ȼɨɡɦɨɠɧɵ
ɧɟɫɤɨɥɶɤɨ
ɧɟɬɢɩɢɡɢɪɨɜɚɧɧɵɯ
ɞɨɩɭɫɤɚɟɬɫɹ
ɹɡɵɤɨɦ
ɤɨɥɢɱɟɫɬɜɨ
ɚɜɬɨɪɚ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ
ɰɟɥɨɦ
ɪɟɲɟɧɢɟ
ɫɥɟɞɭɸɳɢɯ
ɫɱɢɬɚɟɬɫɹ
ȼɵɱɢɫɥɟɧɢɟ
ɜɫɟɯ
ɛɟɡ
ɫɪɚɜɧɟɧɢɹ
ɨɩɪɟɞɟɥɟɧɢɢ
ɢɳɟɬɫɹ
ɷɥɟɦɟɧɬɚ
ɡɧɚɱɟɧɢɹ
ɪɟɦɟɧɧɚɹ
2016
ɦɟɧɹɟɬɫɹ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ
ɤɚɦɧɟɣ
ɨɞɢɧ
10
ɤɚɦɧɟɣ
11,
30
ɟɫɬɶ
ɡɚɜɟɪɲɚɟɬɫɹ
ɤɚɦɧɟɣ
ɩɪɟɜɵɲɚɟɬ
ɛɵɥɨ
ɩɪɨɬɢɜɧɢɤɚ
Ɉɩɢɫɚɬɶ
ɢɝɪɨɤɚ

ɡɧɚɱɢɬ
ɡɚɞɚɧɢɹ
1
ɜɵɢɝɪɚɬɶ
ɡɧɚɱɟɧɢɹ
ɬɚɤɨɟ
ɡɧɚɱɟɧɢɟ
ɉɟɬɹ
ɩɪɢ
ɜɵɢɝɪɚɬɶ
3
ɡɧɚɱɟɧɢɹ
ɜɬɨɪɵɦ
ɧɟɡɚɜɢɫɢɦɨ
ɯɨɞɢɬɶ
ɜɵɢɝɪɵɲɧɭɸ
ɫɬɪɚɬɟɝɢɸ
ɟɫɬɶ
ɜɵɢɝɪɵɲɧɚɹ
ɫɬɪɚɬɟɝɢɹ
ɫɬɪɚɬɟɝɢɸ
ɢɥɢ
ɱɟɫɬɜɨ
2016
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
1.
ɉɟɬɹ
ɜɵɢɝɪɚɬɶ
= 22, , 64.
65
ɤɚɦɧɟɣ
ɉɟɬɟ
ɤɨɥɢɱɟɫɬɜɨ
= 21
ɤɚɦɟɧɶ
63
2.
ȼɨɡɦɨɠɧɵɟ
ɡɧɚɱɟɧɢɹ
ɷɬɢɯ
ɉɟɬɹ
21
S
ɤɨɥɢɱɟɫɬɜɨ
2
= 20
1
21
ɫɥɟɞɭɸɳɢɦ
3.
ȼɨɡɦɨɠɧɨɟ
ɡɧɚɱɟɧɢɟ
ɩɟɪɜɨɝɨ
19
ɤɚɦɧɟɣ
54
ɫɬɚɧɟɬ
54
3
19
20
ɬɟɩɟɪɶ
ɫɜɨɢɦ
ɞɟɪɟɜɨ
ɩɨɫɥɟ
ɨɱɟɪɟɞɧɵɯ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ








2016



ɩɨɤɚɡɚɧɨ
ɞɪɭɝɢɦ
ɇɚɩɪɢɦɟɪ
ɜɟɪɲɢɧɵ
ɫɤɥɟɟɧɵ
ȼɚɠɧɨ
ɩɨɡɢɰɢɹɯ
ɟɫɬɶ
63
ɞɨɛɚɜɢɬɶ
2
ɤɚɦɧɹ
ɭɤɚɡɵɜɚɬɶ
2016
Ʉɨɥɢɱɟɫɬɜɨ
ɢɫɤɚɠɚɸɳɚɹ
ɤɨɥɢɱɟɫɬɜɚ
ɡɚɤɥɸɱɢɬɟɥɶɧɨɣ
ɭɱɢɬɵɜɚɟɬɫɹ
ɤɚɠɞɨɦ
ɡɚɞɚɧɢɢ
ɡɧɚɱɟɧɢɹ
ɫɨɨɬɜɟɬɫɬɜɭɸɳɭɸ
ɫɬɪɚɬɟɝɢɸ
ɨɞɧɨ
(
ɪɟɲɟɧɢɹ
ɢɥɢ
ɞɚɥɟɟ
ɞɨɩɭɫɤɚɸɬɫɹ
ɜɵɩɨɥɧɟɧɵ
3
ɡɚɞɚɧɢɟ
ɩɨɫɬɚɜɢɬɶ
2
3
ɡɚɞɚɧɢɟ
ɡɚɞɚɧɢɟ
1, 2
3
ɰɟɥɨɱɢɫɥɟɧɧɵɦɢ
ɫɜɨɣɫɬɜɚɦɢ
ɜɟɪɲɢɧɵ
ɡɚɞɚɧɧɨɦɭ
ɩɟɪɟɫɟɤɚɟɬɫɹ
2016
ɡɚɜɢɫɢɬ
ɤɨɥɢɱɟɫɬɜɚ
ɡɚɞɚɺɬɫɹ

ɤɨɥɢɱɟɫɬɜɨ
Ʉɚɠɞɚɹ
ɫɥɟɞɭɸɳɢɯ

ɤɨɨɪɞɢɧɚɬɵ
ɱɬɨ
1
10000, 1000
x, y
1000,
ɫɨɜɩɚɞɚɸɬ
ɞɚɧɧɵɟ
ɤɨɥɢɱɟɫɬɜɨ
ɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
ɩɟɪɟɫɟɤɚɥɫɹ
Oy
ɉɨɥɭɱɚɟɬɫɹ
ɱɟɬɜɟɪɬɟɣ
ɱɟɫɬɜɨ
ɇɚɩɪɢɦɟɪ
ɱɟɬɜɟɪɬɢ

ɱɟɬɜɟɪɬɢ

ɱɟɬɜɺɪɬɨɣ
ɤɨɥɢɱɟɫɬɜɨ
2016
ɉɚɫɤɚɥɶ
var
N: integer; {
}
x,y: integer; {
}
n1, n2, n3, n4: integer;
}
s: integer; {
}
i: integer;
begin
readln(N);
n1:=0; n2:=0; n3:=0; n4:=0;
for i:=1 to N do begin
�� if (x0) and (y0) then n1 := n1+1;
� an; y0; if (x0) and (y0) then n2 := n2+1;
if (x0) and (y0) then n3 := n3+1;
� if (x0) and (y0) then n4 := n4+1;
end;
s := (n1*n4*(n1+n4-2) + n2*n3*(n2+n3-2)) div 2;
writeln(s)
end.

ɩɪɨɢɡɜɨɥɶɧɨɝɨ
ɧɚɥɢɱɢɟ
ɬɟɤɫɬɟ
ɧɟɜɟɪɧɨ
ɹɡɵɤɚ
ɨɩɟɪɚɰɢɹ
ɞɥɹ
ɚɟɬɫɹ
ɧɟɫɤɨɥɶɤɨ
ɫɱɢɬɚɟɬɫɹ
ɩɨɫɬɚɜɢɬɶ
4
ɷɬɨɦ
ɡɚɜɢɫɢɬ
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
ɤɨɥɢɱɟɫɬɜɚ
ɫɬɟɦɚɯ
ɩɟɪɟɦɟɧɧɵɟ
ɡɧɚɱɟɧɢɟ
0.
ɫɱɢɬɚɬɶ
ɫɪɚɜɧɟɧɢɹ
ɥɟɠɚɳɢɟ
2016
ɜɟɪɲɢɧ
ɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɪɟɲɟɧɢɢ
ɚɧɚɥɨɝɢɱɧɨɦ
ɛɚɥɥɚ
ɩɨɫɬɚɜɢɬɶ
3
4
2
ɨɰɟɧɢɜɚɸɬɫɹ
ɜɫɟ
3
ɛɚɥɥɚ
ɩɨɫɬɚɜɢɬɶ
2, 3
4
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ
4

ɧɟɨɬɪɢɰɚɬɟɥɶɧɨɟ
ɤɜɚɞɪɚɬ
3
ɩɪɨɝɪɚɦɦɚ
INPUT N
K = 1
WHILE K*K = N
K = K + 1
WEND
PRINT (K-1)*(K-1), K*K
END
n = int(input())
while k*k = n:
k = k + 1
print((k-1)*(k-1),k*k)



read(n);
k := 1;
while k*k = n do
k := k + 1;
writeln((k-1)*(k-1)," ",k*k)
end.

int main(){
int n, k;
scanf("%d", &n);
k = 1;
while (k*k = n)
= 2016
ɡɧɚɱɟɧɢɟ
)
ɞɨɩɭɳɟɧɚ
ɩɪɢɜɟɞɺɧɧɭɸ
ɬɨɥɶɤɨ
ɨɲɢɛɨɱɧɵɟ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
2025
= 0
ɨɬɜɟɬɟ
1
= 0 –
ɩɨɞɯɨɞɹɳɟɟ
ɡɧɚɱɟɧɢɟ
ɱɢɫɟɥ
Ⱦɥɹ
ɱɢɫɥɚ
= 0
ɩɨɥɭɱɚɬɶɫɹ
Ɉɞɧɚɤɨ
ɪɟɡɭɥɶɬɚɬɚ
= 0
ɡɧɚɱɟɧɢɟ
ɬɪɟɛɭɟɬɫɹ
ɨɰɟɧɤɭ
ɩɨɫɥɟ
































































































































11


10503 3
2016
.





ɬɪɢ
1
ɗɤɡɚɦɟɧɭɟɦɵɣ
ɩɨɥɭɱɟɧ
ɭɤɚɡɚɬɶ
ɱɢɫɥɨ
2
3
ɬɚɟɬɫɹ
ɜɟɪɧɵɟ
ɢɫɩɪɚɜɥɟɧɧɨɣ
ɞɨɩɭɫɤɚɸɬɫɹ
ɫɢɧɬɚɤɫɢɱɟɫɤɢɟ
ɨɲɢɛɤɢ
ɫɥɭɠɟɛɧɵɯ
)
ɫɱɢɬɚɟɬɫɹ
ɫɥɟɞɭɸɳɢɯ
ɭɤɚɡɚɧɚ
ɤɚɱɟɫɬɜɟ
ɢɫɩɪɚɜɥɟɧɚ
ɫɬɪɨɤɚ
ɧɚɡɜɚɧɚ
ɧɟɫɭɳɟɫɬɜɟɧɧɨ
ɷɬɨɦ
ɧɟɫɭɳɟɫɬɜɟɧɧɨ
2
ɨɤɚ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ

3
ɱɢɫɟɥ
1000
ɷɥɟɦɟɧɬɨɜ
ɲɟɫɬɢ
ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ
2, 3, 1, 5, 6, 4,
ɜɫɟɯ
ɷɥɟɦɟɧɬɨɜ
6
DIM A(N) AS INTEGER
DIM I, M, K AS INTEGER
INPUT A(I)
NEXT I

END
#

-
#


#
m, k
a = []
N = 2016
for i in range(0, N):
a.append(int(input()))






N=2016
a[1:N]
i, m, k
i
a[i]


N=2016;
var
a: array [1..N] of integer;
begin
for i:=1 to N do
readln(a[i]);

end.
11


10503 5
2016
.

int i, m, k; for (i=0; iN; i++) scanf("%d", &a[i]);
ɦɨɠɟɬɟ
ɡɚɩɢɫɚɬɶ
ɹɡɵɤɟ
ɢɫɩɨɥɶɡɭɟɦɭɸ
Free Pascal 24)
ɫɥɭɱɚɟ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
ɷɥɟɦɟɧɬɨɜ
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
ɩɪɨɢɡɜɟɞɟɧɢɹ
ɩɟɪɟɩɨɥɧɟɧɢɹ
ɡɚɦɟɬɢɬɶ
ɟɫɬɶ
ɦɚɫɫɢɜɟ
ɱɺɬɧɵɯ
ɡɧɚɱɟɧɢɸ





(

for i:=1 to N do begin
� if (a[i] mod 2 = 0) and (a[i]m)
then m := a[i];
� if (a[i] mod 2 = 1) and (a[i]k)
then k := a[i];
end;
�if m 0
then writeln(m)

ɨɱɟɪɟɞɢ
ɨɛɵɱɧɨɦ
ɬɟɤɭɳɢɦ
ɦɚɤɫɢɦɭɦɨɦ
11


10503 6
2016
.





(
� if (a[i] mod 2 = m mod 2) and (a[i] m) or
(a[i] mod 2 = 0) and (m mod 2 = 1)
end;
writeln(m)




,




/








ɢɫɩɨɥɶɡɭɸɳɚɹ
ɹɡɵɤ
ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ
ɹɡɵɤɨɦ
ɜɨ
ɡɚɦɵɫɥɚ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ
ɪɟɲɟɧɢɟ
ɩɨɜɬɨɪɹɟɬɫɹ
ɫɱɢɬɚɟɬɫɹ
)
ɢɹ
ɨɩɪɟɞɟɥɟɧɢɢ
ɦɚɤɫɢɦɭɦɚ
ɦɚɤɫɢɦɭɦɚ
ɢɳɟɬɫɹ
)
ɷɥɟɦɟɧɬɚ
ɡɧɚɱɟɧɢɹ
ɜɦɟɫɬɨ
ɧɟɱɺɬɧɨɝɨ
)
ɪɟɦɟɧɧɚɹ





























































































































































































































































































ɦɟɧɹɟɬɫɹ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ

2
ɤɚɦɧɟɣ
ɨɞɢɧ
ɤɚɦɧɟɣ
ɡɚɜɟɪɲɚɟɬɫɹ
ɤɚɦɧɟɣ
ɩɪɟɜɵɲɚɟɬ
64
64
ɩɪɨɬɢɜɧɢɤɚ
Ɉɩɢɫɚɬɶ
ɢɝɪɨɤɚ
ɡɧɚɱɢɬ
ɡɚɞɚɧɢɹ
ɡɧɚɱɟɧɢɹ
ɬɚɤɨɟ
ɡɧɚɱɟɧɢɟ
ɉɟɬɹ
ɩɪɢ
ɜɵɢɝɪɚɬɶ
ɡɧɚɱɟɧɢɹ
ɪɵɦ
ɧɟɡɚɜɢɫɢɦɨ
ɛɭɞɟɬ
ɯɨɞɢɬɶ
ɜɵɢɝɪɵɲɧɭɸ
ɫɬɪɚɬɟɝɢɸ
ɟɫɬɶ
ɜɵɢɝɪɵɲɧɚɹ
)
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
ɉɟɬɹ
ɜɵɢɝɪɚɬɶ
= 22, , 64
ɤɚɦɧɟɣ
ɉɟɬɟ
ɤɨɥɢɱɟɫɬɜɨ
ɤɚɦɟɧɶ
: 7, 19, 20
ɷɬɢɯ
ɉɟɬɹ
ɤɨɥɢɱɟɫɬɜɨ
ɡɧɚɱɟɧɢɟ
: 18
ɩɟɪɜɨɝɨ
ɫɬɚɧɟɬ
2
ɬɟɩɟɪɶ
ɫɜɨɢɦ
ɪɟɜɨ
)
ɩɨɫɥɟ
ɨɱɟɪɟɞɧɵɯ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ
18+1 =

19+2 =

21+1 =

22*3 =
��66


23*3 =
��69

63


63*3 =
��189


20


20+1 =

21+1 =

22*3 =
��66

11


10503 9
2016
.
21+2 =

23*3 =
��69

63


63*3 =
��189



ɩɨɤɚɡɚɧɨ
ɞɪɭɝɢɦ
ɇɚɩɪɢɦɟɪ
ɜɟɪɲɢɧɵ
ɫɤɥɟɟɧɵ
»
ȼɚɠɧɨ
ɩɨɡɢɰɢɹɯ
ɟɫɬɶ
ɞɨɛɚɜɢɬɶ
ɤɚɦɧɹ
11


10503 10
2016
.





)
ɢɫɤɚɠɚɸɳɚɹ
ɤɨɥɢɱɟɫɬɜɚ
ɡɚɤɥɸɱɢɬɟɥɶɧɨɣ
ɭɱɢɬɵɜɚɟɬɫɹ
ɤɚɠɞɨɦ
ɫɨɨɬɜɟɬɫɬɜɭɸɳɭɸ
ɨɞɧɨ
ɪɟɲɟɧɢɹ
ɢɥɢ
ɞɚɥɟɟ
ɞɨɩɭɫɤɚɸɬɫɹ
ɜɵɩɨɥɧɟɧɵ
ɡɚɞɚɧɢɟ
2
ɡɚɞɚɧɢɟ
ɡɚɞɚɧɢɟ
2



,

1, 2
3

0

3
ɫɜɨɣɫɬɜɚɦɢ
ɜɟɪɲɢɧɵ
ɡɚɞɚɧɧɨɦɭ
ɩɟɪɟɫɟɤɚɟɬɫɹ











































































































































































































ɡɚɜɢɫɢɬ
ɤɨɥɢɱɟɫɬɜɚ
ɡɚɞɚɺɬɫɹ
Ʉɚɠɞɚɹ
ɤɨɨɪɞɢɧɚɬɵ
ɱɬɨ
ɫɨɜɩɚɞɚɸɬ
ɞɚɧɧɵɟ
ɤɨɥɢɱɟɫɬɜɨ
ɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
ɥɟɠɚɬɶ
ɨɞɧɨɣ
ɩɨɥɭɩɥɨɫɤɨɫɬɢ
ɜɟɪɲɢɧɵ
ɥɟɠɚɬɶ
ɱɟɬɜɟɪɬɟɣ
ɦɨɠɧɨ
ɱɟɬɜɟɪɬɢ
/2
ɉɚɫɤɚɥɶ
var
N: integer; {

}
x,y: integer; {


}
n1, n2, n3, n4: integer;
{


}
s: integer; {

}
i: integer;
readln(N);
n1:=0; n2:=0; n3:=0; n4:=0;
for i:=1 to N do begin
readln(x,y);
�� if (x0) and (y0) then n1 := n1+1;
� an; y0; if (x0) and (y0) then n2 := n2+1;
if (x0) and (y0) then n3 := n3+1;
end;
s := (n1*n2*(n1+n2-2) + n3*n4*(n3+n4-2)) div 2;
writeln(s)
end.



ɩɪɨɢɡɜɨɥɶɧɨɝɨ
ɧɚɥɢɱɢɟ
ɬɟɤɫɬɟ
ɧɟɜɟɪɧɨ
ɹɡɵɤɚ
ɨɩɟɪɚɰɢɹ
ɞɥɹ
ɚɟɬɫɹ
ɫɱɢɬɚɟɬɫɹ
)
ɷɬɨɦ
ɡɚɜɢɫɢɬ
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
ɤɨɥɢɱɟɫɬɜɚ
ɫɢɫɬɟɦɚɯ
ɩɟɪɟɦɟɧɧɵɟ
ɡɧɚɱɟɧɢɟ
0
ɫɱɢɬɚɬɶ
ɥɟɠɚɳɢɟ
ɧɚɩɪɢɦɟɪ
)
ɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɪɟɲɟɧɢɢ
ɚɧɚɥɨɝɢɱɧɨɦ
)
ɤɪɢɬɟɪɢɹɯ
ɜɫɟ
ɛɚɥɥɚ


2, 3
4
,






1
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ

4





































































































































































ɨɰɟɧɢɜɚɧɢɹ
ɛɥɢɠɚɣɲɢɯ
ɜɨɡɪɚɫɬɚɧɢɹ
ɱɢɫɥɚ
9
ɩɪɨɝɪɚɦɦɚ
INPUT N
K = 1
WHILE K*K = N
K = K + 1
WEND
PRINT K-1, K
END
n = int(input())
while k*k = n:
k = k + 1
print(k-1,k)






k-1, " ", k
read(n);
k := 1;
while k*k = n do
k := k + 1;
writeln(k-1, " ", k)
end.


int n, k;
scanf("%d", &n);
k = 1;
while (k*k = n)
k = k + 1;
printf("%d %d", k-1, k);
24
ɷɬɚ
= 2016
ɡɧɚɱɟɧɢɟ
ɜɫɟ
)
ɤɚɠɞɨɣ
ɫɩɨɫɨɛ
ɩɪɢɜɟɞɺɧɧɭɸ
ɬɨɥɶɤɨ
ɨɲɢɛɨɱɧɵɟ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
45
= 0
ɨɬɜɟɬɟ
1
= 0 –
ɩɨɞɯɨɞɹɳɟɟ
ɡɧɚɱɟɧɢɟ
ɤɜɚɞɪɚɬɨɜ
ɱɚɟɬɫɹ
= 0
ɡɧɚɱɟɧɢɟ
ɬɪɟɛɭɟɬɫɹ
ɲɢɛɨɱɧɵɟ
ɚɥɝɨɪɢɬɦɢɱɟɫɤɨɦ
ɇɟɡɧɚɱɢɬɟɥɶɧɨɣ
ɨɩɢɫɤɨɣ
ɨɰɟɧɤɭ
11


10504 3
2016
.



ɬɪɢ
1
ɗɤɡɚɦɟɧɭɟɦɵɣ
ɩɨɥɭɱɟɧ
ɭɤɚɡɚɬɶ
ɱɢɫɥɨ
2
ɫɱɢɬɚɟɬɫɹ
3
ɚɟɬɫɹ
ɜɟɪɧɵɟ
ɜɟ
ɞɨɩɭɫɤɚɸɬɫɹ
ɫɢɧɬɚɤɫɢɱɟɫɤɢɟ
ɨɲɢɛɤɢ
ɫɥɭɠɟɛɧɵɯ
)
ɫɱɢɬɚɟɬɫɹ
ɫɥɟɞɭɸɳɢɯ
ɭɤɚɡɚɧɚ
ɤɚɱɟɫɬɜɟ
ɩɪɨɝɪɚɦɦɟ
ɫɬɪɨɤɚ
ɧɚɡɜɚɧɚ
ɫɬɪɨɤɚ
ɧɚɡɜɚɧɚ
ɨɞɧɨ
ɲɢɛɨɱɧɨɣ
ɧɟɫɭɳɟɫɬɜɟɧɧɨ
2
ɂɫɩɪɚɜɥɟɧɚ
ɧɚɡɜɚɧɚ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ

3
ɩɨɥɨɠɢɬɟɥɶɧɵɯ
1000
ɷɥɟɦɟɧɬɨɜ
ɲɟɫɬɢ
ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ
2, 3, 1, 5, 6, 4,
2
DIM A(N) AS INTEGER
DIM I, M, K AS INTEGER
INPUT A(I)
NEXT I

END

#

-
#


#
m, k
a = []
N = 2016
for i in range(0, N):
a.append(int(input()))







N=2016
a[1:N]
i, m, k
i
a[i]


N=2016;
var
a: array [1..N] of integer;
i, m, k: integer;
begin
for i:=1 to N do
readln(a[i]);

end.











































































































































































































































11


10504 5
2016
.

int i, m, k; for (i=0; iN; i++) scanf("%d", &a[i]);
ɦɨɠɟɬɟ
ɡɚɩɢɫɚɬɶ
ɹɡɵɤɟ
ɢɫɩɨɥɶɡɭɟɦɭɸ
Free Pascal 24)
ɫɥɭɱɚɟ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
ɷɥɟɦɟɧɬɨɜ
ɩɟɪɟɩɨɥɧɟɧɢɹ
ɡɧɚɱɟɧɢɸ





(

for i:=1 to N do begin
if (a[i] mod 2 = 0) and (a[i]m)
then m := a[i];
if (a[i] mod 2 = 1) and (a[i]k)
then k := a[i];
end;
then writeln(m)
else writeln(k)

ɫɪɚɜɧɢɜɚɸɬɫɹ
ɷɥɟɦɟɧɬɚ
11


10504 6
2016
.





(
if (a[i] mod 2 = m mod 2) and (a[i] m) or
(a[i] mod 2 = 0) and (m mod 2 = 1)
end;
writeln(m)

ɧɟɫɤɨɥɶɤɨ



ɧɟɬɢɩɢɡɢɪɨɜɚɧɧɵɯ
ɹɡɵɤɨɦ
ɚɜɬɨɪɚ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ
ɰɟɥɨɦ
ɪɟɲɟɧɢɟ
ɫɥɟɞɭɸɳɢɯ
ɫɱɢɬɚɟɬɫɹ
)
ɜɫɟɯ
ɛɟɡ
ɢɹ
ɨɩɪɟɞɟɥɟɧɢɢ
ɢɳɟɬɫɹ
)
ɷɥɟɦɟɧɬɚ
ɡɧɚɱɟɧɢɹ
)
ɪɟɦɟɧɧɚɹ
ɦɟɧɹɟɬɫɹ
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ


2
ɤɚɦɧɟɣ
ɨɞɢɧ
ɤɚɦɧɟɣ
ɤɚɦɧɟɣ
ɞɟɥɚɬɶ
ɡɚɜɟɪɲɚɟɬɫɹ
ɤɚɦɧɟɣ
ɩɪɟɜɵɲɚɟɬ
54
54
ɩɪɨɬɢɜɧɢɤɚ
Ɉɩɢɫɚɬɶ
ɢɝɪɨɤɚ
ɡɧɚɱɢɬ
ɡɚɞɚɧɢɹ
ɬɚɤɨɟ
ɡɧɚɱɟɧɢɟ
ɉɟɬɹ
ɩɪɢ
ɜɵɢɝɪɚɬɶ
ɜɬɨɪɵɦ
ɧɟɡɚɜɢɫɢɦɨ
ɯɨɞɢɬɶ
ɜɵɢɝɪɵɲɧɭɸ
ɫɬɪɚɬɟɝɢɸ
ɟɫɬɶ
ɜɵɢɝɪɵɲɧɚɹ
)
ɤɨɥɢɱɟɫɬ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
= 19, , 54
ɦɟɧɶɲɢɯ
ɤɚɦɧɟɣ
ɉɟɬɟ
ɤɚɦɧɟɣ
ɩɨɫɥɟ
ɤɚɦɧɟɣ
ȼɚɧɹ
ɡɧɚɱɟɧɢɹ
: 6, 16, 17
Ɉɞɧɚɤɨ
ɤɚɦɧɟɣ
ɡɧɚɱɟɧɢɟ
: 15
ɫɬɚɧɟɬ
ɤɚɦɧɟɣ
2
ɬɟɩɟɪɶ
ɫɜɨɢɦ
ɩɨɞɱɺɪɤɧɭɬɵ
ɫɩɨɫɨɛɚ
)
ɩɨɫɥɟ
ɨɱɟɪɟɞɧɵɯ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ
ɭɤɚɡɚɧɚ
15+1 =

16+2 =

18+1 =

19*3 =
��57


20*3 =
��60

54


54*3 =
��162


17


17+1 =

18+1 =

19*3 =
��57










































































































































































































































































11


10504 9
2016
.
18+2 =

20*3 =
��60

54


54*3 =
��162



ɩɨɤɚɡɚɧɨ
ɞɪɭɝɢɦ
ɇɚɩɪɢɦɟɪ
»
ɜɡɚɢɦɧɨ
ɫɨɨɬɜɟɬɫɬɜɢɢ
. 1.


,

.



.








:
54


1

,



,











11


10504 10
2016
.




ɩɨɞɪɨɛɧɟɟ
)
ɢɫɤɚɠɚɸɳɚɹ
ɡɚɦɵɫɥɚ
ɧɟɜɟɪɧɨɦɭ
ɤɨɥɢɱɟɫɬɜɚ
ɭɱɢɬɵɜɚɟɬɫɹ
ɫɨɨɬɜɟɬɫɬɜɭɸɳɭɸ
ɡɚɞɚɧɢɟ
ɫɞɟɥɚɧɨ
ɞɚɥɟɟ
ɞɨɩɭɫɤɚɸɬɫɹ
ɡɚɞɚɧɢɟ
2
ɡɚɞɚɧɢɟ
ɡɚɞɚɧɢɟ
2
ɭɫɥɨɜɢɣ

3
ɫɜɨɣɫɬɜɚɦɢ
ɜɟɪɲɢɧɵ
ɡɚɞɚɧɧɨɦɭ
ɩɟɪɟɫɟɤɚɟɬɫɹ
ɡɚɜɢɫɢɬ
ɤɨɥɢɱɟɫɬɜɚ
ɡɚɞɚɺɬɫɹ
Ʉɚɠɞɚɹ
ɳɢɯ
ɤɨɨɪɞɢɧɚɬɵ
ɱɬɨ
ɫɨɜɩɚɞɚɸɬ
ɞɚɧɧɵɟ
ɤɨɥɢɱɟɫɬɜɨ
ɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɜɟɪɧɨɝɨ
ɨɰɟɧɢɜɚɧɢɸ
ɨɫɶɸ
ɥɟɠɚɬɶ
ɥɟɠɚɬɶ
ɥɟɠɚɬɶ
ɜɟɪɲɢɧɵ
ɩɨɞɫɱɢɬɚɬɶ
ɤɨɥɢɱɟɫɬɜɨ
ɇɚɩɪɢɦɟɪ
ɱɟɬɜɟɪɬɢ
ɥɟɠɚɬ
/2
ɉɚɫɤɚɥɶ
var
N: integer; {

}
x,y: integer; {


}
n1, n2, n3, n4: integer;


}
s: integer; {

}
i: integer;
begin
readln(N);
n1:=0; n2:=0; n3:=0; n4:=0;
for i:=1 to N do begin
�� if (x0) and (y0) then n1 := n1+1;
� an; y0; if (x0) and (y0) then n2 := n2+1;
if (x0) and (y0) then n3 := n3+1;
� if (x0) and (y0) then n4 := n4+1;
end;
s := (n1*n4*(n1+n4-2) + n2*n3*(n2+n3-2)) div 2;
writeln(s)
end.



ɩɪɨɢɡɜɨɥɶɧɨɝɨ
ɧɚɥɢɱɢɟ
ɬɟɤɫɬɟ
ɧɟɜɟɪɧɨ
ɹɡɵɤɚ
ɨɩɟɪɚɰɢɹ
ɞɥɹ
ɧɟɫɤɨɥɶɤɨ
ɫɱɢɬɚɟɬɫɹ
)
ɷɬɨɦ
ɡɚɜɢɫɢɬ
ɫɨɨɬɜɟɬɫɬɜɭɟɬ
ɤɨɥɢɱɟɫɬɜɚ
ɩɟɪɟɦɟɧɧɵɟ
ɡɧɚɱɟɧɢɟ
0
ɫɱɢɬɚɬɶ
ɥɟɠɚɳɢɟ


























































































































































ɜɟɪɲɢɧ
ɪɟɲɟɧɢɢ
)
ɬɪɟɭɝɨɥɶɧɢɤɨɜ
ɪɟɲɟɧɢɢ
ɚɧɚɥɨɝɢɱɧɨɦ
)
ɥɥɚ
ɜɫɟ
ɥɥɚ


2, 3
4
,






1
ɩɨɡɜɨɥɹɸɳɢɟ
ɩɨɫɬɚɜɢɬɶ

4


Приложенные файлы

  • pdf 8815493
    Размер файла: 1 006 kB Загрузок: 0

Добавить комментарий