using System;

public class Program

{

    // הפעולה מקבלת מערך מספרים שלמים ומחזירה רשימה של איברי המערך באותו סדר 

    // הנחה: המערך לא ריק!!! הוא מכיל לפחות איבר אחד

    public static Node<int> BuildListFromArForword (int[] ar)

    {

        Node<int> lst = new Node<int>(ar[0]);

        Node<int> pos = lst;

        for (int i=1;i<ar.Length;i++)

        {

            pos.SetNext(new Node<int>(ar[i]));

            pos=pos.GetNext();

       }

       return lst;

     }

    // הפעולה מקבלת מערך של נקודות ומחזירה רשימה של איברי המערך באותו סדר 

    // הנחה: המערך לא ריק!!! הוא מכיל לפחות איבר אחד

    public static Node<Point> BuildListFromPointsArForword (Point[] ar)

    {

        Node<Point> lst = new Node<Point>(ar[0]);

        Node<Point> pos = lst;

        for (int i=1;i<ar.Length;i++)

        {

            pos.SetNext(new Node<Point>(ar[i]));

            pos=pos.GetNext();

       }

       return lst;

     }

    // הצגת שרשרת חוליות של מספרים שלמים

    public static void Show (Node<int> lst)

   {

    Console.Write("[");

    Node<int> pos = lst;

​

    while (pos != null)

    {

        Console.Write(pos.ToString());

        if (pos.HasNext())

            Console.Write(",");

        pos = pos.GetNext();

    }

    Console.WriteLine("]");

 }

    // הצגת שרשרת חוליות של נקודות

    public static void ShowPoints (Node<Point> lst)

   {

    Console.Write("[");

    Node<Point> pos = lst;

​

    while (pos != null)

    {

        Console.Write(pos.GetValue().ToString());

        if (pos.HasNext())

            Console.Write(",");

        pos = pos.GetNext();

    }

    Console.WriteLine("]");

 }

    public static void Main ()

    {

        Console.WriteLine("Hello World");

        Point p1 = new Point (1,1);

        Point p2 = new Point (2,2);

        Point p3 = new Point (3,3);

        Point[] ar = {p1,p2,p3};

        ShowPoints(BuildListFromPointsArForword(ar));

    }

}

​

// המחלקה מצולע

public class Polygon

{

    /*

    הערה: נניח שהנקודות אכן נסגרות לפוליגון, ואין קודקודים באמצע צלעות

    בנוסף, בין כל שתי נקודות יש צלע, כך גם בין הראשונה לאחרונה

    כלומר, לא מדובר ברשימה מעגלית, אבל קודקודי הרשימה מסודרים

    ״מעגלית״

    */

    private Node<Point> ls;   // רשימה של נקודות

    // פעולה בונה פוליגון ריק - פוליגון ללא קודקודים

    public Polygon ()

    {

        this.ls = null;

    }

​

    // פעולה בונה המקבלת נקודה ובונה פוליגון שהנקודה היא הנקודה הראשונה שלו 

    public Polygon (Point p)

    {

        Point p1 = new Point(p);   // יצרתי תחילה נקודה חדשה באמצעות הפעולה הבונה המעתיקה נקודה כמו זו של הפרמטר שהועבר

        this.ls = new Node<Point>(p1);

    }

    // פעולה בונה מעתיקה המקבלת פוליגון ובונה פוליגון חדש בעל קודקודים עם ערכים זהים

    public Polygon (Polygon other)

    {

        //this.ls = other.ls;               // האם רק זה מספיק או ממש להעתיק הכל הכל הכל?????

        this.ls = new Node<Point>(new Point(0,0));   // חוליית דמה

        Node<Point> pLs = this.ls;

        Node<Point> pOther = other.ls;   // רשימת הנקודות של הפוליגון האחר

        int i=0;

        while (pOther != null)

        {

            Point p1 = new Point(pOther.GetValue());

            pLs.SetNext(new Node<Point>(p1));

            pLs = pLs.GetNext();

            pOther = pOther.GetNext();

            i++;

        }

        this.ls = this.ls.GetNext();

    }

    // פעולה שמקבלת נקודה ומחזירה אמת אם היא קיימת ברשימה, ושקר אחרת

    private bool IsExist (Point p)

    {

        //if (this.ls == null) return false;   מיותר

        Node<Point> pos = this.ls;

        while (pos != null)

        {

            if (pos.GetValue().Equals(p))

                 return true;

            pos = pos.GetNext();

        }

        return false;   

    }

    // הפעולה מקבלת נקודה ומוסיפה אותה לסוף רשימת הקודקודים, אם לא קיימת נקודה זהה בערכיה ברשימה

    public void AddPointL (Point p)

    {

        Point p1 = new Point(p);

        if (this.ls == null)

        {

            this.ls = new Node<Point>(p1);

            return;

        }

​

        Node<Point> pos = this.ls;

        while (pos.HasNext() && !pos.GetValue().Equals(p1))

            pos = pos.GetNext();

        if (pos.HasNext()==false)   // pos.GetNext()==null

        {

           if (!pos.GetValue().Equals(p1))

               pos.SetNext(new Node<Point>(p1));

        }

    }

    // הפעולה מקבלת נקודה ומוסיפה אותה לתחילת רשימת הקודקודים, אם לא קיימת נקודה זהה בערכיה ברשימה

    public void AddPointF (Point p)

    {

        Point p1 = new Point(p);

        /*

        if (this.ls == null)     // אני חושבת שזה מיותר. זה עבור רשימה שהיא בהתחלה ריקה, אבל בעצם הקוד בהמשך מטפל בזה

        {

            this.ls = new Node<Point>(p1);

            return;

        }

        */

        if (this.IsExist(p))   // אם חוזר אמת כלומר אם הנקודה כבר קיימת ברשימה

            return;

        Node<Point> pos = new Node<Point>(p1,this.ls);

        this.ls = pos;

    }

    // הפעולה מקבלת נקודה ומורידה נקודה בעלת ערכים זהים מרשימת הקודקודים, אם קיימת

    public void DelPoint (Point p)

    {

        if (this.ls == null) return;   // אם הרשימה ריקה אין מה למחוק

        if (this.ls.GetValue().Equals(p))   // האיבר המבוקש נמצא בתחילת הרשימה

        {

            this.ls = this.ls.GetNext();

            return;

        }

        // אם הגענו לשלב זה, הרשימה בהכרח מכילה לפחות איבר אחד, והאיבר המבוקש לא בהתחלה, אלא נמצא באמצע או בסוף הרשימה

        Node<Point> pos = this.ls; 

        Node<Point> prev = pos;

        pos = pos.GetNext();

        while (pos!=null && !pos.GetValue().Equals(p))

        {

            pos = pos.GetNext();

            prev = prev.GetNext();

        }

        /*

        הלולאה הנ״ל נעצרה בגלל שסיימתי לעבור על הרשימה ואז זה אומר שלא מצאתי את האיבר המבוקש

        או שהלולאה נעצרה בגלל שבמהלך הסריקה מצאתי את האיבר המבוקש

        לכן, אם מצאתי את האיבר אז בהכרח שהרשימה שונה מ-נאל

        ואז נרצה למחוק את האיבר המבוקש שמצאנו

        */

        if (pos != null)     

            prev.SetNext(pos.GetNext());

    }

}

​

​

// המחלקה נקודה

public class Point

{

    private double x;   // שיעור האיקס של הנקודה

    private double y;   // שיעור הוואי של הנקודה

    // פעולה בונה נקודה עם ערכי איקס ו-וואי המתאימים שהועברו כפרמטרים

    public Point (double x, double y)

    {

        this.x = x; 

        this.y = y;

    }

    // פעולה בונה מעתיקה - מקבלת נקודה אחרת שהועברה כפרמטר ובונה נקודה חדשה עם ערכים זהים לנקודה האחרת

    public Point (Point other)

    {

        this.x = other.x;   

        this.y = other.y;

    }

    // פעולה המחזירה את ערכו של שיעור האיקס של הנקודה

    public double GetX ()

    {

        return this.x;  

    }

    // פעולה המחזירה את ערכו של שיעור הוואי של הנקודה

    public double GetY ()

    {

        return this.y;  

    }

    // פעולה שמקבלת ערך חדש עבור איקס, ומעדכנת את שיעור האיקס של הנקודה בהתאם

    public void SetX (double x)

    {

        this.x = x; 

    }

    // פעולה שמקבלת ערך חדש עבור וואי, ומעדכנת את שיעור הוואי של הנקודה בהתאם

    public void SetY (double y)

    {

        this.y = y; 

    }

    // הפעולה מקבלת יחידות אורך להזזת הנקודה משני הצירים ו"מזיזה" את הנקודה, כך שקואורדינטה איקס החדשה היא

    // x+dx

    // וקואורדינטה וואי החדשה היא

    // y+dy

    public void ShiftPoint (double dx, double dy)

    {

        this.x = this.x + dx;

        this.y = this.y + dy;

    }

    // הפעולה מחזירה את מספר הרביע בו נמצאת הנקודה במערכת הצירים

    // הערה: אם הנקודה ממוקמת על אחד מהצירים, יוחזר הערך 0

    // לחילופין, ניתן להניח שהנקודה לא נמצאת על אחד הצירים

    public int Quadrant ()

    {

        if (this.x>0 && this.y>0)

            return 1;

        if (this.x<0 && this.y>0)

            return 2;

        if (this.x<0 && this.y<0)

            return 3;

        if (this.x>0 && this.y<0)

            return 4;

        return 0;

    }   

    // הפעולה מקבלת נקודה אחרת ומחזירה אמת אם ערכי הנקודה הנוכחית, וערכי הנקודה האחרת הם שווים, אחרת מחזירה שקר

    public bool Equals (Point other)

    {

        return (this.x==other.x && this.y==other.y);

    }

    // פעולה שמקבלת נקודה אחרת, ומחזירה את המרחק בין הנקודה הנוכחית לנקודה האחרת

    public double Distance (Point other)

    {

        return Math.Sqrt(Math.Pow(other.y-this.y,2) + Math.Pow(other.x-this.x,2));

    }

    // הפעולה מחזירה את מרחק הנקודה הנוכחית מראשית הצירים

    public double Distance00 (Point other)

    {

        return Math.Sqrt(Math.Pow(this.x,2)+Math.Pow(this.y,2));

    }

    // הפעולה מחזירה מחרוזת המתארת את ערכי הנקודה לפי הייצוג המתמטי המקובל 

    // (x,y)

    public override string ToString ()

    {

        return "(" + this.x + "," + this.y + ")";   

    }

}

​

​

​

// המחלקה חוליה

public class Node<T> 

{

    private T value;

    private Node<T> next;

    public Node (T value)

    {

        this.value=value;

        this.next=null;

    }

​

public Node (T value, Node<T> next)

    {

        this.value=value;

        this.next=next;

    }

    public T GetValue()

    {

        return this.value;

    }

​

public Node<T> GetNext()

    {

        return this.next;

    }

    public void SetValue (T value)

    {

        this.value=value;

    }

    public void SetNext(Node<T> next)

    {

        this.next=next;

    }

​

    // הפעולה מחזירה אמת אם קיימת חוליה עוקבת, אחרת מחזירה שקר

    public bool HasNext()

    {

       return this.next != null;

    }

    public override String ToString()

    {

        return this.value.ToString();

    }

​

}

​

​