2017-12-14
160
Класс Natur_Chisla.
using System;
using System.Collections.Generic;
using System.Text;
namespace Первые_учебные_классы
{
class Natur_Chisla
{
/// <summary>
/// Шаг 1: Определение полей класса.
/// Конструкторы, метод Show():
/// </summary>
uint x, y;
public Natur_Chisla()
{
Console.WriteLine("Работает конструктор класса без параметров");
x = y = 0;
}
public Natur_Chisla(uint x, uint y)
{
Console.WriteLine("Работает конструктор класса c параметрами");
this.x = x;
this.y = y;
}
public void Show()
{
Console.WriteLine("x= " + x + ", y= " + y);
}
/// <summary>
/// Шаг 2: Методы чтения, модификации полей класса:
/// </summary>
public uint get_x()
{
return x;
}
public uint get_y()
{
return y;
}
public void Set_x(uint a)
{
x = a;
}
public void Set_y(uint a)
{
y = a;
}
/// <summary>
/// Шаг 3: Метод Ostatok() - без параметров:
/// </summary>
public uint Ostatok()
{
if (y == 0)
return x;
if (x < y)
return y;
uint x1 = x, y1 = y;
while (x1 >= y1)
x1 -= y1;
return x1;
}
/// <summary>
/// Шаг 4: Перегруженный метод Ostatok(uint a, uint b) - с параметрами.
/// Обработка исключения:"Деление на ноль":
/// </summary>
public uint Ostatok(uint a, uint b)
{
try
{
double rez = 15 / b;
}
catch (Exception error)
{
Console.WriteLine("Деление на ноль!");
|
|
|
Console.WriteLine(error.Message);
}
if (a < b) return a;
while (a >= b)
a -= b;
return a;
}
/// <summary>
/// Шаг 5: Метод NOD(uint a, uint b):
/// </summary>
public uint NOD(uint a, uint b)
{
if (a == 0 || b == 0)
return 1;
while (a!= b)
if (a > b)
a -= b;
else b -= a;
return a;
}
/// <summary>
/// Шаг 6: Метод NOK(uint a, uint b):
/// </summary>
public uint NOK(uint a, uint b)
{
return a * b / NOD(a, b);
}
/// <summary>
/// Шаг 7: Логический метод Prost(uint a), который проверяет,
/// является ли число-параметр простым:
/// </summary>
public bool Prost(uint a)
{
bool rez = true;
for (uint del = 2; del <= a / 2; del++)
if (Ostatok(a, del) == 0)
{
rez = false;
break;
}
return rez;
}
/// <summary>
/// Шаг 8: Логический метод Wzaimno_prostie(uint a, uint b),
/// который проверяет,являются ли числа-параметры взаимно-простыми:
/// </summary>
public bool Wzaimno_prostie(uint a, uint b)
{
return NOD(a, b) == 1;
}
/// <summary>
/// Шаг 9: Метод Cifri(uint a), который получает и выводит цифры
/// числа-параметра на экран:
/// </summary>
public void Cifri(uint a)
{
uint sf;
while (a!= 0)
{
sf = Ostatok(a, 10);
a /= 10;
Console.WriteLine("Очередная цифра " + sf);
}
}
/// <summary>
/// Шаг 10: Метод обмена - Swap1(uint kol1, uint kol2),в который аргументы передаются по значению.
/// Метод работает с копиями аргументов.
/// </summary>
public void Swap1(uint kol1, uint kol2)
{
uint x = kol1;
kol1 = kol2;
kol2 = x;
}
/// <summary>
/// Шаг 11: Метод обмена - Swap2(ref uint kol1, ref uint kol2),в который аргументы передаются по ссылке.
/// Метод работает с оригиналами аргументов.
/// </summary>
public void Swap2(ref uint kol1, ref uint kol2)
{
uint x = kol1;
kol1 = kol2;
kol2 = x;
}
/// <summary>
/// Шаг 12: Перегруженный метод Cifri(uint a, out sbyte kol), который получает и выводит цифры
/// числа-параметра на экран, а также возвращает их количество:
/// </summary>
public void Cifri(uint a, out sbyte kol)
{
kol = 0;
while (a!= 0)
{
|
|
|
Console.WriteLine("Очередная цифра " +(a%10));
kol++;
a /= 10;
}
}
/// <summary>
/// Шаг 13: Метод Deliteli(int a, out sbyte kol), который возвращает массив делителей числа-параметра a и их количество:
/// </summary>
public uint[] Deliteli(uint a, out sbyte kol)
{
uint[]mas = new uint[100];
sbyte i=0; kol=0;
mas[i]=1; kol++; i++;
for(uint del=2; del<=(a/2); del++)
if (a % del==0)
{
mas[i] = del; kol++; i++;
}
mas[i] = a; kol++;
return mas;
}
/// <summary>
/// Шаг 14: Метод получения максимального значения из любого набора чисел MaxVal(params int[] mas).
/// Параметром метода является массив с произвольным количеством элементов:
/// </summary>
public int MaxVal(params int[] mas)
{
int max;
if (mas.Length == 0)
{
Console.WriteLine("Набор чисел пуст! Аргументов нет!");
return 0;
}
max = mas[0];
for (int i = 1; i < mas.Length; i++)
if (mas[i] > max)
max = mas[i];
return max;
}
/// <summary>
/// Вспомогательный метод Kol_cifr(uint a) для решения задачи:
/// </summary>
public sbyte Kol_cifr(uint a)
{
sbyte kol = 0;
while (a!= 0)
{
a /= 10;
kol++;
}
return kol;
}
/// <summary>
/// Основной метод Mas_Cifr(uint F,out uint F_new) для решения задачи:
/// </summary>
public sbyte [] Mas_Cifr(uint F,out uint F_new)
{
sbyte kol=(sbyte)Kol_cifr(F);
sbyte [] mas = new sbyte [kol];
sbyte i=0; // Индекс первого элемента массива
while (F!= 0)
{
mas[i] =(sbyte) (F % 10);
F /= 10;
i++;
}
F_new = 0;
sbyte i_sr =(sbyte) (kol / 2);// Индекс серединного элемента массива
sbyte x = mas[i_sr];// Серединный элемент массива
uint step_10 = 1; //Степень числа 10 для последней цифры нового //числа.
// В массиве цифры числа расположены в обратном порядке.
for (i = 0; i <(sbyte) (kol/2); i++)
{
F_new +=(uint) (mas[i]*step_10);
step_10 *=10;
}
if (x % 2!= 0)
{
F_new += 9 * step_10;
// Если серединная цифра четная, то этот разряд в числе F_new //нужно просто пропустить.
}
// Далее, разряд серединной цифры пропускаем, т.е.
//вычисляем следующую степень 10.
step_10 *= 10;
for (i = (sbyte) (kol / 2 + 1); i < kol; i++)
{
F_new += (uint) (mas[i] * step_10);
step_10 *= 10;
}
return mas;
}
}
}
