public class Triangle
    {

        public bool IsInside(int npol, float[] xp, float[] yp, float x, float y)
        {

            int c = 0;
            for (int i = 0, j = npol - 1; i < npol; j = i++)
            {
                if ((((yp[i] <= y) && (y < yp[j])) || ((yp[j] <= y) && (y < yp[i]))) &&
                  (x > (xp[j] - xp[i]) * (y - yp[i]) / (yp[j] - yp[i]) + xp[i]))
                    c = 1 - c;
            }
          return  c == 1 // точка внутри
            }

   
            private static void Main()
            {


                float[] xp = { 0, 2, 4 }; // масcив  х вершин
                float[] yp = { 0, 2, 2 }; // массив  у вершин
                float x = 2;
                float y = 1;
                int npol = xp.Length;

                Triangle t = new Triangle();
                bool result = t.IsInside(npol, xp, yp, x, y);

                Console.WriteLine(result ? "Внутри" : "Снаружи");
                Console.ReadKey();
            }

    }
   

namespace CyberForum {
    public struct Point {
        private float _x;
        private float _y;

        public Point(float x, float y) {
            _x = x;
            _y = y;
        }

        public float X {
            get { return _x; }
            set { _x = value; }
        }

        public float Y {
            get { return _y; }
            set { _y = value; }
        }
    }

    public class Triangle {
        private Point _a;
        private Point _b;
        private Point _c;

        public Triangle(Point a, Point b, Point c) {
            _a = a;
            _b = b;
            _c = c;
        }

        public bool IsInside(Point p) {
            // тут твой код. без глобальных переменных: всё на стеке
            return true;
        }

   

        public Point A {
            get { return _a; }
        }

        public Point B {
            get { return _b; }
        }

        public Point C {
            get { return _c; }
        }

    }

    public static class Program {

        private static void Main() {
            Point p1 = new Point(0, 0);
            Point p2 = new Point(0, 10);
            Point p3 = new Point(10, 0);
            Point p4 = new Point(1, 1);

            Triangle t = new Triangle(p1, p2, p3);

            Console.WriteLine(t.IsInside(p4) ? "Внутри" : "Снаружи");
            Console.ReadKey();
        }

    }
}

namespace NewTriangle
{
   

    public class Triangle
    {
        private float [] _a;  // вот здесь я так понимаю мы создаем закрытие переменные
        private  float [] _b;

/ /здесь назначаем закрытым переменным значение аргументов которые принимает новый класс
        public Triangle(float[] X, float[] Y)
        {
            _a = X;   
            _b = Y;
           
        }

        public bool IsInside(PointF p)
        {
            int npol = 3;
            int c = 0;
            for (int i = 0, j = npol - 1; i < npol; j = i++)
            {
                if ((((Y[i] <= p.Y) && (p.Y < Y[j])) || ((Y[j] <= p.Y) && (p.Y < Y[i]))) &&
              (p.X > (Y[j] - X[i]) * (p.Y - Y[i]) / (Y[j] - Y[i]) + X[i]))
                    c = 1 - c;
            }
            return c == 1;  // точка внутри
        }

       
// вот здесь не совсем понимаю что мы делаем - но без этого код вообще не работает
        public float [] X
        {
            get { return _a; }
        }

        public float [] Y
        {
            get { return _b; }
        }

       

    }

    public static class Program
    {

        private static void Main()
        {
           
            PointF p4 = new PointF(2, 1);

            float[] xp = { 0, 0, 3, 3 }; // масив  х вершин
            float[] yp = { 0, 3, 3, 0 }; // массив  у вершин
            Triangle t = new Triangle(xp, yp);
           

            Console.WriteLine(t.IsInside(p4) ? "Внутри" : "Снаружи");
            Console.ReadKey();
        }

    }
}

class Triangle
{
    private PointF[] _vertexes;

    public PointF[] Vertices
    {
        get
        {
            return _vertexes;
        }
    }

    public Triangle(PointF[] vertexes)
    {
        _vertexes = vertexes;
    }

    public bool IsInside(PointF p)
    {
        int c = 0;
        int count = _vertexes.Count;

        for (int i = 0, j = count-1; i < count; j = i++)
            {
                if ((((_vertexes[i].Y <= p.Y) &&
                    (p.Y < _vertexes[j].Y)) ||
                    ((_vertexes[j].Y <= p.Y) &&
                    (p.Y < _vertexes[i].Y))) &&
                    (p.X > (_vertexes[j].Y - _vertexes[i].X) *
                    (p.Y - _vertexes[i].Y) /
                    (_vertexes[j].Y - _vertexes[i].Y) + _vertexes[j].X))
                c = 1 - c;
            }
            return c == 1;
       
       
    }
}

namespace MyLinq
{
    struct Simbol
    {
        // поля структуры
        private string str;
        private int count;
        private IEnumerable<char> simbols;
       

        // конструктор с параметрами
        public Simbol(string s)
        {
            str = s;
            count = 0;
            simbols = null;
             
        }

       
        // методы структуры

        // возвращаем  те элементы последовательности которые встречаются в ней только один раз
        public IEnumerable<char> SingleElements()
        {
            simbols =
            from s in str.ToCharArray()
            where (s != ' ')
            group s by s into группа
            where (группа.Count() == 1)
            select группа.First();
            return simbols;
        }

         // универсальный метод - принимает число и ищет элементы которые встречаются указанное число раз
        public IEnumerable<char> Elements(int number)
        {
            simbols =
            from s in str.ToCharArray()
            where (s != ' ')
            group s by s into группа
            where (группа.Count() == number)
            select группа.First();
            return simbols;
        }


   

        // возвращает кол-во встреченных в последовательности указанных символов
        public int CountChar(char ch)
        {
            simbols =
             from s in str.ToCharArray()
             where (s == ch)
             select s;
             return simbols.Count();

        }


     // получаем все различающиеся элементы последовательности без учета пробелов
        public IEnumerable<char> DifferentElements()
        {
            simbols = str.Distinct().Where(c => c != ' ').Select(t => t);
            return simbols;
        }

          // получаем общее кол-во символов без учета пробелов
        public int CountAllElements()
        {
            count = str.ToCharArray().Where(c => c != ' ').Count();
            return count;
        }

     
  }



    public static class Program
    {

        public static void Main()
    {

        Console.WriteLine("Введите строку: ");
        string s = Console.ReadLine(); 

        Simbol str = new Simbol(s);
        var single =  str.SingleElements();
        var different= str.DifferentElements();
        // общее число символов
        int countall = str.CountAllElements();
       // элементы которые встречаются указанное число раз
        var sim = str.Elements(2);
       // кол-во элементов которое встречается указанное число раз
        int v = str.Elements(2).Count();
       // кол-во различающихся элементов
        int countdif = str.DifferentElements().Count();
       // кол-во элементов встречающихся только один раз
        int countsingle = str.SingleElements().Count();
        // кол-во указанных элементов в последовательности
        int coll = str.CountChar('a');
     
        Console.WriteLine("Одиночные элементы:");
        foreach (var ch in single)
        {
            Console.WriteLine(ch);
        }

        Console.WriteLine("Все  различные элементы:");
        foreach (var ch in different)
        {
            Console.WriteLine(ch);
        }

        Console.WriteLine("Элементы встречающиеся заданное число раз:");
        foreach (var ch in sim)
        {
            Console.WriteLine(ch);
        }

       
        Console.WriteLine("Количество одиночных элeментов: {0}", countsingle);
        Console.WriteLine("Количество различающихся элeментов: {0}", countdif);
        Console.WriteLine("Количество указанных элeментов: {0}", coll);
       Console.WriteLine("Количество элeментов в указанном кол-ве: {0}", v);
        Console.WriteLine("Общее число элeментов: {0}", countall);
       
        Console.ReadKey();
   
        }
    }
}