ΠΡΠΎΠ³ΡΠ°ΠΌΠΌΠΈΡΠΎΠ²Π°Π½ΠΈΠ΅ Π½Π° C/C++
ΠΠ°ΠΏΠΎΠ»Π½Π΅Π½ΠΈΠ΅ Π΄Π°Π½Π½ΡΠΌΠΈ ΠΌΠ°ΡΡΠΈΠ²Π°, ΡΠΎΡΡΠΎΡΡΠ΅Π³ΠΎ ΠΈΠ· Π²ΠΎΡΡΠΌΠΈ ΡΡΡΡΠΊΡΡΡ ΡΠΈΠΏΠ° STUDENT; Π£ΠΏΠΎΡΡΠ΄ΠΎΡΠ΅Π½ΠΈΠ΅ Π·Π°ΠΏΠΈΡΠ΅ΠΉ ΠΏΠΎ Π²ΠΎΠ·ΡΠ°ΡΡΠ°Π½ΠΈΡ ΡΠ°ΠΊΡΠ»ΡΡΠ΅ΡΠ° ΠΈ Π½ΠΎΠΌΠ΅ΡΠ° Π³ΡΡΠΏΠΏΡ; ΠΠ΅ΡΠ΅ΠΌΠ΅Π½Π½ΡΡ f, Ρ ΡΠ°Π½ΡΡΡΡ ΠΈΠ½Π΄Π΅ΠΊΡ ΠΎΡΡΠΎΡΡΠΈΡΠΎΠ²Π°Π½Π½ΠΎΠ³ΠΎ Π·Π½Π°ΡΠ΅Π½ΠΈΡ Π²Π΅ΠΊΡΠΎΡΠ°. ΠΠ²Π΅ΡΡΠΈ Ρ ΠΊΠ»Π°Π²ΠΈΠ°ΡΡΡΡ Π³ΡΠ°Π½ΠΈΡΡ Π΄ΠΈΠ°ΠΏΠ°Π·ΠΎΠ½Π° n ΠΈ N Π½Π°ΡΡΡΠ°Π»ΡΠ½ΡΡ ΡΠΈΡΠ΅Π» (n. Else { Console. WriteLine («Π’ΠΎΡΠΊΠ° ΠΠ ΠΏΠΎΠΏΠ°Π»Π° Π² ΠΏΠ»ΠΎΡΠΊΠΎΡΡΡ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ°»); }. Else { Console. WriteLine («Π’ΠΎΡΠΊΠ° ΠΠ ΠΏΠΎΠΏΠ°Π»Π° Π² ΠΏΠ»ΠΎΡΠΊΠΎΡΡΡ… Π§ΠΈΡΠ°ΡΡ Π΅ΡΡ >
ΠΡΠΎΠ³ΡΠ°ΠΌΠΌΠΈΡΠΎΠ²Π°Π½ΠΈΠ΅ Π½Π° C/C++ (ΡΠ΅ΡΠ΅ΡΠ°Ρ, ΠΊΡΡΡΠΎΠ²Π°Ρ, Π΄ΠΈΠΏΠ»ΠΎΠΌ, ΠΊΠΎΠ½ΡΡΠΎΠ»ΡΠ½Π°Ρ)
" ΠΡΠΎΠ³ΡΠ°ΠΌΠΌΠΈΡΠΎΠ²Π°Π½ΠΈΠ΅ Π½Π° Π‘/Π‘++"
ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΠΈΡΠΎΠ²Π°Π½ΠΈΠ΅ ΠΌΠΎΠ΄ΠΈΡΠΈΡΠΈΡΠΎΠ²Π°Π½Π½ΡΠΉ ΠΌΠ°ΡΡΠΈΠ²
ΠΠ°Π΄Π°Π½ΠΈΠ΅ 1
ΠΠ·ΡΡΠΈΡΡ ΡΠ΅ΠΎΡΠ΅ΡΠΈΡΠ΅ΡΠΊΠΈΠΉ ΠΌΠ°ΡΠ΅ΡΠΈΠ°Π», ΠΎΡΠ²Π΅ΡΠΈΡΡ Π½Π° ΠΊΠΎΠ½ΡΡΠΎΠ»ΡΠ½ΡΠ΅ Π²ΠΎΠΏΡΠΎΡΡ. Π‘Π°ΠΌΠΎΡΡΠΎΡΡΠ΅Π»ΡΠ½ΠΎ ΡΠΎΠ·Π΄Π°ΡΡ Π½ΠΎΠ²ΠΎΠ΅ ΠΊΠΎΠ½ΡΠΎΠ»ΡΠ½ΠΎΠ΅ ΠΏΡΠΈΠ»ΠΎΠΆΠ΅Π½ΠΈΠ΅.
Π ΡΡΠ½ΠΊΡΠΈΠΈ Main () ΠΎΠ±ΡΡΠ²ΠΈΡΡ 2 ΠΏΠ΅ΡΠ΅ΠΌΠ΅Π½Π½ΡΠ΅ ΡΠΈΠΏΠ° string, 1 — ΡΠΈΠΏΠ° int, 1 — ΡΠΈΠΏΠ° double.
ΠΠ²Π΅ΡΡΠΈ ΠΈΡ Π·Π½Π°ΡΠ΅Π½ΠΈΡ Ρ ΠΊΠ»Π°Π²ΠΈΠ°ΡΡΡΡ ΠΈ ΡΠ°ΡΡΡΠΈΡΠ°ΡΡ ΡΡΠΌΠΌΡ ΠΈ ΠΏΡΠΎΠΈΠ·Π²Π΅Π΄Π΅Π½ΠΈΠ΅ Π°ΡΠΈΡΠΌΠ΅ΡΠΈΡΠ΅ΡΠΊΠΈΡ ΠΏΠ΅ΡΠ΅ΠΌΠ΅Π½Π½ΡΡ , ΡΡΠΌΠΌΡ ΡΡΡΠΎΠΊ.
Π Π΅ΡΠ΅Π½ΠΈΠ΅
using System;
using System.Collections.Generic;
using System. Linq;
using System. Text;
namespace ConsoleApplication1
{
class Program
{
static void Main (string[] args)
{
// ΡΡΠΎ ΠΏΡΠ΅Π΄ΡΠ΄ΡΡΠ΅Π΅ Π·Π°Π΄Π°Π½ΠΈΠ΅, Ρ Π΅Π³ΠΎ Π·Π°ΠΊΠΎΠΌΠΌΠ΅Π½ΡΠΈΡΠΎΠ²Π°Π», Π½ΠΎ Π½Π° Π²ΡΡΠΊΠΈΠΉ ΡΠ»ΡΡΠ°ΠΉ ΠΎΡΡΠ°Π²ΠΈΠ»
//double myDouble;
// string myString;
// myDouble = Convert. ToDouble (Console.ReadLine ());
// myString = «» myDouble «is» ;
// Console. WriteLine («{0} {1}», myString, myDouble);
string aaa;
string bbb;
int ccc;
double ddd;
int x;
int z;
Console.WriteLine («ΠΠ°Π΄Π°Π½ΠΈΠ΅: ΠΎΠ±ΡΡΠ²ΠΈΡΡ 2 ΠΏΠ΅ΡΠ΅ΠΌΠ΅Π½Π½ΡΠ΅ ΡΠΈΠΏΠ° string, 1 — ΡΠΈΠΏΠ° int, 1 — ΡΠΈΠΏΠ° double. ΠΠ²Π΅ΡΡΠΈ ΠΈΡ Π·Π½Π°ΡΠ΅Π½ΠΈΡ Ρ ΠΊΠ»Π°Π²ΠΈΠ°ΡΡΡΡ ΠΈ ΡΠ°ΡΡΡΠΈΡΠ°ΡΡ ΡΡΠΌΠΌΡ ΠΈ ΠΏΡΠΎΠΈΠ·Π²Π΅Π΄Π΅Π½ΠΈΠ΅ Π°ΡΠΈΡΠΌΠ΅ΡΠΈΡΠ΅ΡΠΊΠΈΡ ΠΏΠ΅ΡΠ΅ΠΌΠ΅Π½Π½ΡΡ , ΡΡΠΌΠΌΡ ΡΡΡΠΎΠΊ.»);
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ ΡΡΡΠΎΠΊΡ»);
aaa = Console. ReadLine ();
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ Π΅ΡΠ΅ ΠΎΠ΄Π½Ρ ΡΡΡΠΎΠΊΡ»);
bbb = Console. ReadLine ();
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ ΡΠΈΡΠ»ΠΎ»);
ccc = Convert. ToInt32(Console.ReadLine ());
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ Π΅ΡΠ΅ ΠΎΠ΄Π½ΠΎ ΡΠΈΡΠ»ΠΎ»);
ddd = Convert. ToDouble (Console.ReadLine ());
x = ccc + Convert. ToInt32(ddd);
z = ccc * Convert. ToInt32(ddd);
Console.WriteLine («ΡΡΠΌΠΌΠ° Π°ΡΠΈΡΠΌΠ΅ΡΠΈΡΠ΅ΡΠΊΠΈΡ ΠΏΠ΅ΡΠ΅ΠΌΠ΅Π½Π½ΡΡ = «+x);
Console.WriteLine («ΠΏΡΠΎΠΈΠ·Π²Π΅Π΄Π΅Π½ΠΈΠ΅ Π°ΡΠΈΡΠΌΠ΅ΡΠΈΡΠ΅ΡΠΊΠΈΡ ΠΏΠ΅ΡΠ΅ΠΌΠ΅Π½Π½ΡΡ = «+ z);
Console.WriteLine («ΡΡΠΌΠΌΠ° ΡΡΡΠΎΠΊΠΎΠ²ΡΡ ΠΏΠ΅ΡΠ΅ΠΌΠ΅Π½Π½ΡΡ = «+ aaa+bbb);
}
}
}
Π Π΅Π·ΡΠ»ΡΡΠ°Ρ ΡΠ°Π±ΠΎΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ Π ΠΈΡ.
ΠΠ°Π΄Π°Π½ΠΈΠ΅ 2
1. ΠΠ²Π΅ΡΡΠΈ Ρ ΠΊΠ»Π°Π²ΠΈΠ°ΡΡΡΡ Π³ΡΠ°Π½ΠΈΡΡ Π΄ΠΈΠ°ΠΏΠ°Π·ΠΎΠ½Π° n ΠΈ N Π½Π°ΡΡΡΠ°Π»ΡΠ½ΡΡ ΡΠΈΡΠ΅Π» (n
Π Π΅ΡΠ΅Π½ΠΈΠ΅
using System;
using System.Collections.Generic;
using System. Linq;
using System. Text;
namespace ConsoleApplication1
{
class Program
{
static void Main (string[] args)
{
int x1, x2, a, b, s, w, v, z, x, size, step, count, count2, count3;
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ Π³ΡΠ°Π½ΠΈΡΡ Π½Π°ΡΠ°Π»Π° ΡΡΠ΄Π°»);
x1 = Convert. ToInt32(Console.ReadLine ());
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ Π³ΡΠ°Π½ΠΈΡΡ ΠΊΠΎΠ½ΡΠ° ΡΡΠ΄Π°»);
x2 = Convert. ToInt32(Console.ReadLine ());
count = 0;
count2 = 0;
int i = x1;
for (; i < x2 + 1; i++)
{
ewq:
// ΠΎΠΏΡΠ΅Π΄Π΅Π»ΡΠ΅ΠΌ ΡΠ°Π·ΡΡΠ΄Π½ΠΎΡΡΡ ΡΠΈΡΠ»Π° size
size = 0;
w = i;
for (; w > 0; size++)
{
w = w / 10;
}
// ΠΎΡΠ΅Π΄Π΅Π»ΡΠ΅ΠΌ ΡΡΠ΅ΠΏΠ΅ΡΠ½Ρ Π΄Π΅Π»ΠΈΡΠ΅Π»Ρ
v = size;
step = 10;
while (v > 2)
{
v = v — 1;
step = step * 10;
}
// ΠΎΠ±ΡΡΠ²Π»ΡΠ΅ΠΌ ΠΌΠ°ΡΡΠΈΠ² ΡΠ°Π·ΠΌΠ΅ΡΠΎΠΌ size
int y = 0;
int[] A1 = new int[size];
// ΡΠ°ΡΠΊΠ»Π°Π΄ΡΠ²Π°Π΅ΠΌ ΡΠΈΡΠ»ΠΎ Π½Π° ΡΠΈΡΡ Π² ΠΌΠ°ΡΡΠΈΠ²
for (int j = 0; j < size — 1; j++)
{
s = i;
qwe:
a = s / step;
A1[j + y] = a;
b = s % step;
if (b < 1)
{
i = i + (step/10);
goto ewq;
}
if (b < 10)
{
y++;
A1[j + y] = b;
}
else
{
j++;
s = b;
step = step / 10;
goto qwe;
}
}
// ΠΏΡΠΎΠ²Π΅ΡΡΠ΅ΠΌ ΠΎΡΠ²Π΅ΡΠ°Π΅Ρ Π»ΠΈ ΠΌΠ°ΡΡΠΈΠ² Π·Π°ΡΠ²Π»Π΅Π½Π½ΡΠΌ ΡΡΠ΅Π±ΠΎΠ²Π°Π½ΠΈΡΠΌ
z = 0;
x = 0;
for (int d = 0; d < size; d++)
{
v = 1;
if (d == size-1)
{
v = 0;
}
if ((A1[d] + 1) == A1[d+v])
{
z++;
}
if ((A1[d] - 1) == A1[d + v])
{
x++;
}
}
// Π²ΡΠ²ΠΎΠ΄ΠΈΠΌ Π½Π° ΡΠΊΡΠ°Π½ ΠΈ Π²Π΅Π΄ΠΌ ΠΏΠΎΡΡΠ΅Ρ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²Π° count ΠΈ ΡΠ΅ΡΠ½ΠΎΡΡΠΈ count2
if (z == size — 1)
{
count++;
for (int n = 0; n < size; n++)
{
Console.Write (A1[n]);
}
if (A1[size-1] % 2 == 0)
{
count2++;
}
Console.WriteLine ();
}
if (x == size — 1)
{
count++;
for (int n = 0; n < size; n++)
{
Console.Write (A1[n]);
}
if (A1[size-1] % 2 == 0)
{
count2++;
}
Console.WriteLine ();
}
}
// Π²ΡΠ²ΠΎΠ΄ΠΈΠΌ Π½Π° ΡΠΊΡΠ°Π½ Π΄Π°Π½Π½ΡΠ΅ ΠΎ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²Π΅ ΠΈ ΡΠ΅ΡΠ½ΠΎΡΡΠΈ
Console.WriteLine («ΠΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΡΠΎΡΠ΅Π΄Π½ΠΈΡ ΡΠΈΡΠ΅Π» = {0}», count);
Console.WriteLine («ΠΠ· Π½ΠΈΡ ΡΠ΅ΡΠ½ΡΡ = {0}», count2);
count3 = count — count2;
Console.WriteLine («ΠΠ· Π½ΠΈΡ Π½Π΅ΡΠ΅ΡΠ½ΡΡ = {0}», count3);
Console.ReadLine ();
}
}
}
Π Π΅Π·ΡΠ»ΡΡΠ°Ρ ΡΠ°Π±ΠΎΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ Π ΠΈΡ.
ΠΠ°Π΄Π°Π½ΠΈΠ΅ 3
2. Π‘ΠΎΡΡΠ°Π²ΠΈΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ Π²ΡΡΠΈΡΠ»Π΅Π½ΠΈΡ:
ΠΠ΅ΠΉΡΡΠ²ΠΈΡΠ΅Π»ΡΠ½ΡΠ΅ ΡΠΈΡΠ»Π° Π°, b ΠΈ Π½Π°ΡΡΡΠ°Π»ΡΠ½ΠΎΠ΅ N Π·Π°Π΄Π°ΡaΡΡΡ ΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΠ΅Π»Π΅ΠΌ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ.
Π Π΅ΡΠ΅Π½ΠΈΠ΅
using System;
using System.Collections.Generic;
using System. Linq;
using System. Text;
namespace _444
{
class Program
{
static void Main (string[] args)
{
int a, b, i;
double N, h, F, s, FF, x;
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ (a)»);
a = Convert. ToInt32(Console.ReadLine ());
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ (b)»);
b = Convert. ToInt32(Console.ReadLine ());
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ (N)»);
N = Convert. ToDouble (Console.ReadLine ());
h = (b — a) / N;
FF = 0;
for (i = 1; i <= N; i++)
{
s = 1+(a-(i-0.5));
s = s * s;
F = (a + ((i — 0.5) * h)) / s;
FF = FF + F;
Console.WriteLine («F{1}= ({0})», F, i);
Console.WriteLine ();
}
x=FF* h;
Console.WriteLine («(F1+F2+F3+…+FN)h = {0}», x);
Console.ReadLine ();
}
}
}
Π Π΅Π·ΡΠ»ΡΡΠ°Ρ ΡΠ°Π±ΠΎΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ Π ΠΈΡ.
ΠΠ°Π΄Π°Π½ΠΈΠ΅ 4
3. ΠΠ°Π½Ρ Π΄Π΅ΠΉΡΡΠ²ΠΈΡΠ΅Π»ΡΠ½ΡΠ΅ ΡΠΈΡΠ»Π°. Π‘ΠΎΡΡΠ°Π²ΠΈΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ Π²ΡΡΠΈΡΠ»Π΅Π½ΠΈΡ ΡΡΠΌΠΌΡ Ρ ΡΠΎΡΠ½ΠΎΡΡΡΡ ΠΈ Π΅Π΅ ΠΏΠΎΡΠ»Π΅Π΄Π½Π΅Π³ΠΎ ΡΠ»Π°Π³Π°Π΅ΠΌΠΎΠ³ΠΎ:
Π Π΅ΡΠ΅Π½ΠΈΠ΅
using System;
using System.Collections.Generic;
using System. Linq;
using System. Text;
namespace _333
{
class Program
{
static void Main (string[] args)
{
double x, e, k, a, b, w, v, sw, sx, f, g, i, ii, j, s, z, sum;
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ X»);
x = Convert. ToDouble (Console.ReadLine ());
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ ΠΠΏΡΠΈΠ»ΠΎΠ½»);
e = Convert. ToDouble (Console.ReadLine ());
sum = 0;
w = -1;
k = 0;
do
{
k++;
i = 0;
sw = w;
for (; i < k; i++)
{
sw = sw * w;
}
v = (2 * k) + 1;
j = 0;
sx = x;
for (; j < v-1; j++)
{
sx = sx * x;
}
a = sw * sx;
g = k + 2;
f = g;
ii = 1;
for (; ii < g; ii++)
{
f = f * ii;
}
b = f * ((2 * k) + 1);
s = a / b;
z = s;
sum = sum+s;
Console.WriteLine («[ΡΠ»Π°Π³Π°Π΅ΠΌΠΎΠ΅]-({0})», s);
// Π‘ΡΠΈΡΠ°ΡΠ°Π΅ΠΌ, ΡΡΠΎ ΡΡΠ΅Π±ΡΠ΅ΠΌΠ°Ρ ΡΠΎΡΠ½ΠΎΡΡΡ Π΄ΠΎΡΡΠΈΠ³Π½ΡΡΠ°, Π΅ΡΠ»ΠΈ ΠΎΡΠ΅ΡΠ΅Π΄Π½ΠΎΠ΅
// ΡΠ»Π°Π³Π°Π΅ΠΌΠΎΠ΅ ΡΡΠΌΠΌΡ ΠΎΠΊΠ°Π·Π°Π»ΠΎΡΡ ΠΏΠΎ ΠΌΠΎΠ΄ΡΠ»Ρ ΠΌΠ΅Π½ΡΡΠ΅ ΡΠ΅ΠΌ ΡΠΏΡΠΈΠ»ΠΎΠ½
z = Math. Abs (z);
}
while (z > e);
Console.WriteLine ();
Console.WriteLine («[ΠΏΠΎΡΠ»Π΅Π΄Π½Π΅Π΅ ΡΠ»Π°Π³Π°Π΅ΠΌΠΎΠ΅]-({0})», s);
Console.WriteLine («[Π‘ΡΠΌΠΌΠ°]-({0})», sum);
Console.ReadLine ();
}
}
}
Π Π΅Π·ΡΠ»ΡΡΠ°Ρ ΡΠ°Π±ΠΎΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ Π ΠΈΡ.
ΠΠ°Π΄Π°Π½ΠΈΠ΅ 5
1. Π ΠΎΠ΄Π½ΠΎΠΌΠ΅ΡΠ½ΡΠΉ ΠΌΠ°ΡΡΠΈΠ² ΡΠ°Π·ΠΌΠ΅ΡΠ½ΠΎΡΡΠΈ N Π²Π²Π΅ΡΡΠΈ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ»ΡΠ½ΡΠ΅ ΡΠΈΡΠ»Π°. ΠΠ²Π΅ΡΡΠΈ ΡΠΈΡΠ»ΠΎ Π. ΠΡΠ»ΠΈ Π² ΠΈΡΡ ΠΎΠ΄Π½ΠΎΠΌ ΠΌΠ°ΡΡΠΈΠ²Π΅ ΡΠΈΡΠ΅Π» Π±ΠΎΠ»ΡΡΠ΅ ΡΠ΅ΠΌ Π, ΡΠΎ ΠΌΠ°ΡΡΠΈΠ²Π΅ Π²ΡΠΏΠΎΠ»Π½ΠΈΡΡ ΠΊΠΎΠ»ΡΡΠ΅Π²ΠΎΠΉ ΡΠ΄Π²ΠΈΠ³ ΠΌΠ°ΡΡΠΈΠ²Π° ΡΠ°ΠΊ, ΡΡΠΎΠ±Ρ Π΅Π³ΠΎ ΠΏΠ΅ΡΠ²ΡΠΉ ΠΌΠ°ΠΊΡΠΈΠΌΠ°Π»ΡΠ½ΡΠΉ ΡΠ»Π΅ΠΌΠ΅Π½Ρ ΠΎΠΊΠ°Π·Π°Π»ΡΡ Π½Π° K-ΠΌ ΠΌΠ΅ΡΡΠ΅ (N ΠΈ K Π·Π°Π΄Π°Π½Ρ). ΠΠΎΠ»ΡΡΠ΅Π²ΠΎΠΉ ΡΠ΄Π²ΠΈΠ³ ΠΌΠ°ΡΡΠΈΠ²Π° Π²ΡΠΏΠΎΠ»Π½ΡΠ΅ΡΡΡ Π²ΡΠ΅ΠΌΠΈ Π΅Π³ΠΎ ΡΠ»Π΅ΠΌΠ΅Π½ΡΠ°ΠΌΠΈ ΡΠ°ΠΊ, ΡΡΠΎ ΡΠ»Π΅ΠΌΠ΅Π½ΡΡ «Π²ΡΡΠ°Π»ΠΊΠΈΠ²Π°Π΅ΠΌΡΠ΅» ΠΈΠ· ΠΌΠ°ΡΡΠΈΠ²Π° Π² ΠΎΠ΄Π½Ρ ΡΡΠΎΡΠΎΠ½Ρ Π·Π°Π½ΠΈΠΌΠ°ΡΡ ΠΎΡΠ²ΠΎΠ±ΠΎΠ΄ΠΈΠ²ΡΠΈΠ΅ΡΡ ΠΌΠ΅ΡΡΠΎ Ρ Π΄ΡΡΠ³ΠΎΠΉ ΡΡΠΎΡΠΎΠ½Ρ. ΠΡΠ»ΠΈ Π Π±ΠΎΠ»ΡΡΠ΅ ΠΈΠ»ΠΈ ΡΠ°Π²Π½ΠΎ ΡΠΈΡΠ»Ρ ΡΠ»Π΅ΠΌΠ΅Π½ΡΠΎΠ² Π² ΠΈΡΡ ΠΎΠ΄Π½ΠΎΠΌ ΠΌΠ°ΡΡΠΈΠ²Π΅, ΡΠΎ ΡΠΎΠ·Π΄Π°ΡΡ Π½ΠΎΠ²ΡΠΉ ΠΌΠ°ΡΡΠΈΠ², Π΄ΠΎΠ±Π°Π²ΠΈΠ² Π² Π½Π°ΡΠ°Π»ΠΎ ΠΈΡΡ ΠΎΠ΄Π½ΠΎΠ³ΠΎ ΠΌΠ°ΡΡΠΈΠ²Π° ΡΠΈΡΠ»ΠΎ Π. ΠΠ°ΠΏΠ΅ΡΠ°ΡΠ°ΡΡ ΠΌΠΎΠ΄ΠΈΡΠΈΡΠΈΡΠΎΠ²Π°Π½Π½ΡΠΉ ΠΌΠ°ΡΡΠΈΠ².
Π Π΅ΡΠ΅Π½ΠΈΠ΅
using System;
using System.Collections.Generic;
using System. Linq;
using System. Text;
namespace _31
{
class Program
{
static void Main (string[] args)
{
int[] A1 = new int[9] {4, 3, 8, 12, 29, 2, 31, 25, 3};
int K, a, b, c, z, f;
Console.WriteLine («ΠΡΡ ΠΎΠ΄Π½ΡΠΉ ΠΌΠ°ΡΡΠΈΠ²»);
for (int i = 0; i < A1. Length; i++)
{
Console.Write (A1[i]+" t");
}
Console.WriteLine ();
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ (Π)»);
K=Convert.ToInt32(Console.ReadLine ());
// Π΅ΡΠ»ΠΈ Π ΠΌΠ΅Π½ΡΡΠ΅ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²Π° ΡΠ»Π΅ΠΌΠ΅Π½ΡΠΎΠ² Π² ΠΌΠ°ΡΡΠΈΠ²Π΅ ΡΠΎ…
if (K < A1. Length)
{
// ΠΎΠΏΡΠ΅Π΄Π΅Π»ΡΠ΅ΠΌ ΠΏΠ΅ΡΠ²ΡΠΉ ΠΌΠ°ΠΊΡΠΈΠΌΠ°Π»ΡΠ½ΡΠΉ ΡΠ»Π΅ΠΌΠ΅Π½Ρ ΠΌΠ°ΡΡΠΈΠ²Π°
c = 1;
a = A1[0];
b = 0;
f = 0;
for (int i = 0; i < A1. Length; i++)
{
if (i == A1. Length — 1)
{ c = 0; }
b = A1[i + c];
if (a < b)
{
a = b;
f = i + c + 1;
}
}
// Π²ΡΠΏΠΎΠ»Π½ΡΠ΅ΠΌ ΠΊΡΠΎΠ»ΡΡΠ΅Π²ΠΎΠΉ ΡΠ΄Π²ΠΈΠ³ ΠΌΠ°ΡΡΠΈΠ²Π°
do
{
z = A1[A1.Length — 1];
for (int j = A1. Length — 1; j >= 1; j—)
{
A1[j] = A1[j — 1];
}
A1[0] = z;
}
while (A1[K — 1] ≠ a);
Console.WriteLine («ΠΠΎΠ΄ΠΈΡΠΈΡΠΈΡΠΎΠ²Π°Π½Π½ΡΠΉ ΠΌΠ°ΡΡΠΈΠ²»);
for (int i = 0; i < A1. Length; i++)
{
Console.Write (A1[i] + «t»);
}
}
// Π΅ΡΠ»ΠΈ Π Π±ΠΎΠ»ΡΡΠ΅ ΠΈΠ»ΠΈ ΡΠ°Π²Π½ΠΎ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²Ρ ΡΠ»Π΅ΠΌΠ΅Π½ΡΠΎΠ² Π² ΠΌΠ°ΡΡΠΈΠ²Π΅ ΡΠΎ…
else
{
int[] A2 = new int[10];
// Π΄ΠΎΠ±Π°Π²Π»ΡΠ΅ΠΌ ΡΠ»Π΅ΠΌΠ΅Π½Ρ Π² Π½Π°ΡΠ°Π»ΠΎ ΠΌΠ°ΡΡΠΈΠ²Π°
A2[0] = K;
// ΠΊΠΎΠΏΠΈΡΡΠ΅ΠΌ ΡΠ»Π΅ΠΌΠ΅Π½ΡΡ ΠΈΡΡ ΠΎΠ΄Π½ΠΎΠ³ΠΎ ΠΌΠ°ΡΡΠΈΠ²Π°
for (int i = 1; i < A2. Length; i++)
{
A2[i] = A1[i — 1];
}
Console.WriteLine («ΠΠΎΠ΄ΠΈΡΠΈΡΠΈΡΠΎΠ²Π°Π½Π½ΡΠΉ ΠΌΠ°ΡΡΠΈΠ²»);
for (int i = 0; i < A2. Length; i++)
{
Console.Write (A2[i] + «t»);
}
}
Console.ReadLine ();
}
}
}
Π Π΅Π·ΡΠ»ΡΡΠ°Ρ ΡΠ°Π±ΠΎΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ Π ΠΈΡ.
ΠΠ°Π΄Π°Π½ΠΈΠ΅ 6
2. Π‘ΠΎΡΡΠ°Π²ΠΈΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ, ΠΊΠΎΡΠΎΡΠ°Ρ ΠΏΠΎΠ»ΡΡΠ°Π΅Ρ ΠΌΠ°ΡΡΠΈΡΡ Π₯ ΡΠ°Π·ΠΌΠ΅ΡΠ½ΠΎΡΡΡΡ m*n ΠΈ ΠΈ Π²Π΅ΠΊΡΠΎΡ Π, ΡΠ°Π·ΠΌΠ΅ΡΠΎΠΌ m. ΠΠ°ΠΆΠ΄ΠΎΠΌΡ ΡΠ»Π΅ΠΌΠ΅Π½ΡΡ Π²Π΅ΠΊΡΠΎΡΠ° ΠΏΠΎΡΡΠ°Π²Π»Π΅Π½Π° Π² ΡΠΎΠΎΡΠ²Π΅ΡΡΡΠ²ΠΈΠ΅ ΡΡΡΠΎΠΊΠ° Ρ ΡΠ΅ΠΌ ΠΆΠ΅ Π½ΠΎΠΌΠ΅ΡΠΎΠΌ. ΠΡΠΎΠ³ΡΠ°ΠΌΠΌΠ° ΡΠΎΡΡΠΈΡΡΠ΅Ρ Π²Π΅ΠΊΡΠΎΡ, Π Π² ΠΏΠΎΡΡΠ΄ΠΊΠ΅ Π²ΠΎΠ·ΡΠ°ΡΡΠ°Π½ΠΈΡ ΠΈ ΡΠΎΡΠΌΠΈΡΡΠ΅Ρ Π½ΠΎΠ²ΡΡ ΠΌΠ°ΡΡΠΈΡΡ, ΡΠ°ΡΠΏΠΎΠ»ΠΎΠΆΠΈΠ² ΡΡΡΠΎΠΊΠΈ ΠΈΡΡ ΠΎΠ΄Π½ΠΎΠΉ ΠΌΠ°ΡΡΠΈΡΡ Π² ΡΠΎΠΌ ΠΆΠ΅ ΠΏΠΎΡΡΠ΄ΠΊΠ΅, ΡΡΠΎ ΠΈ ΡΠ»Π΅ΠΌΠ΅Π½ΡΡ Π²Π΅ΠΊΡΠΎΡΠ° ΠΏΠΎΡΠ»Π΅ ΡΠΎΡΡΠΈΡΠΎΠ²ΠΊΠΈ.
Π Π΅ΡΠ΅Π½ΠΈΠ΅
using System;
using System.Collections.Generic;
using System. Linq;
using System. Text;
namespace _32
{
class Program
{
static void Main (string[] args)
{
int[,] matr;
matr = new int[6, 6];
int[,] matr1;
matr1 = new int[6, 6];
int[] vect;
vect = new int[6];
int[] vect1;
vect1 = new int[6];
int a, b, c, f, r, w;
r = (matr.Length / 6)-1;
// Π·Π°ΠΏΠΎΠ»Π½ΡΠ΅ΠΌ ΠΌΠ°ΡΡΠΈΡΡ
for (int i = 0; i < matr. Length / 6; i++)
{
for (int j = 0; j < matr. Length / 6; j++)
{
matr[i, j] = i*j;
}
}
// Π²ΡΠ²ΠΎΠ΄ΠΈΠΌ ΠΌΠ°ΡΡΠΈΡΡ Π½Π° ΠΊΠΎΠ½ΡΠΎΠ»Ρ
Console.WriteLine («ΠΡΡ ΠΎΠ΄Π½Π°Ρ ΠΌΠ°ΡΡΠΈΡΠ°»);
for (int i = 0; i < matr. Length / 6; i++)
{
for (int j = 0; j < matr. Length / 6; j++)
{
Console.Write (matr[i, j] + «t»);
}
Console.WriteLine ();
}
// Π²Π²ΠΎΠ΄ΠΈΠΌ Ρ ΠΊΠ»Π°Π²ΠΈΠ°ΡΡΡΡ ΡΠ»Π΅ΠΌΠ΅Π½ΡΡ Π²Π΅ΠΊΡΠΎΡΠ°
for (int i = 0; i < vect. Length; i++)
{
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ ΠΎΡΠ΅ΡΠ΅Π΄Π½ΠΎΠΉ ΡΠ»Π΅ΠΌΠ΅Π½Ρ Π²Π΅ΠΊΡΠΎΡΠ°»);
vect[i] = Convert. ToInt32(Console.ReadLine ());
}
// Π²ΡΠ²ΠΎΠ΄ΠΈΠΌ Π½Π° ΠΊΠΎΠ½ΡΠΎΠ»Ρ Π²Π΅ΠΊΡΠΎΡ
Console.WriteLine ();
Console.WriteLine («ΠΡΡ ΠΎΠ΄Π½ΡΠΉ Π²Π΅ΠΊΡΠΎΡ»);
for (int i = 0; i < vect. Length; i++)
{
Console.WriteLine (vect[i]);
}
Console.WriteLine ();
// ΡΠΎΡΡΠΈΡΡΠ΅ΠΌ Π²Π΅ΠΊΡΠΎΡ ΠΏΠΎ Π²ΠΎΠ·ΡΠΎΡΡΠ°Π½ΠΈΡ
a = 0;
f = 0;
for (int s = 0; s < vect. Length; s++)
{
c = 1;
a = vect[0];
b = 0;
f = 0;
for (int i = 0; i < vect. Length; i++)
{
if (i == vect. Length — 1)
{ c = 0; b = vect[vect.Length-1]; goto wer; }
b = vect[i + c];
if (a < b)
{
a = b;
f = i + c ;
}
}
wer:
vect[f] = 0;
vect1[s] = a;
// ΡΠΎΠΏΠΎΡΡΠ°Π²Π»ΡΠ΅ΠΌ ΡΡΡΠΎΠΊΠΈ ΠΌΠ°ΡΡΠΈΡΡ Ρ ΡΠ»Π΅ΠΌΠ΅Π½ΡΠ°ΠΌΠΈ Π²Π΅ΠΊΡΠΎΡΠ° ΡΠ΅ΡΠ΅Π·
// ΠΏΠ΅ΡΠ΅ΠΌΠ΅Π½Π½ΡΡ f, Ρ ΡΠ°Π½ΡΡΡΡ ΠΈΠ½Π΄Π΅ΠΊΡ ΠΎΡΡΠΎΡΡΠΈΡΠΎΠ²Π°Π½Π½ΠΎΠ³ΠΎ Π·Π½Π°ΡΠ΅Π½ΠΈΡ Π²Π΅ΠΊΡΠΎΡΠ°
for (int i = 0; i < matr1. Length / 6; i++)
{
matr1[r, i]= matr[i, f];
}
r—;
}
Array.Reverse (vect1);
// Π²ΡΠ²ΠΎΠ΄ΠΈΠΌ Π½Π° ΡΠΊΡΠ°Π½ ΠΎΡΡΠΎΡΡΠΈΡΠΎΠ²Π°Π½Π½ΡΠΉ ΠΏΠΎ Π²ΠΎΠ·ΡΠΎΡΡΠ°Π½ΠΈΡ Π²Π΅ΠΊΡΠΎΡ
Console.WriteLine ();
Console.WriteLine («ΠΡΡΠΎΡΡΠΈΡΠΎΠ²Π°Π½Π½ΡΠΉ Π²Π΅ΠΊΡΠΎΡ»);
for (int i = 0; i < vect1. Length; i++)
{
Console.WriteLine (vect1[i]);
}
// Π²ΡΠ²ΠΎΠ΄ΠΈΠΌ Π½Π° ΡΠΊΡΠ°Π½ ΠΏΠΎΠ»ΡΡΠ΅Π½Π½ΡΡ ΠΌΠ°ΡΡΠΈΡΡ
Console.WriteLine («ΠΠΎΠ»ΡΡΠ΅Π½Π½Π°Ρ ΠΌΠ°ΡΡΠΈΡΠ°»);
for (int i = 0; i < matr1. Length / 6; i++)
{
for (int j = 0; j < matr1. Length / 6; j++)
{
Console.Write (matr1[i, j] + «t»);
}
Console.WriteLine ();
}
Console.ReadLine ();
}
}
}
Π Π΅Π·ΡΠ»ΡΡΠ°Ρ ΡΠ°Π±ΠΎΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ Π ΠΈΡ.
ΠΠ°Π΄Π°Π½ΠΈΠ΅ 7
ΠΠΏΠΈΡΠ°ΡΡ ΡΡΡΡΠΊΡΡΡΡ Ρ ΠΈΠΌΠ΅Π½Π΅ΠΌ STUDENT, ΡΠΎΠ΄Π΅ΡΠΆΠ°ΡΡΡ ΡΠ»Π΅Π΄ΡΡΡΠΈΠ΅ ΠΏΠΎΠ»Ρ:
— ΡΠ°ΠΌΠΈΠ»ΠΈΡ ΠΈ ΠΈΠ½ΠΈΡΠΈΠ°Π»Ρ;
— ΡΠ°ΠΊΡΠ»ΡΡΠ΅Ρ (ΡΠΈΠΏ — ΠΏΠ΅ΡΠ΅ΡΠΈΡΠ»Π΅Π½ΠΈΠ΅);
— Π½ΠΎΠΌΠ΅Ρ Π³ΡΡΠΏΠΏΡ;
— ΡΡΠΏΠ΅Π²Π°Π΅ΠΌΠΎΡΡΡ (ΠΌΠ°ΡΡΠΈΠ² ΠΈΠ· ΠΏΡΡΠΈ ΡΠ»Π΅ΠΌΠ΅Π½ΡΠΎΠ²).
ΠΠ°ΠΏΠΈΡΠ°ΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ, Π²ΡΠΏΠΎΠ»Π½ΡΡΡΡΡ ΡΠ»Π΅Π΄ΡΡΡΠΈΠ΅ Π΄Π΅ΠΉΡΡΠ²ΠΈΡ:
— Π·Π°ΠΏΠΎΠ»Π½Π΅Π½ΠΈΠ΅ Π΄Π°Π½Π½ΡΠΌΠΈ ΠΌΠ°ΡΡΠΈΠ²Π°, ΡΠΎΡΡΠΎΡΡΠ΅Π³ΠΎ ΠΈΠ· Π²ΠΎΡΡΠΌΠΈ ΡΡΡΡΠΊΡΡΡ ΡΠΈΠΏΠ° STUDENT;
— ΡΠΏΠΎΡΡΠ΄ΠΎΡΠ΅Π½ΠΈΠ΅ Π·Π°ΠΏΠΈΡΠ΅ΠΉ ΠΏΠΎ Π²ΠΎΠ·ΡΠ°ΡΡΠ°Π½ΠΈΡ ΡΠ°ΠΊΡΠ»ΡΡΠ΅ΡΠ° ΠΈ Π½ΠΎΠΌΠ΅ΡΠ° Π³ΡΡΠΏΠΏΡ;
— Π²ΡΠ²ΠΎΠ΄ Π·Π°ΠΏΠΈΡΠ΅ΠΉ Π² ΠΎΠ±ΡΠ°ΡΠ½ΠΎΠΌ ΠΏΠΎΡΡΠ΄ΠΊΠ΅;
— Π²ΡΠ²ΠΎΠ΄ Π½Π° Π΄ΠΈΡΠΏΠ»Π΅ΠΉ ΡΠ°ΠΌΠΈΠ»ΠΈΠΉ ΠΈ Π½ΠΎΠΌΠ΅ΡΠΎΠ² Π³ΡΡΠΏΠΏ Π΄Π»Ρ Π²ΡΠ΅Ρ ΡΡΡΠ΄Π΅Π½ΡΠΎΠ², ΠΈΠΌΠ΅ΡΡΠΈΡ ΠΎΡΠ΅Π½ΠΊΠΈ 3 ΠΈ 4. ΠΡΠ»ΠΈ ΡΠ°ΠΊΠΈΡ Π·Π°ΠΏΠΈΡΠ΅ΠΉ Π½Π΅Ρ, ΡΠΎ Π²ΡΠ²Π΅ΡΡΠΈ ΡΠΎΠΎΡΠ²Π΅ΡΡΡΠ²ΡΡΡΠ΅Π΅ ΡΠΎΠΎΠ±ΡΠ΅Π½ΠΈΠ΅ Π Π΅ΡΠ΅Π½ΠΈΠ΅
using System;
using System.Collections.Generic;
using System. Linq;
using System. Text;
namespace _4
{
enum ff: byte
{
Π€ΠΠΠ=1,
Π Π’Π€, ΠΠ€, Π€ΠΠΠ
}
struct student
{
public string fio;
public ff fak;
public int n;
public int[] usp;
}
class Program
{
static void Main (string[] args)
{
int a;
student[] st = new student[8];
int[] oc = new int[5];
qwe:
Console.WriteLine («aΠΡΠ±Π΅ΡΠΈΡΠ΅ Π΄Π΅ΠΉΡΡΠ²ΠΈΠ΅ n (1)ΠΠ°ΠΏΠΎΠ»Π½Π΅Π½ΠΈΠ΅ ΠΌΠ°ΡΡΠΈΠ²Π°n (2)Π£ΠΏΠΎΡΡΠ΄ΠΎΡΠΈΠ²Π°Π½ΠΈΠ΅ Π·Π°ΠΏΠΈΡΠ΅ΠΉ ΠΏΠΎ Π³ΡΡΠΏΠΏΠ΅ n (3)Π£ΠΏΠΎΡΡΠ΄ΠΎΡΠΈΠ²Π°Π½ΠΈΠ΅ Π·Π°ΠΏΠΈΡΠ΅ΠΉ ΠΏΠΎ ΡΠ°ΠΊΡΠ»ΡΡΠ΅ΡΡ n (4)ΠΡΠ²ΠΎΠ΄ Π·Π°ΠΏΠΈΡΠ΅ΠΉ Π² ΠΎΠ±ΡΠ°ΡΠ½ΠΎΠΌ ΠΏΠΎΡΡΠ΄ΠΊΠ΅ n (5)ΠΡΠ²Π΅ΡΡΠΈ ΠΈΠΌΠ΅Π½Π° ΡΡΡΠ΄Π΅Π½ΡΠΎΠ² ΠΈΠΌΠ΅ΡΡΠΈΡ ΠΎΡΠ΅Π½ΠΊΠΈ 3 ΠΈ 4 n (6)ΠΡΡ ΠΎΠ΄ «);
a = Convert. ToInt32(Console.ReadLine ());
if (a == 1)
{
for (int i = 0; i < st. Length; i++)
{
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ Π€Π°ΠΌΠΈΠ»ΠΈΡ ΡΡΡΠ΄Π΅Π½ΡΠ° ΠΈ ΠΈΠ½ΠΈΡΠΈΠ°Π»Ρ»);
st[i]. fio = Console. ReadLine ();
Console.WriteLine («ΠΡΠ±Π΅ΡΠΈΡΠ΅ ΡΠ°ΠΊΡΠ»ΡΡΠ΅Ρ n (1)Π€ΠΠΠ n (2)Π Π’Π€ n (3)ΠΠ€ n (4)Π€ΠΠΠ»);
st[i]. fak = (ff)Convert.ToByte (Console.ReadLine ());
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ Π½ΠΎΠΌΠ΅Ρ Π³ΡΡΠΏΠΏΡ»);
st[i]. n = Convert. ToInt32(Console.ReadLine ());
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ ΡΡΠΏΠ΅Π²Π°Π΅ΠΌΠΎΡΡΡ (ΠΏΡΡΡ ΠΎΡΠ΅Π½ΠΎΠΊ)»);
st[i]. usp = new int[5];
for (int j = 0; j < st[i]. usp. Length; j++)
{
st[i]. usp[j] = Convert. ToInt32(Console.ReadLine ());
}
}
Print (st);
goto qwe;
}
if (a == 2)
{
Console.WriteLine ();
Console.WriteLine («Π£ΠΏΠΎΡΡΠ΄ΠΎΡΠΈΠ²Π°Π½ΠΈΠ΅ Π·Π°ΠΏΠΈΡΠ΅ΠΉ ΠΏΠΎ Π½ΠΎΠΌΠ΅ΡΡ Π³ΡΡΠΏΠΏΡ»);
Sort (ref st);
Print (st);
goto qwe;
}
if (a == 3)
{
Console.WriteLine ();
Console.WriteLine («Π£ΠΏΠΎΡΡΠ΄ΠΎΡΠΈΠ²Π°Π½ΠΈΠ΅ Π·Π°ΠΏΠΈΡΠ΅ΠΉ ΠΏΠΎ ΡΠ°ΠΊΡΠ»ΡΡΠ΅ΡΡ»);
SortF (ref st);
Print (st);
goto qwe;
}
if (a == 4)
{
Console.WriteLine ();
Console.WriteLine («ΠΡΠ²ΠΎΠ΄ Π·Π°ΠΏΠΈΡΠ΅ΠΉ Π² ΠΎΠ±ΡΠ°ΡΠ½ΠΎΠΌ ΠΏΠΎΡΡΠ΄ΠΊΠ΅»);
Array.Reverse (st);
Print (st);
goto qwe;
}
if (a == 5)
{
Console.WriteLine ();
Console.WriteLine («Π‘ΡΡΠ΄Π΅Π½ΡΡ, ΠΈΠΌΠ΅ΡΡΠΈΠ΅ 3 ΠΈ 4»);
Vyvod34(st);
goto qwe;
}
if (a > 5)
{
return;
}
}
static void Sort (ref student[] A)
{
student[] B = A;
for (int i=0; i
{
for (int j=i; j
{
if (A[j]. n. CompareTo (B[i].n) < 0)
{
student h;
h=B[i];
B[i]=B[j];
B[j]=h;
}
}
}
foreach (student a in B) ;
}
static void SortF (ref student[] A)
{
student[] B = A;
for (int i = 0; i < B. Length; i++)
{
for (int j = i; j < B. Length; j++)
{
if (A[j]. fak. CompareTo (B[i].fak) < 0)
{
student h;
h = B[i];
B[i] = B[j];
B[j] = h;
}
}
}
foreach (student a in B) ;
}
static void Vyvod34(student[] A)
{
int g = 0;
for (int i = 0; i < A. Length; i++)
{
int[]B = A[i]. usp;
int s=0;
for (int j=0; j
{
if (B[j] == 3) { s++; g++;}
if (B[j] == 4) { s++; g++;}
}
if (s > 0)
{
Console.WriteLine («a{0}t{1}», A[i]. fio, A[i]. n);
}
}
if (g == 0)
{
Console.WriteLine («ΠΎΡΡΡΡΡΡΠ²ΡΡΡ»);
}
}
static void Print (student[] A)
{
Console.Write («tΠ€ΠΠttΠ€Π°ΠΊΡΠ»ΡΡΠ΅ΡtΠΡΡΠΏΠΏΠ°tΠ£ΡΠΏΠ΅Π²Π°Π΅ΠΌΠΎΡΡΡ»);
Console.WriteLine ();
for (int i = 0; i < A. Length; i++)
{
Console.Write («{0}tt{1}tt{2}t{3} {4} {5} {6} {7}», A[i]. fio, A[i]. fak, A[i]. n, A[i]. usp[0], A[i]. usp[1], A[i]. usp[2], A[i]. usp[3], A[i]. usp[4]);
Console.WriteLine ();
}
}
}
}
ΠΠ²ΠΎΠ΄ΠΈΠΌ Π΄Π°Π½Π½ΡΠ΅ Ρ ΠΊΠ»Π°Π²ΠΈΠ°ΡΡΡΡ Π ΠΈΡ.
Π ΠΈΡ.
Π£ΠΏΠΎΡΡΠ΄ΠΎΡΠΈΠ²Π°Π΅ΠΌ ΠΏΠΎ Π³ΡΡΠΏΠΏΠ΅ Π ΠΈΡ.
Π£ΠΏΠΎΡΡΠ΄ΠΎΡΠΈΠ²Π°Π΅ΠΌ ΠΏΠΎ ΡΠ°ΠΊΡΠ»ΡΡΠ΅ΡΡ Π ΠΈΡ.
ΠΡΠ²ΠΎΠ΄ΠΈΠΌ Π·Π°ΠΏΠΈΡΠΈ Π² ΠΎΠ±ΡΠ°ΡΠ½ΠΎΠΌ ΠΏΠΎΡΡΠ΄ΠΊΠ΅ Π ΠΈΡ.
ΠΡΠ²ΠΎΠ΄ΠΈΠΌ ΠΈΠΌΠ΅Π½Π° ΠΈ Π³ΡΡΠΏΠΏΡ ΡΡΡΠ΄Π΅Π½ΡΠΎΠ², ΠΈΠΌΠ΅ΡΡΠΈΡ 3 ΠΌ 4
Π ΠΈΡ.
ΠΠ°Π΄Π°Π½ΠΈΠ΅ 8
Π’Π΅ΠΊΡΡ ΡΠΎΡΡΠΎΠΈΡ ΠΈΠ· ΠΏΡΠ΅Π΄Π»ΠΎΠΆΠ΅Π½ΠΈΠΉ, ΡΠ°Π·Π΄Π΅Π»Π΅Π½Π½ΡΡ ΡΠΎΡΠΊΠΎΠΉ. Π’Π΅ΠΊΡΡ Π²Π²ΠΎΠ΄ΠΈΡΡΡ Ρ ΠΊΠ»Π°Π²ΠΈΠ°ΡΡΡΡ, Π΅Π³ΠΎ Π΄Π»ΠΈΠ½Π° Π½Π΅ ΠΏΡΠ΅Π²ΡΡΠ°Π΅Ρ 1000 ΡΠΈΠΌΠ²ΠΎΠ»ΠΎΠ². Π£Π΄Π°Π»ΠΈΡΡ ΠΈΠ· ΡΠ΅ΠΊΡΡΠ° Π·Π°Π΄Π°Π½Π½ΠΎΠ΅ ΡΠ»ΠΎΠ²ΠΎ. Π‘Π»ΠΎΠ²Π° ΡΠ°Π·Π΄Π΅Π»Π΅Π½Ρ ΠΏΡΠΎΠ±Π΅Π»Π°ΠΌΠΈ ΠΈ Π·Π½Π°ΠΊΠ°ΠΌΠΈ ΠΏΡΠ΅ΠΏΠΈΠ½Π°Π½ΠΈΡ.
Π Π΅ΡΠ΅Π½ΠΈΠ΅
using System;
using System.Collections.Generic;
using System. Linq;
using System. Text;
namespace _5
{
class Program
{
static void Main (string[] args)
{
string text, word;
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ ΡΠ΅ΠΊΡΡ»);
text = Console. ReadLine ();
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ ΡΠ»ΠΎΠ²ΠΎ»);
word = Console. ReadLine ();
// ΠΈΠ½ΠΈΡΠΈΠ°Π»ΠΈΠ·ΠΈΡΡΠΌΠ΅ ΠΌΠ°ΡΡΠΈΠ²Ρ Ρ ΡΠ°Π·Π΄Π΅Π»ΠΈΡΠ΅Π»ΡΠΌΠΈ
char[] sS = new char[] { ' ' };
char[] zp = new char[] { '.', ':', ';', ',', '?', '!', 'n', 'r' };
// ΠΠ½ΠΈΡΠΈΠ°Π»ΠΈΠ·ΠΈΡΡΠ΅ΠΌ ΠΌΠ°ΡΡΠΈΠ² ΡΡΡΠΎΠΊ Π½Π° ΠΏΠΎΠ΄ΡΡΡΠΎΠΊΠΈ ΠΏΠΎ ΡΠ°Π·Π΄Π΅Π»ΠΈΡΠ΅Π»ΡΠΌ
string[] result = text. Split (sS);
string[] newtext = new string[result.Length];
for (int i = 0; i < result. Length; i++)
{
string[] elem = result[i]. Split (zp);
// ΡΡΠ°Π²Π½ΠΈΠ²Π°Π΅ΠΌ ΠΊΠ°ΠΆΠ΄ΡΠΉ ΡΠ»Π΅ΠΌΠ΅Π½Ρ ΠΌΠ°ΡΡΠΈΠ²Π° Ρ word ΠΈ Π΅ΡΠ»ΠΈ ΠΎΠ½ΠΈ Π½Π΅ ΡΠ°Π²Π½Ρ,
// ΡΠΎ Π΄ΠΎΠ±Π°Π²Π»ΡΠ΅ΠΌ Π΅Π³ΠΎ Π² Π½ΠΎΠ²ΡΠΉ ΠΌΠ°ΡΡΠΈΠ²
if (elem[0] ≠ word)
{
newtext[i] = result[i];
}
}
// Π²ΡΠ²ΠΎΠ΄ΠΈΠΌ Π½Π° ΡΠΊΡΠ°Π½ ΡΠ΅Π·ΡΠ»ΡΡΠ°Ρ
for (int i = 0; i < newtext. Length; i++)
{
Console.Write («{0} «, newtext[i]);
}
Console.ReadLine ();
}
}
}
Π Π΅Π·ΡΠ»ΡΡΠ°Ρ ΡΠ°Π±ΠΎΡΡ Π ΠΈΡ.
ΠΠ°Π΄Π°Π½ΠΈΠ΅ 9
ΠΡΠΎΠ²Π΅ΡΠΈΡΡ, ΠΏΠΎΠΏΠ°Π΄Π°Π΅Ρ Π»ΠΈ Π·Π°Π΄Π°Π½Π½Π°Ρ ΡΠΎΡΠΊΠ° (x1, y1) Π² ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊ ABCD. ΠΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊ Π·Π°Π΄Π°Π΅ΡΡΡ Ρ ΠΏΠΎΠΌΠΎΡΡΡ Π»Π΅Π²ΠΎΠ³ΠΎ Π²Π΅ΡΡ Π½Π΅Π³ΠΎ ΠΈ ΠΏΡΠ°Π²ΠΎΠ³ΠΎ Π½ΠΈΠΆΠ½Π΅Π³ΠΎ ΡΠ³Π»ΠΎΠ². Π‘ΠΏΡΠΎΠ΅ΠΊΡΠΈΡΠΎΠ²Π°ΡΡ Π½Π΅ΠΎΠ±Ρ ΠΎΠ΄ΠΈΠΌΡΠ΅ ΠΊΠ»Π°ΡΡΡ ΠΈ ΡΠΎΡΡΠ°Π²ΠΈΡΡ ΡΠ΅ΡΡΠΈΡΡΡΡΡΡ ΠΏΡΠΎΡΠ΅Π΄ΡΡΡ.
Π Π΅ΡΠ΅Π½ΠΈΠ΅
using System;
using System.Collections.Generic;
using System. Text;
namespace _66
{
// ΠΠΏΠΈΡΠ΅ΠΌ ΠΊΠ»Π°ΡΡ tetr
class tetr
{
public int koordX;
public int koordY;
public int koordA1;
public int koordA2;
public int koordB1;
public int koordB2;
// ΠΊΠΎΠ½ΡΡΡΡΠΊΡΠΎΡ
public tetr ()
{
koordX = 0;
koordY = 0;
koordA1 = 0;
koordB1 = 0;
koordA2 = 0;
koordB2 = 0;
}
// ΠΏΠ°ΡΠ°ΠΌΠ΅ΡΡΠΈΠ·ΠΎΠ²Π°Π½Π½ΡΠΉ ΠΊΠΎΠ½ΡΡΡΡΠΊΡΠΎΡ
public tetr (int koordX, int koordY, int koordA1, int koordA2, int koordB1, int koordB2)
{
this.koordX = koordX;
this.koordY = koordY;
this.koordA1 = koordA1;
this.koordB1 = koordB1;
this.koordA2 = koordA2;
this.koordB2 = koordB2;
}
// ΠΌΠ΅ΡΠΎΠ΄ Π΄Π»Ρ ΠΎΠΏΡΠ΅Π΄Π΅Π»Π΅Π½ΠΈΡ ΠΏΠΎΠ»ΠΎΠΆΠ΅Π½ΠΈΡ ΡΠΎΡΠΊΠΈ
public void rez ()
{
if (koordX <= koordA1 && koordY <= koordB2)
{
if (koordY >= koordB1 && koordX >= koordA2)
{
Console.WriteLine («Π’ΠΎΡΠΊΠ° Π² ΠΏΠ»ΠΎΡΠΊΠΎΡΡΠΈ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ°»);
}
else { Console. WriteLine («Π’ΠΎΡΠΊΠ° ΠΠ ΠΏΠΎΠΏΠ°Π»Π° Π² ΠΏΠ»ΠΎΡΠΊΠΎΡΡΡ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ°»); }
}
else { Console. WriteLine («Π’ΠΎΡΠΊΠ° ΠΠ ΠΏΠΎΠΏΠ°Π»Π° Π² ΠΏΠ»ΠΎΡΠΊΠΎΡΡΡ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ°»); }
}
static void Main (string[] args)
// ΡΠ΅ΡΡΠΈΡΡΡΡΠ°Ρ ΠΏΡΠΎΡΠ΅Π΄ΡΡΠ°
{
tetr s=new tetr ();
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°Ρ ΠΏΡΡΠΌΠΎΡΠ³ΠΎΠ»ΡΠ½ΠΈΠΊΠ° «);
Console.WriteLine («ΠΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΡ Π»Π΅Π²ΠΎΠ³ΠΎ Π²Π΅ΡΡ Π½Π΅Π³ΠΎ ΡΠ³Π»Π°»);
Console.Write («X — «);
s.koordA1 = Convert. ToInt32(Console.ReadLine ());
Console.Write («Y — «);
s.koordB1 = Convert. ToInt32(Console.ReadLine ());
Console.WriteLine («ΠΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΡ ΠΏΡΠ°Π²ΠΎΠ³ΠΎ Π½ΠΈΠΆΠ½Π΅Π³ΠΎ ΡΠ³Π»Π°»);
Console.Write («X — «);
s.koordA2 = Convert. ToInt32(Console.ReadLine ());
Console.Write («Y — «);
s.koordB2 = Convert. ToInt32(Console.ReadLine ());
Console.WriteLine («ΠΠ²Π΅Π΄ΠΈΡΠ΅ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°Ρ ΡΠΎΡΠΊΠΈ «);
Console.Write («X — «);
s.koordX = Convert. ToInt32(Console.ReadLine ());
Console.Write («Y — «);
s.koordY = Convert. ToInt32(Console.ReadLine ());
s.rez ();
Console.ReadKey ();
}
}
}
Π Π΅Π·ΡΠ»ΡΡΠ°Ρ ΡΠ°Π±ΠΎΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ Π ΠΈΡ.
Π ΠΈΡ.