C#   Уроки программирования с нуля. Си-шарп для чайников   C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Structure
{
    class Program
    {
        static void Main(string[] args)
        {
            List<float> radiuses = new List<float>();
            Random rand = new Random();
            int count = rand.Next(0, 10);
            for(int i = 0; i < count; i++)
            {
                radiuses.Add(rand.Next(1, 100));
            }
            List<Circle> circles = new List<Circle>();
            for(int i = 0; i < radiuses.Count; i++)
            {
                circles.Add(new Circle() { raduis = radiuses[i] });
            }

            Console.WriteLine(Averege(circles).raduis);        
            Console.ReadLine();
        }

        public struct Circle
        {
            public float raduis;
        }


        public static Circle Averege(List<Circle> crk)
        {
            double aver = 0;
            foreach(Circle circ in crk)
            {
                aver += circ.raduis;
            }
            aver /= crk.Count;
            double closeToAverege = Math.Abs(crk[0].raduis - aver);
            int position = 0;
            for (int i = 0; i < crk.Count; i++)
            {
                if (Math.Abs(crk[i].raduis - aver) < closeToAverege)
                {
                    closeToAverege = crk[i].raduis;
                    position = i;
                }
            }
            return crk[position];

        }
    }
}

 
namespace ConsoleApp17
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Circle> CircleList = new List<Circle> { };
            Random rand = new Random();
            for(int i=0; i < 10; i++)
            { CircleList.Add(new Circle(rand.Next(1, 50))); }
            int sumrad = 0,avg;
            foreach (Circle b in CircleList)
            { sumrad += b.Radius; }
            avg = sumrad / (CircleList.Count());
            int Max=50, Min=1, MAxDif=0, MInDif=0;
            int ind=0,indMax = 0,indMin=0;
            foreach (Circle b in CircleList)
            {
                if (avg <= b.Radius && b.Radius<=Max)
                {
                    indMax = ind;
                    Max = b.Radius;
                    MAxDif = b.Radius-avg;
                }
                else if (avg > b.Radius && Min<b.Radius )
                {
                    Min = b.Radius;
                    MInDif = avg - b.Radius;
                    indMin = ind; }
                ind++;

            }
            if (MAxDif > MInDif) Console.WriteLine("IndexMin: {0},{1}", indMin + 1, CircleList[indMin].Radius);
            else Console.WriteLine("IndexMax: {0},{1}",indMax+1,CircleList[indMax].Radius);
            Console.WriteLine("avg: {0}",avg);
        
        Console.WriteLine("____________________");
            foreach (Circle b in CircleList) { Console.WriteLine(b.Radius); }
                Console.ReadLine();

        }
    }
    public struct Circle {
        private int radius;
        public int Radius { get { return radius; }set { radius = value; } }
        public Circle(int a)
        {
            radius = a;
        }
    }
}

 class Program
    {
        static void Main(string[] args)
        {

            double[] radius = new double[] { 2.3, 2.1, 2,7, 2.9, 1.8 };
            var nearestBYlinq = radius.OrderBy(x => Math.Abs((double)x - (from ord in radius select ord).Average())).First();
          

            Console.WriteLine("The nearest member of the array found by LINQ to the average array is " + nearestBYlinq);
          
        }
     }

//Создаём структуру
        public struct RadiusFinder
        {
            // Метод внутри структуры и принадлежит структуре(static)
            public static void toFindRadius(int[] arrayRadius)
            {
                // Перебираем массив длинн радиусов и вычисляем среднюю длинну радиуса
                int average = 0;
                foreach (int element in arrayRadius)
                {
                    average += element;
                }
                average = average / arrayRadius.Length; // Получаем среднюю длинну радиуса
               
                // Создаём переменную - индекс близости к среднему радиусу. 
                int closeToAverage = (Math.Abs(arrayRadius[0] - average)); // Записываем в переменную индекс близости первого элемента массива 

                // Перебираем массив радиусов. Радиус более близкий к середине(наименьший индекс близости) заносится в переменну position
                int position = 0;// 
                int count = 0; // 
                for (int i = 0; i < arrayRadius.Length; i++)
                {
                    if (closeToAverage > Math.Abs(arrayRadius[i] - average))
                    {
                        closeToAverage = Math.Abs(arrayRadius[i] - average);
                        position = count;
                    }
                    count++;
                }
                // выводим сообщение о среднем радиусе и наиболее близком рабиусе к среднему
                Console.WriteLine("Наиболее близкий радиус {0} к среднему радиусу {1}", arrayRadius[position], average);
            }
        }
        static void Main(string[] args)
        {
           
            int[] radius = {1, 30, 40, 17, 100, 5, 60, 200 };

            RadiusFinder.toFindRadius(radius);



        }

    public struct Circle
    {
        public void Circumference(double[] radius)
        {
            //Getting the nearest member of the array - begin
            double nearest = 0;
            double mindif = radius.Max();
            double avrRad = radius.Average();

            foreach (var element in radius)
            {
                if (Math.Abs(avrRad - element) < mindif)
                {
                    mindif = Math.Abs(avrRad - element);
                    nearest = element;
                }
            }
            Console.WriteLine("The nearest member of the array to the average array is " + nearest);
            //Getting the nearest member of the array - end
            //-------------------------------
            //The circumferencing calculation
            double circumference = nearest * 2 * Math.PI;
            Console.WriteLine("The circumference (C=2*R*Pi) is " + circumference);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            double[] radius = new double[5];
            radius[0] = 2.3;
            radius[1] = 2.1;
            radius[2] = 2.7;
            radius[3] = 2.9;
            radius[4] = 1.8;

            Circle circle = new Circle();
            circle.Circumference(radius);

            Console.ReadKey();
        }
    }

        private struct cyrcleStructure {

            public int rad { get; set; }

            public cyrcleStructure(int radC) {
                rad = radC;
            }

            public static void doIt() {
                while (true) {

                    #region Инициализация
                    List<cyrcleStructure> cList = new List<cyrcleStructure>();
                    Random rnd = new Random();

                    for (int i = 0; i < 10; i++) {
                        cList.Add(new cyrcleStructure(rnd.Next(1, 100)));
                    }
                    #endregion

                    #region Вычисление среднего радиуса всех окружностей
                    int middleCyrcle = 0;

                    foreach (var item in cList) {
                        middleCyrcle += item.rad;
                        Console.Write(item.rad + " ");
                    }
                    middleCyrcle = Convert.ToInt32((double)middleCyrcle / cList.Count);
                    Console.WriteLine("\nСредний радиус окружностей: " + middleCyrcle);
                    #endregion

                    #region Вычисление ближайших к среднему радиусу радиусов
                    List<int> closestRadList = new List<int>();

                    int tempDiff = Math.Abs(middleCyrcle - cList[0].rad);
                    int currDiff = Math.Abs(middleCyrcle - cList[0].rad);

                    foreach (var item in cList) {
                        currDiff = Math.Abs(middleCyrcle - item.rad);
                        if (tempDiff > currDiff) {
                            tempDiff = currDiff;
                        }
                    }
                    foreach (var item in cList) {
                        if (tempDiff == Math.Abs(middleCyrcle - item.rad) && !closestRadList.Contains(item.rad)) {
                            closestRadList.Add(item.rad);
                        }
                    }

                    if (closestRadList.Count == 1)
                        Console.WriteLine("Ближайший к среднему радиус: " + closestRadList[0]);
                    else {
                        Console.Write("Ближайшие к среднему радиусы: ");
                        foreach (var item in closestRadList) {
                            Console.Write(item + " ");
                        }
                        Console.WriteLine();
                    }
                    #endregion

                    Console.WriteLine("Выйти?");
                    if ("y".Equals(Console.ReadLine()))
                        break;
                }
            }

/*
 * Сделано в SharpDevelop.
 * Пользователь: Kolsky
 * Дата: 61.02.1071
 * Время: Свободное
 */
using System;

namespace q
{
	struct Circle//Площадь круга ср. радиуса
	{
		public double area;
		public void CirAreaOfMidR(double[] RadS)//Аргумент - радиусы
		{
			double midR=0;
			int	i;
			for (i = 0; i < RadS.Length; i++) midR+=RadS[i];
			midR/=i;
			area = midR * Math.PI;
		}
	}
	class Program
	{
		public static void Main(string[] args)
		{
			Circle C1;
			C1.area=0;
			double[] RadS = {1.12,1.16,4,7.8};
			C1.CirAreaOfMidR(RadS);
			Console.Write(C1.area);
			Console.ReadKey(true);
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication4
{
    struct okr
    {
        
        public int radiys;
        public int suma1;
        public okr(int radiys, int suma1)
        {
           
            this.radiys = radiys;
            this.suma1 = suma1;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            okr okr1;
            List<int> radiysu = new List<int>();
            Random ran = new Random();
            // Робим цикил для рандомного заповнення списку radiysu 5-ма елементами.
            int suma = 0;
            Console.Write("Радiуси наших кiл =");
            for (int i = 0; i < 5; i++)
            {

                int rand = ran.Next(0, 30);
                radiysu.Add(rand);
                Console.Write(radiysu[i] + "  ");

            }
            
            Console.WriteLine("  ");
            for (int i = 0; i < radiysu.Count; i++)
            {
                suma = suma + radiysu[i];

            }
            okr1.suma1 = suma / radiysu.Count;
            Console.WriteLine("Середнє значення = " + okr1.suma1);
            okr1.radiys=0;
            int min=0;
            for (int i = 0; i < radiysu.Count; i++)
            {
                if (min==0)
                min = Math.Abs(okr1.suma1 - radiysu[i]);
                if ( Math.Abs(okr1.suma1 - radiysu[i])<min)
                {
                    min=Math.Abs(okr1.suma1 - radiysu[i]);
                    
                  okr1.radiys = radiysu[i];
                }
              
            }
            Console.WriteLine("Найбільш наближене значення до "+okr1.suma1+" = "+okr1.radiys);
        }
    }
}

class Program
	{
		public static void Main(string[] args)
		{
			Circle a = new Circle(10);
			Circle b = new Circle(15);
			Circle c = new Circle(30);
			Circle d = new Circle(30);			
			Circle closest = new Circle(0);
			
			
			var list = new List<Circle>();
			list.Add(a);
			list.Add(b);
			list.Add(c);
			list.Add(d);
			
			double approxR = 0; // Общее кратное
			
			foreach (var element in list) {
				approxR += element.Radius;
			}
			approxR = approxR / list.Count;
			
			double diff = 0; //разница между Средним значением и опр. радиусом
			
			foreach (var item in list) {
				if (diff == 0) {
					diff = Math.Abs(approxR - item.Radius);
				}
				if(Math.Abs(approxR - item.Radius) < diff)
				{
					diff = Math.Abs(approxR - item.Radius);
					closest.Radius = item.Radius;
				}				
			}
			Console.WriteLine("The closest Radius is: {0}", closest.Radius.ToString());
			Console.ReadLine();
			

		}
	}
	struct Circle
	{
		public double Radius;		
		public Circle(double radius)
		{
			this.Radius = Math.Abs(radius);
		}
	}

private struct Circle
        {
            internal double radius;
        }
        static void Main(string[] args)
        {
            Console.WriteLine("Enter a quantity of circles:");
            int q = Convert.ToInt32(Console.ReadLine());
            if (q <= 1)
                do
                {
                    Console.WriteLine("You must enter a quantity above 1.");
                    q = Convert.ToInt32(Console.ReadLine());
                }
                while (q <= 1);
            Circle[] c = new Circle[q];
            double[] radiuses = new double[q];
            for (int i = 0; i < q; i++)
            {
                Console.WriteLine("Enter a radius value of circle # " + (i + 1) + ':');
                radiuses[i] = Convert.ToDouble(Console.ReadLine());
            }
            for (int i = 0; i < radiuses.Length; i++)
                c[i].radius = radiuses[i];
            double m = 0, n;
            near(c, ref  m, out  n);
            Console.WriteLine("Average radius is: {0}.\nThe nearest is: {1}.", m, n);
            Console.ReadKey();
        }
        static void near(Circle[] circles, ref double m, out double n)
        {
            double sum = 0;
            for (int i = 0; i < circles.Length; i++)
                sum = sum + circles[i].radius;
            double average = sum / circles.Length;
            double min = Math.Abs(circles[0].radius - average); int b = 0;
            for (int i = 0; i < circles.Length; i++)
                if (Math.Abs(circles[i].radius - average) < min)
                {
                    min = Math.Abs(circles[i].radius - average);
                    b = i;
                }
            m = average; n = circles[b].radius;
        }
    }

array.Average();

AvgRadius = K.Average(k => k.Radius);

namespace ConsoleApplication1
{
    class Program
    {
        public struct Circle
        {
            public int Number;
            public double Radius;
            public double? Length;

            public Circle(int number, double radius, double? length)
            {
                Number = number;
                Radius = radius;
                Length = length;
            }
        }

        public static void Main()
        {
            int n;
            double SumOfRadiuses = 0, AvgRadius, middle, MidRadius;
            Console.WriteLine("Введите количество кругов");
            n = Convert.ToInt32(Console.ReadLine());

            Random Rnd = new Random();
            List<Circle> K = new List<Circle>();
            
            for (int i=0; i<n; i++ )
            {
                K.Add(new Circle(i, Rnd.Next(1, 1000), null));
            }

            Console.WriteLine();
            foreach (Circle Kolo in K)
            {
                Console.WriteLine(Kolo.Radius);
                SumOfRadiuses += Kolo.Radius;
            }
            AvgRadius = SumOfRadiuses / K.Count; //AvgRadius = K.Average() - не работало;

            middle = 1000;
            MidRadius = 0;
            foreach (Circle Kolo in K)
            {
                if ((Math.Abs(AvgRadius - Kolo.Radius)) < middle)
                {
                    middle = Math.Abs(AvgRadius - Kolo.Radius);
                    MidRadius = Kolo.Radius;
                }
            }

            Console.WriteLine();
            Console.WriteLine("Средний радиус: " + AvgRadius + "\nНаиболее близкий к нему радиус: " + MidRadius);
            Console.ReadLine();
        }
     } 
}

public struct Krug
    {
        public int Rad;
        public Krug(int rad)
        {
            Rad = rad;                      
        }
    }        
    class Program
    {
        static void Main(string[] args)
        {
            Random rnd = new Random();
            int[] radius = new int[5];
            List<Krug> rings = new List<Krug>();
            Krug k;
            for (int i = 0; i < radius.Length; i++)
            {
                k.Rad = rnd.Next(100);
                radius [i] = k.Rad;
                rings.Add(k);
            }
            Console.WriteLine("Созданы окружности радиусом: \n");
            double mid = radius.Average();
            int middle = radius [0];
            foreach (Krug radiuss in rings)
            {
                Console.WriteLine(radiuss.Rad + " мм. \n");
                middle = Math.Abs(radiuss.Rad - mid) < Math.Abs(middle - mid) ? radiuss.Rad : middle; 
            }
            Console.WriteLine("Средне арифметический радиус = " + mid + " мм. \n");
            Console.WriteLine("Наиболее близкая к средне арифметическому окружность  с радиусом " + middle + " мм.");
            Console.ReadKey();
        }
    }

namespace ConsoleApplication1
{
    public struct Krug
    {
        public int Rad;
        public Krug(int rad)
        {
            Rad = rad;
        }
    }        
    class Program
    {
        static void Main(string[] args)
        {
            Random rnd = new Random();
            int[] radius = new int[5];
            List<Krug> rings = new List<Krug>();
            for (int i = 0; i < radius.Length; i++)
            {
                rings.Add(new Krug(radius[i]=rnd.Next(100)));
            }
            Console.WriteLine("Созданы окружности радиусом: \n");
            double mid = radius.Average();
            int middle = 0;
            foreach (Krug radiuss in rings)
            {
                Console.WriteLine(radiuss.Rad + " мм. \n");
                middle = Math.Abs(radiuss.Rad - mid) < Math.Abs(middle - mid) ? radiuss.Rad : middle; 
            }
            Console.WriteLine("Средне арифметический радиус = " + mid + " мм. \n");
            Console.WriteLine("Наиболее близкая к средне арифметическому окружность  с радиусом "+ middle + " мм.");
            Console.ReadKey();
        }
    }
}

public struct Circle
    {
        public int radius;
        public Circle(int radius)
        {
            this.radius = radius;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Circle circle1;
            circle1.radius = 10;
            Circle circle2;
            circle2.radius = 15;
            Console.WriteLine(circle1.radius);
            Console.WriteLine(circle2.radius);
            Console.ReadKey();
        }
    }

 static void Main(string[] args)
        {
            int p;
            Console.WriteLine(p); // ошибка Use of unassigned local variable 'p
        }

truct Circle
        {
            private double r;
            public double Rad
            {
                get { return r; }
                set { r = value; }
            }
        static void Main(string[] args)
        {
            Circle c;
            c.Rad = 10;//error
        }

namespace @struct
{
    struct Round
    {
        public double Radius;
        public Round(double r)
        {
            this.Radius = r;
        }
        //Circumference() and Square() are not being in this example
        public double Circumference() 
        {
            return 2 * Math.PI * Radius;
        }
        public double Square()
        {
            return Math.PI * Radius * Radius;
        }
        
    }
    class Program
    {
        static void Main(string[] args)
        {
            Random rng = new Random();
            double sum = 0, avrg, min=double.MaxValue;
            List<Round> Circles = new List<Round>();
            Console.WriteLine("Значення радiусiв в списку: ");
            for (int i = 0; i < 10; i++)
            {
                Circles.Add(new Round(rng.Next(1,100)));
                Console.WriteLine(Circles[i].Radius);
                sum += Circles[i].Radius;
            }
           
            avrg=sum/Circles.Count;
            Console.WriteLine("Середнє значення з масиву: "+avrg);
            foreach (Round r in Circles)
            {
            min = (Math.Abs(r.Radius - avrg) < Math.Abs(min-avrg)) ? r.Radius : min;
            }
            Console.WriteLine("Найближчим до середнього значення радiусу в масивi є коло з радiусом " + min);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication10
{
    struct Circle
    {
        private uint Radius;

        public Circle (uint Radiuss)
        {
            this.Radius = Radiuss;
        }

        public uint CircleRadius()
        {
            return this.Radius;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            List<uint> Radiuses = new List<uint>();
            for (int i = 0; i < 5; i++)
            {
                Circle NewCircle = new Circle(Convert.ToUInt16(Console.ReadLine()));
                Radiuses.Add(NewCircle.CircleRadius());
            }
            double middle = 0;
            foreach (uint a in Radiuses)
            {
                middle += a;
            }
            middle = middle / Radiuses.Count;
            uint near = 0;
            foreach(uint el in Radiuses)
            {
                if (Math.Pow((middle - el),2) < Math.Pow((middle - near),2))
                    near = el;

            }
            Console.WriteLine("Nearest to the middle is element with radius " + near);
            Console.ReadKey();
        }
        
    }
}