ΠŸΠΎΠΌΠΎΡ‰ΡŒ Π² написании студСнчСских Ρ€Π°Π±ΠΎΡ‚
АнтистрСссовый сСрвис

ΠŸΡ€ΠΎΠ³Ρ€Π°ΠΌΠΌΠΈΡ€ΠΎΠ²Π°Π½ΠΈΠ΅ Π½Π° 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 ();

}

}

}

Π Π΅Π·ΡƒΠ»ΡŒΡ‚Π°Ρ‚ Ρ€Π°Π±ΠΎΡ‚Ρ‹ ΠΏΡ€ΠΎΠ³Ρ€Π°ΠΌΠΌΡ‹ Рис.

Рис.

ΠŸΠΎΠΊΠ°Π·Π°Ρ‚ΡŒ вСсь тСкст
Π—Π°ΠΏΠΎΠ»Π½ΠΈΡ‚ΡŒ Ρ„ΠΎΡ€ΠΌΡƒ Ρ‚Π΅ΠΊΡƒΡ‰Π΅ΠΉ Ρ€Π°Π±ΠΎΡ‚ΠΎΠΉ