Давайте посмотрим как же будем это определять.

//Сначала определим переменные с шириной и высотой прямоугольника и эллипса.
int RectangleWidth = 400;
int RectangleHeight = 200;
int EllipseWidth = 500;
int EllipseHeight = 450;

//Далее зададим им координаты размещения на форме.
int coordR_X = 200;
int coordR_Y = 200;
int coordE_X = 100;
int coordE_Y = 400;

//Создадим прямоугольник и эллипс.
Rectangle RectangleDraw = new Rectangle(coordR_X, coordR_Y, RectangleWidth, RectangleHeight);
Rectangle EllipseDraw = new Rectangle(coordE_X, coordE_Y, EllipseWidth, EllipseHeight);

//Создадим графическую область для прямоугольника и эллипса.
GraphicsPath GraphicsPathRectangle = new GraphicsPath();
GraphicsPath GraphicsPathEllipse = new GraphicsPath();

//Добавим в первую область созданный прямоугольник.
GraphicsPathRectangle.AddRectangle(RectangleDraw);

//Добавим во вторую область созданный эллипс.
GraphicsPathEllipse.AddEllipse(EllipseDraw);

//Создадим точку с координатами (100; 200).
Point PointUser = new Point(100, 200);

Все, мы выполнили создание прямоугольника, эллипса и точки.
Теперь давай проверим определим в какую область попала точка.
С помощью объекта IsVisible можно это сделать.

if (GraphicsPathEllipse.IsVisible(PointUser))
	MessageBox.Show("Попала в эллипс!");

if (GraphicsPathRectangle.IsVisible(PointUser))
	MessageBox.Show("Попала в прямоугольник!");

Суть программы будет заключаться в следующем:

Будем моделировать движение пьяного человека (он пьян до того, что не знает что делает, но лежать ему не хочется). В начальный момент времени задается положение человека в некотором дворе с непроницаемыми стенками и одним выходом. Кроме того даются 5 вероятностей – остаться на месте и перемещаться в 4 стороны. Если появляется попытка переместиться через стенку, то «пьяньчуга» остается на месте. Сумма вероятностей строго равно 1. Если «пьяньчуга» нашел выход или попал в один из люков, то моделирование заканчивается и выводится соответствующее сообщение.

И так, в Visual Studio в C# создайте форму, и объекты как показано на рисунке «Рисунок 1.1». Соответственно, к каждому объекту подписано его имя.

После создания формы и всех ее объектов приступим к написанию кода программы.
Для начала я перечислю, какие библиотеки и глобальные переменные необходимы для работы программы.
Библиотеки:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Drawing2D;

Глобальные переменные:

Point[,] coord = new Point[11, 11];
Point[] coord_courses;
coord_points[] mass_points;
Point PointUser = new Point();
Point PointUser_For_searche = new Point();
int shag = 5;
Graphics Line;
Rectangle EllipseDraw = new Rectangle();
Rectangle EllipseDraw2 = new Rectangle();
GraphicsPath GraphicsPathEllipse;

Для того чтобы запоминать сколько раз «пьяньчуга» попадал в ту или иную точку, мы будем использовать структуру «coord_points», которая включает в себя координаты точки x и y и количество попаданий «Count». Структуру объявляем глобально.

public struct coord_points
{
	int x;
	int y;
	int Count;
	public coord_points(int X, int Y, int count)
	{
		x = X;
		y = Y;
		Count = count;
	}
	public int X
	{
		get { return x; }
		set { x = value; }
	}
	public int Y
	{
		get { return y; }
		set { y = value; }
	}
	public int count
	{
		get { return Count; }
		set { Count = value; }
	}
};

Теперь напишем код для кнопки «Нарисовать местность».

	pictureBox.Refresh(); //Обновить область для рисования
	listBox1.Items.Clear(); // Очищаем ListBox с координатами
	isleovanie.Text = ""; // Очищаем значение исследования
	Line = Graphics.FromHwnd(pictureBox.Handle); // Создаем объект для рисования на pictureBox

	count_iter.Text = 0.ToString();//Обнуляем поле «Кол-во итераций»
	distance.Text = 0.ToString();//Обнуляем поле «Расстояние (пиксеметры)»

	count_courses.Text = 0.ToString();//Обнуляем поле «Общее кол-во шагов»
	count_down.Text = 0.ToString();//Обнуляем поле количество шагов «Вниз»
	count_up.Text = 0.ToString();//Обнуляем поле количество шагов «Вверх»
	count_l.Text = 0.ToString();//Обнуляем поле количество шагов «Влево»
	count_r.Text = 0.ToString();//Обнуляем поле количество шагов «Вправо»

	System.Drawing.Pen red = new Pen(Color.Red, 1);
	SolidBrush EllipseBrush = new SolidBrush(Color.Black);
	Graphics Ellipse = Graphics.FromHwnd(pictureBox.Handle);
	Graphics Ellipse2 = Graphics.FromHwnd(pictureBox.Handle);
	GraphicsPathEllipse = new GraphicsPath();
	Random rnd = new Random();
	int max_h = pictureBox.Height / 2 + pictureBox.Height / 4;
	int max_w = pictureBox.Width / 2 + pictureBox.Width / 4;
	int temp = 0;

	Point start1 = new Point(10, 10);
	Point start2 = new Point(10, 10);
	Point end1 = new Point(10, pictureBox.Height - 50);
	Point end2 = new Point(pictureBox.Width - 10, 10);
	Point end3 = new Point(pictureBox.Width - 10, pictureBox.Height - 50);
	//Координаты помещения
	coord[0, 0].X = end2.X - rnd.Next(pictureBox.Width / 3, pictureBox.Width / 2);
	coord[0, 0].Y = start1.Y;
	coord[0, 1].X = end2.X - rnd.Next(5, pictureBox.Width / 3);
	coord[0, 1].Y = end2.Y;
	//Слева линия
	coord[1, 0].X = start1.X;
	coord[1, 0].Y = start1.Y;
	coord[1, 1].X = end1.X;
	coord[1, 1].Y = end1.Y;
	//Верхняя
	coord[2, 0].X = start1.X;
	coord[2, 0].Y = start1.Y;
	coord[2, 1].X = coord[0, 0].X;
	coord[2, 1].Y = end2.Y;
	//Верхняя 2
	coord[6, 0].X = coord[0, 1].X;
	coord[6, 0].Y = start1.Y;
	coord[6, 1].X = end2.X;
	coord[6, 1].Y = end2.Y;
	//Правая
	coord[3, 0].X = end2.X;
	coord[3, 0].Y = end2.Y;
	coord[3, 1].X = end3.X;
	coord[3, 1].Y = end3.Y;
	//Нижняя
	coord[4, 0].X = end1.X;
	coord[4, 0].Y = end1.Y;
	coord[4, 1].X = end3.X - pictureBox.Width / 2 - pictureBox.Width / 3 - rnd.Next(0, 30);
	coord[4, 1].Y = end3.Y;
	//Нижняя
	coord[7, 0].X = end3.X - pictureBox.Width / 4 - pictureBox.Width / 2 - rnd.Next(0, 50);
	coord[7, 0].Y = end1.Y;
	coord[7, 1].X = end3.X;
	coord[7, 1].Y = end3.Y;
	//Нижняя 2
	coord[8, 0].X = coord[4, 1].X;
	coord[8, 0].Y = end3.Y;
	coord[8, 1].X = coord[4, 1].X;
	coord[8, 1].Y = end3.Y + 40;
	//Нижняя 2
	coord[9, 0].X = coord[7, 0].X;
	coord[9, 0].Y = end3.Y;
	coord[9, 1].X = coord[7, 0].X;
	coord[9, 1].Y = coord[8, 1].Y;
	//Нижняя 3
	coord[10, 0].X = coord[8, 1].X;
	coord[10, 0].Y = coord[8, 1].Y;
	coord[10, 1].X = coord[9, 1].X;
	coord[10, 1].Y = coord[9, 1].Y;
	//Координаты для эллипса
	coord[5, 0].X = rnd.Next(50, max_w);
	coord[5, 0].Y = rnd.Next(50, max_h);
	coord[5, 1].X = rnd.Next(50, max_w);
	coord[5, 1].Y = rnd.Next(50, max_h);
	for (; ; )
	{
		if (coord[5, 1].X == 0 || coord[5, 1].Y == 0)
		{
			temp = rnd.Next(50, max_w);
			if (temp != coord[5, 0].X)
				coord[5, 1].X = temp;

			temp = rnd.Next(50, max_w);
			if (temp != coord[5, 0].Y)
				coord[5, 1].Y = temp;
		}
		else
			break;
	}
	//////////////////
	EllipseDraw = new Rectangle(coord[5, 0].X, coord[5, 0].Y, 10, 10);
	EllipseDraw2 = new Rectangle(coord[5, 1].X, coord[5, 1].Y, 10, 10);

	Line.DrawLine(red, start1.X, start1.Y, end1.X, end1.Y); //Левая

	Line.DrawLine(red, coord[2, 0].X, coord[2, 0].Y, coord[2, 1].X, coord[2, 1].Y); //Верхняя
	Line.DrawLine(red, coord[6, 0].X, coord[6, 0].Y, coord[6, 1].X, coord[6, 1].Y); //Верхняя

	Line.DrawLine(red, end2, end3); //Правая

	Line.DrawLine(red, coord[4, 0].X, coord[4, 0].Y, coord[4, 1].X, coord[4, 1].Y); //Нижняя прямая
	Line.DrawLine(red, coord[7, 0].X, coord[7, 0].Y, coord[7, 1].X, coord[7, 1].Y); //Нижняя прямая

	Line.DrawLine(red, coord[8, 0].X, coord[8, 0].Y, coord[8, 1].X, coord[8, 1].Y); //Нижняя 2 слева

	Line.DrawLine(red, coord[9, 0].X, coord[9, 0].Y, coord[9, 1].X, coord[9, 1].Y); //Нижняя 2 справа

	Line.DrawLine(red, coord[10, 0].X, coord[10, 0].Y, coord[10, 1].X, coord[10, 1].Y); //Нижняя 3 прямая

	int el_x1 = rnd.Next(50, max_w);
	int el_y1 = rnd.Next(50, max_h);

	GraphicsPathEllipse.AddEllipse(new Rectangle(el_x1, el_y1, 10, 10));//Рисуем первый люк
	Ellipse.FillEllipse(EllipseBrush, new Rectangle(el_x1, el_y1, 10, 10));
	//Рисуем случайно все остальные люки (kolvolukov.Text – кол-во люков)
	for (int i = 2; i < = Convert.ToInt32(kolvolukov.Text); i++)
	{
		int el_x2 = rnd.Next(50, max_w);
		int el_y2 = rnd.Next(50, max_h);
		for (; ; )
		{
			if (el_x2 == 0 || el_y2 == 0)
			{
				temp = rnd.Next(50, max_w);
				if (temp != el_x1)
					el_x2 = temp;

				temp = rnd.Next(50, max_w);
				if (temp != el_y1)
					el_y2 = temp;
			}
			else
				break;
		}
		el_x1 = el_x2;
		el_y1 = el_y2;

		GraphicsPathEllipse.AddEllipse(new Rectangle(el_x2, el_y2, 10, 10));
		Ellipse.FillEllipse(EllipseBrush, new Rectangle(el_x2, el_y2, 10, 10));
	}
	searching.Enabled = true; //Активируем кнопку «Провести исследование»

Напишем метод «MessageShow», который будет выводить сообщение на экран при завершении моделирования.
void MessageShow(int type)
{
if(type == 1)
MessageBox.Show(«Моделирование закончено!»);
else
MessageBox.Show(«Пьянчуга попал в люк»);
}
Теперь напишем объект «check», который осуществляет ряд проверок движения «пьяньчуги». Если «пьяньчуга» нашел выход или попал в один из люков, выводится соответствующее сообщение и моделирование прекращается.

int check(int type)
{
	//Конец пути пьянчуги
	if (PointUser.X >= coord[0, 0].X && PointUser.X < = coord[0, 1].X && PointUser.Y <= coord[0, 1].Y)
	{
		if(type == 1)
			MessageShow(1);
		return -1;
	}
	//Пьянчуга попал в люк
	if (GraphicsPathEllipse.IsVisible(PointUser))
	{
		if(type == 1)
			MessageShow(2);
		return -1;
	}
	//Слева линия
	if (PointUser.X <= coord[1, 0].X && PointUser.Y >= coord[1, 0].Y && PointUser.Y < = coord[1, 1].Y)
	{
		PointUser.X += shag;
	}
	//Верхняя
	if(PointUser.X >= coord[2, 0].X && PointUser.X < = coord[2, 1].X && PointUser.Y <= coord[2, 0].Y)
	{
		PointUser.Y += shag;
	}
	//Верхняя 2
	if (PointUser.X >= coord[6, 0].X && PointUser.X < = coord[6, 1].X && PointUser.Y <= coord[6, 0].Y)
	{
		PointUser.Y += shag;
	}
	//Правая линия
	if (PointUser.X >= coord[3, 0].X && PointUser.Y >= coord[3, 0].Y && PointUser.Y < = coord[3, 1].Y)
	{
		PointUser.X -= shag;
	}
	//Нижняя
	if ((PointUser.X >= coord[4, 0].X && PointUser.X < = coord[4, 1].X) && PointUser.Y >= coord[4, 1].Y)
	{
		PointUser.Y -= shag;
	}
	if ((PointUser.X >= coord[7, 0].X && PointUser.X < = coord[7, 1].X) && PointUser.Y >= coord[7, 1].Y)
	{
		PointUser.Y -= shag;
	}
	if (PointUser.X < = coord[8, 0].X && PointUser.Y >= coord[8, 0].Y && PointUser.Y < = coord[8, 1].Y)
	{
		PointUser.X += shag;
	}
	if ((PointUser.X >= coord[10, 0].X && PointUser.X < = coord[10, 1].X) && PointUser.Y >= coord[10, 1].Y)
	{
		PointUser.Y -= shag;
	}
	if (PointUser.X >= coord[9, 0].X && PointUser.Y >= coord[9, 0].Y && PointUser.Y < = coord[9, 1].Y)//Нижняя 2 справа
	{
		PointUser.X -= shag;
	}
	return 0;
}

Следующие объекты и методы необходимы для проверки правильного указания коэффициентов вероятности перемещения и количества люков.

bool check_ver()
{
	double sum = Convert.ToDouble(go_up.Text) + Convert.ToDouble(go_down.Text) + Convert.ToDouble(go_right.Text) + Convert.ToDouble(go_left.Text);

	if (sum > 1 || sum < 1)
		MessageBox.Show("Сумма коэффициентов направленности превышает допустимое значение равное 1.");
	else if (Convert.ToInt32(kolvolukov.Text) < 1 || Convert.ToInt32(kolvolukov.Text) > 50)
		MessageBox.Show("Количество люков не может быть меньше 1 или больше 50.");
	else
		return true;

	return false;
}
//Запускается, когда происходит изменение Вероятности перемещения «Вверх»
private void go_up_TextChanged(object sender, EventArgs e)
{
	check_ver();
}
//Запускается, когда происходит изменение Вероятности перемещения «Вниз»
private void go_down_TextChanged(object sender, EventArgs e)
{
	check_ver();
}
//Запускается, когда происходит изменение Вероятности перемещения «Вправо»
private void go_right_TextChanged(object sender, EventArgs e)
{
	check_ver();
}
//Запускается, когда происходит изменение Вероятности перемещения «Влево»
private void go_left_TextChanged(object sender, EventArgs e)
{
	check_ver();
}
//Запускается, когда происходит изменение поля Количество люков
private void kolvolukov_TextChanged(object sender, EventArgs e)
{
	check_ver();
}

Напишем методы, которые изменяют шаг движения. Если на объект выводятся «точки», шаг составляет 5, если цифры – 15. Создано для удобства вывода на экран.

private void pic_point_CheckedChanged(object sender, EventArgs e)
{
	shag = 5;
}
private void pic_char_CheckedChanged(object sender, EventArgs e)
{
	shag = 15;
}
//Объект «isPoint» возвращает положение координаты точки, если она есть в массиве mass_points
int isPoint(Point mass_nums, coord_points[] mass_points)
{
	for (int i = 0; i < mass_points.Count(); i++)
	{
		if (mass_points[i].X == mass_nums.X && mass_points[i].Y == mass_nums.Y)
			return i;
	}
	return -1;
}
//Метод «setCount» увеличивает счетчик попадания человека в точку на 1
void setCount(coord_points[] mass_points, int index)
{
	mass_points[index].count = mass_points[index].count + 1;
}
// Метод «listBox1_MouseDoubleClick» вызывается при двойном клике на объект «listBox1», где хранятся координаты перемещения «пьяньчуги». Метод выделяет красным цветом точку по указанной координате.
private void listBox1_MouseDoubleClick(object sender, MouseEventArgs e)
{
	System.Drawing.Pen red = new Pen(Color.Red, 2);
	Graphics Ellipse = Graphics.FromHwnd(pictureBox.Handle);

	Ellipse.DrawEllipse(red, new Rectangle(mass_points[listBox1.Items.IndexOf(listBox1.Text)].X, mass_points[listBox1.Items.IndexOf(listBox1.Text)].Y, 2, 2));

}

Наконец, метод «pictureBox_MouseDown», который осуществляет моделирование движения пьяного человека.

private void pictureBox_MouseDown(object sender, MouseEventArgs e)
{
	if (check_ver() == true)//Если все проверки прошли
	{
		PointUser.X = e.X; //Получаем X-координату точки
		PointUser.Y = e.Y; //Получаем Y-координату точки

		PointUser_For_searche.X = e.X;
		PointUser_For_searche.Y = e.Y;

		Line = Graphics.FromHwnd(pictureBox.Handle);
		System.Drawing.Graphics graph = Graphics.FromHwnd(pictureBox.Handle);

		System.Drawing.Pen WhiteSmoke = new Pen(Color.WhiteSmoke, 1);
		System.Drawing.Pen Black = new Pen(Color.Black, 2);
		EllipseDraw = new Rectangle(PointUser.X, PointUser.Y, 2, 2);
		Graphics Ellipse = Graphics.FromHwnd(pictureBox.Handle);
		Ellipse.DrawEllipse(Black, EllipseDraw);

		Random rnd = new Random();
		int count = 0, countiter = 0, c_left = 0, c_right = 0, c_up = 0, c_down = 0;
		double hod, left, right, up, down;
		coord_courses = new Point[Convert.ToInt32(count_steps.Text)];

		List<Point> mass_nums = new List<point>();

		for (int i = 1; i < = Convert.ToInt32(count_steps.Text); i++)
		{
			if (rnd.Next(1, 5) != 1)//Если вероятность не «стоять на месте»
			{
				coord_courses[count] = PointUser;
				mass_nums.Add(PointUser);

				hod = rnd.NextDouble();
				up = Convert.ToDouble(go_up.Text);
				down = Convert.ToDouble(go_down.Text);
				right = up + down;
				left = up + down + Convert.ToDouble(go_right.Text);
//Если вероятность «идти влево»
				if (hod > left && hod < left + Convert.ToDouble(go_left.Text))
				{
					PointUser.X -= shag;
					if (check(1) == -1)
						break;
					else
					{
						if (pic_point.Checked)
							Ellipse.DrawEllipse(Black, new Rectangle(PointUser.X, PointUser.Y, 2, 2));
					}
					c_left++;
				}
				else if (hod > 0 && hod < up) //Если вероятность «идти вверх»
				{
					PointUser.Y -= shag;
					if (check(1) == -1)
						break;
					else
					{
						if (pic_point.Checked)
							Ellipse.DrawEllipse(Black, new Rectangle(PointUser.X, PointUser.Y, 2, 2));
					}
					c_up++;
				}
				else if (hod > right && hod < right + Convert.ToDouble(go_right.Text)) //вправо
				{
					PointUser.X += shag;
					if (check(1) == -1)
						break;
					else
					{
						if (pic_point.Checked)
							Ellipse.DrawEllipse(Black, new Rectangle(PointUser.X, PointUser.Y, 2, 2));
					}
					c_right++;
				}
				else if (hod > up && hod < up + down) //вниз
				{
					PointUser.Y += shag;
					if (check(1) == -1)
						break;
					else
					{
						if (pic_point.Checked)
							Ellipse.DrawEllipse(Black, new Rectangle(PointUser.X, PointUser.Y, 2, 2));
					}
					c_down++;
				}
			}
			countiter++;
		}
		count = c_down + c_left + c_right + c_up;

		count_iter.Text = countiter.ToString();
		distance.Text = (count).ToString();

		count_courses.Text = count.ToString();
		count_down.Text = c_down.ToString();
		count_up.Text = c_up.ToString();
		count_l.Text = c_left.ToString();
		count_r.Text = c_right.ToString();

		up = Convert.ToDouble(go_up.Text);
		down = Convert.ToDouble(go_down.Text);
		right = Convert.ToDouble(go_right.Text);
		left = Convert.ToDouble(go_left.Text);

		if (up > down && up > right && up > left)
			isleovanie.Text = "При к.н. (Вверх) пьянчуга прошел " + Math.Round(((double)c_up / (double)count) * 100) + "% пути";
		else if (down > up && down > right && down > right)
			isleovanie.Text = "При к.н. (Вниз) пьянчуга прошел " + Math.Round(((double)c_down / (double)count) * 100) + "% пути";
		else if (right > up && right > left && right > down)
			isleovanie.Text = "При к.н. (Вправо) пьянчуга прошел " + Math.Round(((double)c_right / (double)count) * 100) + "% пути";
		else if (left > up && left > right && left > down)
			isleovanie.Text = "При к.н. (Влево) пьянчуга прошел " + Math.Round(((double)c_left / (double)count) * 100) + "% пути";

		mass_points = new coord_points[mass_nums.Count];
		Point[] coord_courses2 = new Point[mass_nums.Count];
		int index = 0, j = 0;
		for (int i = 0; i < mass_nums.Count; i++)
			if ((index = isPoint(mass_nums[i], mass_points)) > -1)
			{
				setCount(mass_points, index);
			}
			else
			{
				mass_points[j].X = mass_nums[i].X;
				mass_points[j].Y = mass_nums[i].Y;
				mass_points[j].count = 1;
				j++;
			}

		for (int i = j - 1; i >= 0; i--)
		{
			if (!pic_point.Checked)
			{
				if (i + 1 == j)
					graph.DrawString(mass_points[i].count.ToString(), new Font("Times New Roman", 8), new SolidBrush(Color.Red), mass_points[i].X - 3, mass_points[i].Y - 8);
				else
					graph.DrawString(mass_points[i].count.ToString(), new Font("Times New Roman", 8), new SolidBrush(Color.Black), mass_points[i].X - 3, mass_points[i].Y - 8);
			}
			listBox1.Items.Add("X:" + mass_points[i].X + "; Y:" + mass_points[i].Y + "; Кол-во:" + mass_points[i].count);
		}
	}
}

Напишем последний метод «searching_Click», чтобы завершить написание программы. Здесь выполняется исследование.

private void searching_Click(object sender, EventArgs e)
{
	Random rnd = new Random();
	int count = 0, countiter = 0, c_left = 0, c_right = 0, c_up = 0, c_down = 0;
	double hod, left, right, up, down;

	for (int sch = 1; sch < = 10; sch++)
	{
		PointUser = PointUser_For_searche;
		for (int i = 1; i <= Convert.ToInt32(count_steps.Text); i++)
		{
			if (rnd.Next(1, 5) != 1)
			{
				hod = rnd.NextDouble();
				up = Convert.ToDouble(go_up.Text);
				down = Convert.ToDouble(go_down.Text);
				right = up + down;
				left = up + down + Convert.ToDouble(go_right.Text);

				if (hod > left && hod < left + Convert.ToDouble(go_left.Text)) //влево
				{
					PointUser.X -= shag;

					if (check(2) == -1)
						break;
					c_left++;
				}
				else if (hod > 0 && hod < up) //вверх
				{
					PointUser.Y -= shag;

					if (check(2) == -1)
						break;
					c_up++;
				}
				else if (hod > right && hod < right + Convert.ToDouble(go_right.Text)) //вправо
				{
					PointUser.X += shag;
					if (check(2) == -1)
						break;
					c_right++;
				}
				else if (hod > up && hod < up + down) //вниз
				{
					PointUser.Y += shag;
					if (check(2) == -1)
						break;
					c_down++;
				}
			}
			countiter++;
		}
	}
	count = c_down + c_left + c_right + c_up;

	count_iter.Text = countiter.ToString();
	distance.Text = (count).ToString();

	count_courses.Text = count.ToString();
	count_down.Text = c_down.ToString();
	count_up.Text = c_up.ToString();
	count_l.Text = c_left.ToString();
	count_r.Text = c_right.ToString();

	up = Convert.ToDouble(go_up.Text);
	down = Convert.ToDouble(go_down.Text);
	right = Convert.ToDouble(go_right.Text);
	left = Convert.ToDouble(go_left.Text);

	if (up > down && up > right && up > left)
	{
		isleovanie.Text = "При к.н. (Вверх) пьянчуга прошел " + Math.Round(((double)c_up / (double)count) * 100) + "% пути";
		label10.Text = "Среднее значение: " + Math.Round((double)c_up / (double)count, 2).ToString();
	}
	else if (down > up && down > right && down > right)
	{
		isleovanie.Text = "При к.н. (Вниз) пьянчуга прошел " + Math.Round(((double)c_down / (double)count) * 100) + "% пути";
		label10.Text = "Среднее значение: " + Math.Round((double)c_down / (double)count, 2).ToString();
	}
	else if (right > up && right > left && right > down)
	{
		isleovanie.Text = "При к.н. (Вправо) пьянчуга прошел " + Math.Round(((double)c_right / (double)count) * 100) + "% пути";
		label10.Text = "Среднее значение: " + Math.Round((double)c_right / (double)count, 2).ToString();
	}
	else if (left > up && left > right && left > down)
	{
		isleovanie.Text = "При к.н. (Влево) пьянчуга прошел " + Math.Round(((double)c_left / (double)count) * 100) + "% пути";
		label10.Text = "Среднее значение: " + Math.Round((double)c_left / (double)count, 2).ToString();
	}
}

После написание кода программы проверим ее работу:

• Указать вероятности перемещения
• Указать количество люков и тактов
• Выбрать метод представления пути перемещения («Точки» или «Цифры»)
• Кликнуть по кнопке «Нарисовать местность»
• Кликнуть мышкой по области рисования «pictureBox»
• Посмеяться над «пьяньчугой»
• Кликнуть по кнопке «Провести исследование»

Примеры работы программы:

«Пьяньчуга» попал в люк:

«Пьяньчуга» нашел выход:

Данную статью Вы можете скачать в формате doc
Скачать Пьяньчуга – Моделирование движения пьяного человека на C#

Автор: Евтеев Евгений Александрович

Email: evteev_e2003@mail.ru

Pt m1, m2, v1, v2, b1, b2;
public struct Pt
{
	double x;
	double y;
	public Pt(double a, double b)
	{
		x = a;
		y = b;
	}
	public double X
	{
		get { return x; }
		set { x = value; }
	}
	public double Y
	{
		get { return y; }
		set { y = value; }
	}
};

Далее напишем функции для вычисления длин, углов треугольника и т.д. и процедуру для вывода графики на форму.
Пишем функцию нахождения длины строны треугольника по заданным координатам. Будем использовать формулу нахождения расстояния между двумя точками.
S = ((x2 – x1) ^2+ (y2-y1) ^2) ^ (1/2), где (x1, y1) и (x2, y2) – это координаты начала и конца отрезка.

double SideLength(double x1, double y1, double x2, double y2)
{
	double a = Math.Sqrt((x2 - x1) / 10 * (x2 - x1) / 10 + (y2 - y1) / 10 * (y2 - y1) / 10);
	return a * 10;
}

Чтобы найти углы треугольника воспользуемся формулой скалярного произведения векторов
cos(ang) = a/(s1*s2), где a – скалярное произведение векторов s1 и s2,а s1 и s2 – стороны треугольника (абсолютные величины векторов).

double Angles(Pt p1, Pt p2, Pt p3)
{
	double a = (p2.X - p1.X) * (p3.X - p1.X) + (p2.Y - p1.Y) * (p3.Y - p1.Y);
	double exp = a / SideLength(p1.X, p1.Y, p2.X, p2.Y) / SideLength(p1.X, p1.Y, p3.X, p3.Y);
	return Math.Acos(exp);
}

Периметр находим как сумма длин трех сторон треугольника.

double Perimetr(double s1, double s2, double s3)
{
	return (s1 + s2 + s3);
}

Площадь треугольника находится с помощью формулы Герона:

Sqr = (p * (p - s1) * (p - s2) * (p - s3)) ^ (1 / 2), где p - полупериметр треугольника.
double Sqare(double s1, double s2, double s3)
{
	double p;
	p = (Perimetr(s1, s2, s3)) / 2;
	return Math.Sqrt((p * (p - s1) * (p - s2) * (p - s3)));
}

Теперь найдем радиусы вписанной и описанной окружности.

double radius(double S, double p)
{
	return S / p;
}

double Radius(double S, double s1, double s2, double s3)
{
	return (s1 * s2 * s3) / (4 * S);
}

И, наконец, процедура, которая будет осуществлять конечные вычисления, и рисовать окружность на форме программы.

void DescrCircle(double R, int x01, int y01, int x02, int y02, double l1, double m1, double l2, double m2)
{
	double X, Y;
	if ((l1 != 0) && ((m1 / l1) - (m2 / l2) != 0) && (l2 != 0))
	{
		X = ((m1 / l1) * x01 - y01 - (m2 / l2) * x02 + y02) / ((m1 / l1) - (m2 / l2));
		Y = (m1 * X - m1 * x01 + l1 * y01) / l1;
		System.Drawing.Graphics graph = this.CreateGraphics();
		System.Drawing.Pen color = new Pen(Color.Blue, 1);
		graph.DrawEllipse(color, (int)X, (int)Y, 1, 1); //рисуем центр окружности
		graph.DrawEllipse(color, (int)X - (float)R, (int)Y - (float)R, (float)R * 2, (float)R * 2); //рисуем окружность
	}
}

Процедура кнопки, которая будет вызывать всю процедуру рисования треугольника и окружностей.

private void button1_Click_1(object sender, EventArgs e)

Объявим нужные переменные и занесем в структуру координаты вершин треугольника из текстовых полей на форме.

double s1 ,s2 ,s3 ,S ,p ,r, R, ang1, ang2, ang3, x1, x2, y1, y2, det;
znach.Items.Clear();

Pt[] a = new Pt[3];
a[0].X = Convert.ToDouble(Ax.Text);
a[0].Y = Convert.ToDouble(Ay.Text);
a[1].X = Convert.ToDouble(Bx.Text);
a[1].Y = Convert.ToDouble(By.Text);
a[2].X = Convert.ToDouble(Cx.Text);
a[2].Y = Convert.ToDouble(Cy.Text);

Нарисуем форме три линии, которые будут составлять наш треугольник и названия вершин A, B и C.

System.Drawing.Graphics graph = this.CreateGraphics();
System.Drawing.Pen red = new Pen(Color.Red, 1);

graph.DrawLine(red, (int)a[0].X, (int)a[0].Y, (int)a[1].X, (int)a[1].Y);
graph.DrawString("A", new Font("Times New Roman", 12), new SolidBrush(Color.Black), (int)a[0].X, (int)a[0].Y);
graph.DrawLine(red, (int)a[1].X, (int)a[1].Y, (int)a[2].X, (int)a[2].Y);
graph.DrawString("B", new Font("Times New Roman", 12), new SolidBrush(Color.Black), (int)a[1].X, (int)a[1].Y);
graph.DrawLine(red, (int)a[0].X, (int)a[0].Y, (int)a[2].X, (int)a[2].Y);
graph.DrawString("C", new Font("Times New Roman", 12), new SolidBrush(Color.Black), (int)a[2].X, (int)a[2].Y);

Используя написанные функции, найдем длины сторон, полупериметр, площадь, радиусы вписанной и описанной окружности и углы треугольника.

s1 = SideLength(a[0].X, a[0].Y, a[1].X, a[1].Y);
s2 = SideLength(a[1].X, a[1].Y, a[2].X, a[2].Y);
s3 = SideLength(a[2].X, a[2].Y, a[0].X, a[0].Y);

p = (Perimetr(s1, s2, s3)) / 2;
S = Sqare(s1, s2, s3);

r = radius(S, p);
R = Radius(S, s1, s2, s3);

ang1 = Angles(a[2], a[0], a[1]);
ang2 = Angles(a[0], a[1], a[2]);
ang3 = Angles(a[1], a[2], a[0]);

Выведем на форму все эти вычисленные значения в ListBox “znach”.

znach.Items.Add("Длина AB: " + s1);
znach.Items.Add("Длина BC: " + s2);
znach.Items.Add("Длина AC: " + s3);
znach.Items.Add("Полупериметр: " + p);
znach.Items.Add("Площадь: " + S);
znach.Items.Add("Радиус вписанной о.: " + r);
znach.Items.Add("Радиус описанной о.: " + R);
znach.Items.Add("Угл CAB: " + ang1);
znach.Items.Add("Угл ABC: " + ang2);
znach.Items.Add("Угл BCA: " + ang3);

Найдем середины сторон s1 и s2.

m1.X = (a[0].X + a[1].X) / 2;
m1.Y = (a[0].Y + a[1].Y) / 2;
m2.X = (a[1].X + a[2].X) / 2;
m2.Y = (a[1].Y + a[2].Y) / 2;

Необходимо повернуть точки на угол 90 градусов.
Поворачиваем точку а[2] вокруг середины стороны:

 x1 = a[2].X; y1 = a[2].Y;
x1 -= m2.X; y1 -= m2.Y;
b1.X = x1 * Math.Cos(Math.PI / 2) - y1 * Math.Sin(Math.PI / 2);
b1.Y = x1 * Math.Sin(Math.PI / 2) + y1 * Math.Cos(Math.PI / 2);
b1.X += m2.X; b1.Y += m2.Y;
v1.X = b1.X - m2.X; v1.Y = b1.Y - m2.Y;

Поворачиваем точку а[0] вокруг середины стороны s1:

x1 = a[0].X; y1 = a[0].Y;
x1 -= m1.X; y1 -= m1.Y;
b2.X = x1 * Math.Cos(Math.PI / 2) - y1 * Math.Sin(Math.PI / 2);
b2.Y = x1 * Math.Sin(Math.PI / 2) + y1 * Math.Cos(Math.PI / 2);
b2.X += m1.X; b2.Y += m1.Y;
v2.X = b2.X - m1.X; v2.Y = b2.Y - m1.Y;

Вызовем нашу процедуру для вывода графики и построим описанную окружность с центром в точке пересечения серединных перепендикуляров.

DescrCircle(R, (int)m1.X, (int)m1.Y, (int)m2.X, (int)m2.Y, v2.X, v2.Y, v1.X, v1.Y);

int coef1 = 1, coef2 = 1; //коэффициенты,указывающие напрвление поворота
Вычисляем знак третьей координаты векторного произведения векторов, между которыми строится биссектриса.

det = (a[1].X - a[0].X) * (a[2].Y - a[0].Y) - (a[2].X - a[0].X) * (a[1].Y - a[0].Y);
if (det > 0) coef1 = -1;
	det = (a[1].X - a[2].X) * (a[0].Y - a[2].Y) - (a[0].X - a[2].X) * (a[1].Y - a[2].Y);
if (det > 0)
	coef2 = -1;

Поворачиваем точку a[2] вокруг a[0] на угол равный половине угла ang2

x1 = a[2].X; y1 = a[2].Y;
x1 -= a[0].X; y1 -= a[0].Y;
b1.X = x1 * Math.Cos(coef1 * ang2 / 2) - y1 * Math.Sin(coef1 * ang2 / 2);
b1.Y = x1 * Math.Sin(coef1 * ang2 / 2) + y1 * Math.Cos(coef1 * ang2 / 2);
b1.X += a[0].X; b1.Y += a[0].Y;
v1.X = b1.X - a[0].X; v1.Y = b1.Y - a[0].Y;

x2 = a[0].X; y2 = a[0].Y;
x2 -= a[2].X; y2 -= a[2].Y;
b2.X = x2 * Math.Cos(coef2 * ang1 / 2) - y2 * Math.Sin(coef2 * ang1 / 2);
b2.Y = x2 * Math.Sin(coef2 * ang1 / 2) + y2 * Math.Cos(coef2 * ang1 / 2);
b2.X += a[2].X; b2.Y += a[2].Y;
v2.X = b2.X - a[2].X; v2.Y = b2.Y - a[2].Y; //v1.x v1.y- координаты направляющего вектора биссектрисы

И последнее, что мы делаем это выполняем построение вписанной окружности с центром в точке пересечения биссектрисс.

DescrCircle(r, (int)a[2].X, (int)a[2].Y, (int)a[0].X, (int)a[0].Y, v2.X, v2.Y, v1.X, v1.Y);

Треугольник и две окружности построены, для решения этой задачи нам понадобились небольшие знания C# и геометрии.
Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

Форму создали, разместили необходимые объекты на ней. Теперь будем заниматься написанием кода программы. Числа, для которых будет производиться поиск НОК, будут вводиться через пробел. Для того, что их читать из поля “n_gr ” напишем функцию.

string[] nums(string str, int f_m)
{
	string[] numbers = new string[f_m + 1];
	f_m = 0;
	for (int i = 0; i < str.Length; i++)
	{
		if (str.Substring(i, 1) != " ")
			numbers[f_m] += str.Substring(i, 1);
		else
			f_m++;
	}

	return numbers;
}

Входные параметры “str” и “f_m” – это строка с числа и количество чисел соответственно. Создаем массив размерностью “f_m” и начинаем “выдирать” числа из строки и добавлять их в массив “numbers”. Функция возращает массив с числами из строки.

Теперь процедура события клика по кнопке “find”:

private void find_Click(object sender, EventArgs e)
{
	string s = n_gr.Text;
	int i = 0, f_m = 0;
	while (i < s.Length)
	{
		if (s.Substring(i, 1) == " ")
			f_m++;
		i++;
	}
	string[] numbers = new string[f_m + 1];
	numbers = nums(s, f_m);
	int c = 2;
	bool nok = true;
	for (; ; )
	{
		for (i = 0; i < numbers.Length; i++)
			if (numbers[i] != "")
				if (c % Convert.ToInt32(numbers[i]) == 0)
				{
					if (i == 0 || nok == true)
						nok = true;
				}
				else
					nok = false;
		if (nok == true)
		{
			n_nok2.Text = Convert.ToString(c);
			break;
		}
		if (c >= 1000000)
		{
			n_nok2.Text = "НОК для данных чисел не найден!";
			break;
		}
		c++;
	}
}

Здесь сначала вычисляется количество чисел в введенной строке, создается и заполняется массив с числами. Затем используется следующий алгоритм вычисления НОК: постоянно увеличивающееся число 2 делим на каждое из введенных чисел и НОК будет найден в том случае, когда остаток от деления на каждое число будет равен нулю. Если НОК найден или количество проходов цикла перевалило за 1000000 прекращаем работу программы, выводим соответствующий результат ее работы.

На рисунке показан пример удачного поиска НОК, универсальный алгоритм работает правильно.

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

int nod_recur(int num1, int num2)
{
	int n = num1 % num2;
	num1 = num2;
	num2 = n;
	if (n > 0)
		return nod_recur(num1, num2);
	else
		return num1;
}

Как работает эта функция, я рассказывать не буду, т.к. вы можете прочитать это в другой моей статье, посвященной этому алгоритму. Ну и собственно код процедуры события клика по кнопке “button1”:

private void button1_Click(object sender, EventArgs e)
{
	int num1 = Convert.ToInt32(n1.Text);
	int num2 = Convert.ToInt32(n2.Text);
	n_nok.Text = Convert.ToString(num1 * num2 / nod_recur(num1, num2));
}

Как вы видите из кода, здесь происходит считывание двух введенных чисел в переменные и вычисление НОК. Можно сказать, что НОК вычисляется в два действия: перемножаются два и результат от умножения делится на результат вычисления НОД этих двух чисел. Результат вычисления НОК записывается в текстовое поле “n_nok”.

Вы думали, что написать такую программу будет не так просто? Извините, что разочаровал вас. В другой статье, я расскажу вам, как вычислить НОК для двух и более чисел, так называемый универсальный алгоритм.

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

Как преобразовать десятичное число в двоичный вид на VC++?

Ответ на этот вопрос мы и рассмотрим в этой статье. Мы будем использовать всем известный метод, нахождения двоичного представления десятичного числа – деление числа на 2. Все эти преобразования будут находиться в процедуре “Dec2Bin(int ch)”, где “ch”- число в десятичном представлении, которое собственно мы будем декодировать в двоичное.

До всего прочего нужно сначала объявить переменную “n” как константу: “const int n = 32;” Она отвечает за размерность массива “s[n]”, в который будет помещаться двоичное представление числа.
И так, давайте рассмотрим процедуру “Dec2Bin(int ch)”, которая будет преобразовать десятичное число в двоичный вид. Что в этой процедуре мы делаем?

Наше число в 10-м виде делим на 2 с остатком и если при делении получается число с остатком, то в i-й элемент массива “s[i]” мы записываем число 1, в противном случае записываем 0. Этому числу “ch” приравниваем значение равное “ch”деленное на 2, эти действия выполняются пока число “ch” не будут равно нулю.

Дальше проверяем, если наше 10-е число отрицательное инвертируем значения массива “s[n]”, т.е. число 1 заменяем на 0 и число 0 на 1. Это правило распространяется только на отрицательные числа. Затем приводим наш массив “s[n]” в нормальный вид, инвертируя значения до тех пор, пока ни встретится значение равное 0. В конце концов, прогоняя массив по циклу “for” выводим двоичное представление числа в 10-м виде. Вот и все, теперь посмотрите, что получилось:

Процедура “Dec2Bin(int ch)” -Перевод из десятичной системы в двоичную

void Dec2Bin(int ch)
{
	int i, ch2, s[n];
	ch2 = ch;
	for (i = 0; i < n; i++)
	s[i] = 0;
	for (i = 0; ch != 0; i++)
	{
		s[i] = abs(ch) % 2; //текущему значению массива s присваиваем 1 или 0
		ch = abs(ch) / 2;
	}
	if (ch2 < 0)
	{
		for (i = n - 1; i >= 0; i--)
			if (s[i] == 1)
				s[i] = 0;
			else
				s[i] = 1;
	}
	for (i = 0; i < n; i++)
		if (s[i] == 1)
			s[i] = 0;
		else
		{
			s[i] = 1;
			break;
		}
	wcout << L"Двоичное представление :" << endl;
	for (i = n - 1; i >= 0; i--) //цикл вывода массива с введенным числом
		cout << s[i]; //представленным в двоичной системе счисления
}

Число в 2-м виде получили, но разве вам не хочется декодировать его обратно? Для начала напишем функции возведения числа в степень и получения длины массива, они нам понадобятся.

Функция “len(char str[])”:

int len(char str[])
{
	int i = 0;
	while (str[i] != 0)
		i++;
	return i-1;
}

Функция “stepen(int ch, int st)”:

int stepen(int ch, int st)
{
	int a = 1;
	for(int i = 0; i < st; i++)
		a *= ch;
	return a;
}

Функция “len(char str[])” возвращает длину массива “str[]”, а “stepen(int ch, int st)” возводит число 2 в степень “st”.

Перевод из двоичной системы в десятичную

Теперь рассмотрим функцию “Bin2Dec (char m[])”, где “m[]”- это есть массив двоичных данных, в которых спрятано число. Если первый символ в массиве равен ‘1’, т.е. наше число отрицательное, то каждый символ в массиве до первой найденной ‘1’ инвертируем и после этого снова выполняет замену всех символов массива на ‘0’, если этот символ это ‘1’ или на ‘1’ соответственно. Затем непосредственно выполняем перевод в 10-й вид, используя нашу функцию возведения в степень. Код приведен ниже:

Функция “Bin2Dec (char m[])” – Перевод из двоичной системы в десятичную

int Bin2Dec (char m[])
{
	int i, deca=0, j = 0, q = 1;
	if (m[0] == '1')
	{
		for (i = n - 1; i >= 0; i--)
			if (m[i] == '0')
				m[i] = '1';
			else
			{
				m[i] = '0';
				break;
			}
		for (i = 0; i < n; i++)
			if (m[i] == '1')
				m[i] = '0';
			else
				m[i] = '1';
		q*=-1;
	}
	for (i = n - 1; i >= 0; i--, j++)
		if(m[i] == '1')
			deca += stepen(2,j);
	return deca*q;
}

Ну и, наконец, главная функция, с которой начинается работа нашего приложения. Здесь происходит ввод данных и вывод результата работы программы на экран пользователя.

Главный метод:

[/cpp]int main()
{
	wcout.imbue(locale("rus_rus.866"));
	int ch;
	char c[n];
	wcout << L"Введите число (десятичное):" << endl; //вывод сообщения на экран
	cin >> ch; //ввод значения с клавиатуры
	Dec2Bin(ch);
	/*------------------------------------------------------------------------*/
	wcout << L"\n\nВведите число (двоичное):" << endl; //вывод сообщения на экран
	cin>>c; //ввод значения с клавиатуры
	wcout << L"Десятичное представление :" << endl << Bin2Dec(c) << endl; //выводим на экран число в 10-й системе счисления
	system("pause");
	return 1;
}[cpp]

Используя данное приложение, вы с легкостью сможете переводить числа из десятичной системы счисления в двоичный вид и, наоборот, из двоичной системы счисления в десятичный вид. Желаю вам удачи!

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

Текст, который нужно будет кодировать, получим из текстового поля “text_input” и запишем в строковую переменную “str1”. Далее будем пробегать по каждому символу в этой строке, получать текущий символ в строковую переменную “ch”. В том случае, если данный символ равен следующему, продолжаем поиск количества таких символов, начиная текущей позиции в строке.

После всего этого формируем кодируемую строку равную количеству найденных символов и самому символу, которых повторяется друг за другом n-e количество раз. Если найден только один символ строка принимает значение равное этому символу.
Все выше описанные операции выполняются до тех пор, пока не будет достигнут конец файла.

string str1 = text_input.Text, str = "", ch = "";
int i, k, j;
for (i = 0; i < str1.Length; ) // от 0 до длины строки
{
ch = str1.Substring(i, 1); // получаем текущий символ из строки str1
k = 0; //счетчик количества повторяющихся символов
if (i == str1.Length - 1) // если последний символ
{
str += Convert.ToString(ch);
break; //выходим из цикла
}
if (str1.Substring(i + 1, 1) == ch)
{
for (j = i; j < str1.Length; j++)
{
if (str1.Substring(j, 1) == ch)//если текущий символ равен символу из строки ch
{
k++;//увеличиваем счетчик
}
else
break; //выходим из цикла
}
i = j;
}
else
i++;
if (k != 0)
str += Convert.ToString(k) + Convert.ToString(ch);
else
str += Convert.ToString(ch);

}
text_output.Text = str;
button2.Enabled = true;

Кодировку успешно выполнили, теперь напишем декодировку строки, кодированную при помощи алгоритма RLE. Декодирование закодированной строки выполняется путем поиска числа, которое является количеством повторений символа и самого символа.
И так, получаем закодированную строку из текстового поля “textBox1” и записывает полученный текст в переменную “str1”. При каждом проходе цикла, который выполняется, пока недостигнут последний символ, записываем в переменную “ch” текущий символ и если он является цифрой, выполняем поиск цифр идущих друг за другом. Тем самым последовательность найденных цифр будет представлять собой число, являющееся количеством повторений символа, идущего сразу же после этой последовательности. В конце в строковую переменную “str” записываем букву столько раз, сколько равно значение числа.

string str1 = textBox1.Text, str = "", ch = "", s = "", symb = "";
int i, k = 0, j;
for (i = 0; i < str1.Length; )
{
ch = str1.Substring(i, 1); // текущий символ i
k = 0;
s = "";
if ("0123456789".Contains(ch)) // если символ ch является цифрой
{
for (j = i; j < str1.Length; j++)
{
if ("0123456789".Contains(str1.Substring(j, 1))) // если текущий символ j является цифрой
{
s += str1.Substring(j, 1);
}
else
break;
}
symb = str1.Substring(j, 1); // получаем букву
i = j + 1;
}
else
i++;
if (s.Length != 0)
{
for (j = 0; j < Convert.ToInt32(s); j++) // декодирование буквы
str += symb;
}
else
str += Convert.ToString(ch);
}
out_shifr.Text = str;

В данной программе реализовано кодирование и декодирование строки, используя алгоритм сжатия данных RLE.

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

Напишем функцию “check_str”, которая будет возвращать “false” в случае если найден одинаковый участок в последовательности “s”.

Boolean check_str(string s)
{
string start, end;
for (int i = 1; i < = s.Length / 2; i++)
{
start = s.Substring(0, s.Length - i);
end = s.Substring(s.Length - i, i);
if (start.Length < end.Length)
return true;
if (start.Substring(start.Length - i, i) == end)
return false;
}
return true;
}

В функции выполняется проверка на все возможные смежные одинаковые участки. Разберем работу функции на примере последовательности 120120. Для выполнения всех проверок достаточно всего 3 прохода, при первом проходе сравниваются последние цифры 120120, если они равны, то одинаковый участок найден и выполняется завершение работы функции, в противном случае выполняется 2-й проход и уже сравниваются цифры 01 и 20. При следующем и последнем проходе сравниваются первые и последние 3 цифры 120 и 120, вот теперь они равны и производится выход из функции, возвращается значение “false”.
Теперь рассмотрим код процедуры “generate_Click”, которая вызывается при нажатии на кнопку “generate”.

private void generate_Click(object sender, EventArgs e)
{
int kol = Convert.ToInt32(kolvo.Text);
Random r = new Random();
generate_num.Clear();
int x;
string s = "";
for (int i = 1; i < = kol; i++)
{
for (; ; )
{
x = r.Next(0, 3);
if (i == 1)
{
s = Convert.ToString(x);

break;
}
if (check_str(s + Convert.ToString(x)))
{
s += Convert.ToString(x);
break;
}
else
{
if (!check_str(s + "0") && !check_str(s + "1") && !check_str(s + "2"))
{
generate_num.Text = s + " (Дальнейшая генерация числа невозможна)";
return;
}
}
}
}
generate_num.Text += s;
}

В этом процедуре происходит автоматическая генерация цифр от 0 до 2, добавление цифры к строке “s” (в случае положительного результата от функции “check_str”) и вывод сгенерированной последовательности на форму пользователя.
Бывают такие случаи, когда невозможна дальнейшая генерации последовательности, в этом случае выводится последовательность и текст “(Дальнейшая генерация числа невозможна)”.

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

Например, строку “aabb” при делении на 2 получаем две последовательности: “aa” и “bb”, затем “aa” сравниваем с “bb”. Если первая последовательность равна второй, то указываем, что последовательность “aa” встречается в тексте 2 раза, иначе 1 раз. В данном случае “aa” встречается 1 раз. В конце выполняем поиск из последовательностей символов, которые встречаются наиболее часто, и выбираем последовательность максимальной длины.
Запоминать последовательности и количество вхождений этих последовательностей будем в структуре, создадим ее:

public struct Symbols
{
string words;
int kolvo;

public Symbols(string w, int k)
{
words = w;
kolvo = k;
}
public string Words
{
get { return words; }
set { words = value; }
}
public int Kolvo
{
get { return kolvo; }
set { kolvo = value; }
}
};

Чтобы не добавлять в структуру одинаковые последовательности, напишем функцию, которая будет возвращать логическую “ложь” в том случае, если последовательность уже имеется в структуре:

Boolean Not_Eq_str(string c, Symbols[] sym, int k)
{
for (int i = 0; i < k; i++)
if (sym[i].Words == c)
return false;
return true;
}

Еще одна важная функция, которая будет искать в уже сформированной структуре из последовательностей и их вхождению в текст ту последовательность, которая чаще встречается и длиннее всех остальных последовательностей. Функция выводит каждую последовательность в текстовое поле “richTextBox1” и возвращает индекс найденной последовательности.

int search(Symbols[] sym, int k)
{
int max = 0, max_len = 0, index = 0;
for (int i = k - 1; i >= 0; i--)
{
richTextBox1.Text += sym[i].Words + " - " + sym[i].Kolvo + "\n";
if (max < sym[i].Kolvo && max_len <= sym[i].Words.Length)
{
max = sym[i].Kolvo;
max_len = sym[i].Words.Length;
index = i;
}
}
return index;
}

И, наконец, процедура обработки события нажатия на кнопку “button1”:

private void button1_Click(object sender, EventArgs e)
{

Открываем диалог для открытия текстового файла, очищаем поле “richTextBox1”, в строку “stroka” записываем текст из выбранного файла, получаем его длину и инициализируем структуру:

openFileDialog1.ShowDialog();
string p = openFileDialog1.FileName;
StreamReader inStream = new StreamReader(p);
patch.Text = p;
richTextBox1.Clear();
string s = "";
string stroka = "";

while ((s = inStream.ReadLine()) != null)
{
stroka += s;
}
int i, l = stroka.Length, n = 0;

Symbols[] sym = new Symbols[l];
int j, k = 0, x;
string subs = "";

Если текст состоит из одного символа, выводим этот символ, указываем, что он встречается в тексте один раз и прекращаем дальнейшее выполнение кода программы:

if (l == 1)
{
symbols.Text = stroka;
kolvosym.Text = "1";
return;
}

Добавляем в структуру весь текст и количество вхождений указываем равным 1:

sym[k].Words = stroka;
sym[k].Kolvo = 1;
k++;

Выполняем поиск других последовательностей, исключая возможность добавления в структуру одинаковых последовательностей:

for (i = 2; i < l; i++)
{
if (l % i == 0)
{
int c = l / i;
for (j = 0; j < i; j++)
{
subs = stroka.Substring(j * c, c);
x = 0;
for (int a = 0; a < i; a++)
{
if (stroka.Substring(a * c, c) == subs)
x++;
}
if (Not_Eq_str(subs, sym, k))
{

sym[k].Words = subs;
sym[k].Kolvo = x;
k++;
}
}
}
}
n = k;

Получаем индекс в структуре, где находится наиболее часто встречающуюся последовательность символов максимальной длины, выводим ее и количество вхождений ее в текст в поля на форму приложения:

int ind = search(sym, k);
symbols.Text = sym[ind].Words;
kolvosym.Text = Convert.ToString(sym[ind].Kolvo);
}

Это конечно не самый хороший алгоритм, который дает быстрое выполнение программы, но главное же, что он работает.

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

Начнем реализацию программы с создания формы.

Сразу можно создать событие выхода из программы, для этого два раза кликните по кнопке “Выход” и пропишите в процедуру следующий:

this.Dispose(); //Принудительно завершаем работу программы

Таким же образом создайте событие клика по кнопке “Найти”. Начинаем писать программный код для поиска чисел Пифагора.
Очистим поле результатов поиска и объявим нужные переменные.

lstFinds.Items.Clear(); //очищаем результаты поиска
int i1, i2, i3, a, b; //первое, второе и третье числа, диапазон поиска

Выполним проверку на заполнение полей диапазона.

if (txtDiapFirst.Text != "" && txtDiapSecond.Text != "") //если диапазон указан

Используя формулы для поиска всех трех чисел, находим числа Пифагора в заданном диапазоне от “a” до “b” и выводим рельтать на форму.

{
a = Convert.ToInt32(txtDiapFirst.Text); //диапазон от
b = Convert.ToInt32(txtDiapSecond.Text); //до
for (int i = a; i < = b; i++)
{
for (int j = i + 1; j <= b; j++)
{// применяем формулы для поиска чисел
i1 = j * j - i * i;
i2 = 2 * i * j;
i3 = j * j + i * i;
if (i1 >= a && i3 < = b) lstFinds.Items.Add(i1 + "^2 + " + i2 + "^2 = " + i3 + "^2");// Выводим результат поиска
}
}
}
else MessageBox.Show("Введите значения диапазона!", "Ошибка"); //Выдаем ошибку, если одно или все поля диапазона не заполнены

Если проверка не выполнилась, то выводим сообщение об ошибке без выхода из приложения для последующего исправления ошибки и поиска чисел Пифагора.

Результат выполнения программы

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

Сначала инициализируем структуру, делаем все границ всех процедур и функций:

struct STRUCTURA
{
char* PEREM1;
int PEREM2;
};

Здесь мы инициализировали структуру с именем “STRUCTURA” и двумя переменами (символьного типа и числового). Для работы со структурой нужно создать ее с заданием длины структуры и переменной, которая будет работать с ней:

STRUCTURA str[5];

Для ввода данных в структуру необходимо обращаться к нужному элементу структуры. Для этого создадим процедуру, в которой будет происходить заполнения структуры:

void input(STRUCTURA * str)
{
for (int i = 0; i < 5; i++)
{
cout << i+1 << "элемент структуры - PEREM1";
cin >> str[i]. PEREM1;
cout < < i+1 << "элемент структуры – PEREM2";
cin >> str[i]. PEREM2;
cout< }
}

str[i]. PEREM1; – означает обращение к переменной PEREM1 в i-м элементе структуры.
Чтобы вывести все значения поле структуры создадим соответствующую процедуру:

void out(STRUCTURA * str)
{
for(int i = 0; i < 5; i++)
{
cout<< i+1 << "элемент структуры - PEREM1" << str[i]. PEREM1;
cout<< i+1 << "элемент структуры – PEREM2" << str[i]. PEREM2;
}
}

Вызов этих процедур осуществляется с передачей параметра str, т.е. передается переменная, которая имеет доступ к структуре.

input(str);
out(str);

В этой статье я рассказал вам как осуществлять простейшие операции работы со структурой.

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

Вы никогда не задавали себе этот вопрос? Это очень интересный вопрос, ведь используя, стандартный калькулятор Windows вы получите укороченную версию этого числа. Даже написав функцию вычисления факториала просто нельзя поместить ни в одну числовую переменную все цифры факториала 100, т.к. оно состоит из 158 цифр. О каких цифрах идет речь и как их получить, мы поговорим в этой статей.

Начнем с того, нам нужно написать собственную функцию умножения, так как мы умножаем на простом листке бумаги. Она будет умножать числа вида [999] * [9], т.е. числа, которые содержать одну или несколько цифр на числа, содержащие одну цифру.

string mnog(string s, int i)
{
string res = "";
int x = 0, d, cifra = 0;
for (int j = s.Length - 1; j >= 0; j--)
{
cifra = Convert.ToInt32(s.Substring(j, 1)) * i + x;
if (j != 0)
{
d = cifra % 10;
x = cifra / 10;
}
else
d = cifra;
res = Convert.ToString(d) + res;
}
return res;
}

Входные параметры s и i – это числа, которые необходимо перемножить, соответствует выражению s * i. Алгоритм работы данной функции заключается в следующем:

1. Извлекаем j-ю цифру из строки s (в начале это последняя цифра), умножаем ее на i и прибавляем значение полученное в пункте №3;
2. Получаем остаток от деления вычисленного значения на число 10;
3. Получаем результат от целочисленного деления вычисленного значения на 10;
4. Добавляем вычисленное значение из пункта №2 к результату;
5. Повторяем пункты №1 – №4 пока не дойдем до первой цифры из строки s. Переходим к пункту №6;
6. Повторяем пункты №1 и №4, завершаем выполнение операции умножения.

Далее необходимо написать функцию для вычисления суммы двух чисел. Она также будет складывать числа, как делаем это мы.

string summ(string s_str1, string s_str2)
{
string summa = "";
int d = 0, cifra = 0, x = 0, sch;

for (int i = 0; i < = s_str1.Length - 1; i++)
{
if (i == s_str1.Length - 1)
{
if (s_str1.Length == s_str2.Length)
sch = 1;
else
sch = s_str2.Length - i;
d = Convert.ToInt32(s_str1.Substring(0, 1)) + Convert.ToInt32(s_str2.Substring(0, sch)) + x;
summa = Convert.ToString(d) + summa;
continue;
}
d = Convert.ToInt32(s_str1.Substring(s_str1.Length - i - 1, 1)) + Convert.ToInt32(s_str2.Substring(s_str2.Length - i - 1, 1)) + x;
cifra = d % 10;
x = d / 10;
summa = Convert.ToString(cifra) + summa;
}
return summa;
}

Входные параметры s_str1 и s_str2 – числа, которые нужно сложить. Алгоритм работы:

1. Вычисляем сумму i-й цифры из строки s_str1 (в начале это последняя цифра) и i-й цифры из строки s_str2, и прибавляем значение из пункта №3;
2. Получаем остаток от деления значения из пункта №1 на число 10;
3. Получаем результат от целочисленного деления значения из пункта №1 на 10;
4. Добавляем вычисленное значение из пункта №2 к результату;
5. Повторяем пункты №1 – №4 пока не дойдем до 1-й цифры из строки s_str1. Переходим к пункту №6;
6. Если количество цифр первого числа и второго совпадают, выполняем пункт №1, прибавляем его к результату. В противном случае суммируем первую цифру из строки s_str1 и значение из пункта №3, и прибавляем его к результату. Завершаем работу функции вычисления суммы.

Ну и наконец, мы дошли до процедуры, вызываемой событием клика на кнопку “sol”.

private void sol_Click(object sender, EventArgs e)
{
string s = "99", s_str1 = "", s_str2 = "", res = "";
for (int i = 98; i >= 2; i--)
{
if (i < 10)
{
s = mnog(s, i);
continue;
}
if (i % 10 != 0)
{
s_str1 = mnog(s, i % 10);
s_str2 = mnog(s, i / 10);
res = summ(s_str1, s_str2 + "0");
}
if (i % 10 == 0)
{
s_str2 = mnog(s, i / 10) + "0";
res = s_str2;
}
s = res;

}
chisla.Text = s + "00";
}

Здесь выполняется перемножение и суммирование чисел, начинающихся с 99 до 2, число 100 нет необходимости умножать, в конце всех вычислений просто прибавим “00”. В этой процедуре есть необходимые условия для нормальной работы функций вычисления умножения и суммы двух чисел. В поле “chisla” запишется результат выполнения программы, т.е. все цифры числа 100! как это показано рисунке:

Результат выполнения всех операций

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

• Найти числа, равные сумме факториалов своих цифр. Например, 1!+4!+5! = 145

Как эта задача решается? Мы устанавливаем диапазон чисел, среди которых будем искать такие числа, которые равны сумме факториалов своих цифр. Дальше находим факториал каждой цифры данного числа, суммируем суммы факториалов и проверяем на равенство: [сумма] = [число], где [сумма] – это, найденная сумма факториалов всех цифр данного числа, а [число] – данное число в диапазоне. Так вот, если равенство выполняется, то сохраняем это выражение в массив. Теперь реализуем этот алгоритм в программный код.

Для начала напишем рекурсивную функцию нахождения факториала числа. Факториал находится так: все числа от 1 до числа, факториал которого нужно найти, перемножаем.

Готовый код этой функции:

int fact(int f)
{
int fact = 1;
for (int i = 1; i < = f; i++)
fact *= i;
return fact;
}

Процедура для кнопки “Найти”:

private void button1_Click(object sender, EventArgs e)
{
int q = 0;
String str = "", sint = "";
listBox1.Items.Clear();
DateTime start = (DateTime.Now);
for (int dip = Convert.ToInt32(textBox1.Text); dip < = Convert.ToInt32(textBox2.Text); dip++)
{
q = 0;
sint = Convert.ToString(dip);
int[] mass = new int[sint.Length];
for (int i = 0; i < sint.Length; i++)
{
q += sint.Substring(i, 1) == "0" ? 1 : sint.Substring(i, 1) == "1" ? 1 :
sint.Substring(i, 1) == "2" ? 2 : fact(Convert.ToInt32(sint.Substring(i, 1)));
mass[i] = Convert.ToInt32(sint.Substring(i, 1));
}
if (q == dip)
{
str = "";
for (int i = 0; i < sint.Length; i++)
{
if (i < sint.Length - 1)
str = str + Convert.ToString(mass[i]) + "! + ";
else
str = str + Convert.ToString(mass[i]) + "! = ";
}
listBox1.Items.Add(str + sint);
}
}
DateTime end = (DateTime.Now);

listBox1.Items.Add(«Время выполнения: » + Convert.ToString(end – start));
}

По ходу работы программы выполняется на такие цифры как 0, 1 и 2, для них мы не выполняем поиск факториала, а просто приравниваем 1, 1 и 2 соответственно. Так как 0! = 1, 1! = 1, а 2! = 2, то мы не будем тратить процессорное время на запуск функции нахождения факториала, а приравняем соответствующие значения.
Код процедуры “Завершить работу”:

private void button3_Click(object sender, EventArgs e)
{
Application.Exit();
}

В этой процедуры, вызываемой нажатием на кнопку “Завершить работу”, мы вызываем событие выхода из программы.

На рисунке приведен результат выполнения программы. Диапазон использовался от 0 до 1 млн. В этом диапазоне, как видите, найдено всего 4 числа, которые необходимо найти по заданию.

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

Основное, что должны сделать – это найти общее количество чисел, которые нужно декодировать в систему счисления k и саму декодировку чисел. Количество чисел должно вычисляться по формуле: max = k в степени n – 1, где max – общее количество чисел. Декодировка должна быть универсальна, т.е. переводить десятичное число в любую систему счисления.

Создайте форму как показано на рисунке:

Форма программы

Поле напротив надписи “Введите число” переименуйте в “num_k”, следующее в “num_n”, а объект ListBox в “list_num”. Два раза кликните по кнопке “Получить числа” для создания процедуры вызова события клика по кнопке и скопируйте следующий код:

string num_res = ""; // число в k-й системе счисления
int n_k = Convert.ToInt32(num_k.Text);
int kolvo = Convert.ToInt32(num_n.Text);

int doo = Convert.ToInt32(Math.Pow(Convert.ToDouble(n_k), Convert.ToDouble(kolvo))) - 1;
groupBox_num.Text = "Все числа от 1 до " + doo + " в " + n_k + "-й системе счисления";
groupBox_num.Visible = true;
list_num.Items.Clear();

for (int i = 1; i < = doo; i++)
{
int count = 1;
if ((n_k == i && n_k != 2 && n_k != 16) || i / n_k < 0 || n_k == 1)
{
num_res = Convert.ToString(i);
}
else
{
int t = 0;
int ch = i;
num_res = "";
count = 1;
for (; ; )
{
string ad = "";
int delitel = ch / n_k;
double del = ch / n_k;
t = ch - delitel * n_k;
if (n_k == 16)
{
int b = ch % n_k;
if (b == 10)
ad = "A";
else if (b == 11)
ad = "B";
else if (b == 12)
ad = "C";
else if (b == 13)
ad = "D";
else if (b == 14)
ad = "E";
else if (b == 15)
ad = "F";
else
ad = Convert.ToString(t);

if( i >= 10 && i < = 15)
{
num_res += ad;
break;
}
}
else
ad = Convert.ToString(t);

if (del <= 0)
{
num_res += ad;
break;
}
else
num_res += ad;
ch = delitel;
count++;
}
}

char[] mass = new char[count];
mass = num_res.ToCharArray();
num_res = "";
for (int j = mass.Length - 1; j >= 0; j--)
num_res += mass[j];
list_num.Items.Add(Convert.ToString(i) + " = " + num_res);
}

Опишем этот код. Сначала вычисляем общее количество чисел, которые нужно декодировать в систему счисления k по формуле, приведенной выше, и приравниваем это значение переменной “doo”. Дальше идет вычисление числа “i” в системе счисления “k”.
Зачем необходимо использовать условие “if ((n_k == i && n_k != 2 && n_k != 16) || n_k == 1)”? Затем, чтобы не вычислять число “i” в системе счисления “k”, которое равно самой системе счисления и если система счисления равна 2 и 16 или не равна 1. Мы просто выводим значение числа “i”, т.е. не нужно переводить число “i” в систему счисления, если “i” – это система счисления.

Если условие не выполняется, то используем универсальный декодировщик для перевода числа “i” в систему счисления “k”. Внутри него встроен декодировщик числа в шестнадцатеричную систему счисления, т.к. в этой системе счисления числа 10, 11, 12, 13, 14, 15 равны “A”, “B”, “C”, “D”, “E”, “F” соответственно.

На заключительном этапе необходимо полученный результат перевода числа расположить в обратном порядке (произвести инверсию), чтобы наше число в системе счисления “k” приняло нужный формат для чтения человеку. Все, выводим результат в нашу форму.

Результат выполнения

Задача решена и реализована на языке C#, теперь вы можете использовать для перевода группы чисел в любую систему счисления.

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru

Реализовать программный код будем на C# в среде разработки Visual Studio 2008 как Windows приложение с формами.
Начинаем, конечно, с создания проекта с формой. На форме нужно разместить следующие объекты:

1. Надпись Label.
2. Текстовое поле Textbox, переименовать имя в “cout_oper”.
3. Кнопку Button, переименовать в “work”.
4. Два текстовых поля большой длины RichTextbox, переименовать в “ data_mas ” и “date_mas_ch” соответственно.

Пример показан на рисунке:

Форма приложения

Программа не большая и довольно проста. Рассмотрим процедуру “work_Click(), которая вызывается всякий раз, когда происходит событие клика по кнопке “work”:

private void work_Click(object sender, EventArgs e)
{
data_mas.Clear();
date_mas_ch.Clear();
Random r = new Random();
int c_m = r.Next(10, 30), count = 0;
int[] mass = new int[c_m];
for (int i = 0; i < c_m; i++)
{
mass[i] = r.Next(0, 3);
data_mas.Text = data_mas.Text + " " + mass[i];
}
for (int i = 0; i < c_m; i++)
{
int k = i, x = mass[i];
for (int j = i + 1; j < c_m; j++)
if (mass[j] < x)
{
k = j;
x = mass[j];
count++;
}
mass[k] = mass[i];
mass[i] = x;
}
for (int i = 0; i < c_m; i++)
date_mas_ch.Text = date_mas_ch.Text + " " + mass[i];
cout_oper.Text = Convert.ToString(count);
}

В этой процедуре сначала происходит очистка текстовых полей большой длины, чтобы при следующем запуске процедуры поля заполнялись только новыми данными. Дальше генерируем длину массива от 10 до 30 и создаем его. В первом цикле for происходит заполнение массива числа 0, 1 или 2 также случайно и вывод его в форму.

Затем мы используем сортировку, переставляя два элемента, если это необходимо. Самый последний цикл for выводит отсортированный в порядке возрастания массив в поле “date_mas_ch”, а в поле “cout_oper” записывается число равное количеству операций, которых нам понадобилось выполнить, чтобы отсортировать массив.

Пример выполнения

Автор: Евтеев Евгений Александрович
Email: evteev_e2003@mail.ru