using System;

using System.Collections.Generic;

​

public class Program

{

    public static List<Point> path = new List<Point>();

     public static void Main(){

        // Create two random points

        Random rand = new Random();

        Point pointA = new Point(0,1);

        Point pointB = new Point(0,5);

​

        // Create the obstacles array

        int rows = 10;

        int cols = 10;

        Circle[,] obstacles = new Circle[rows, cols];

​

        // Initialize the obstacles array with null values

        for (int i = 0; i < rows; i++)

        {

            for (int j = 0; j < cols; j++)

            {

                obstacles[i, j] = null;

            }

        }

​

        // Set some points as obstacles

        obstacles[2, 3] = new Circle(1,2);

        obstacles[5, 8] = new Circle(1,2);

​

        // Find a path between the points

        int turns = FindPath(pointA, pointB, obstacles);

​

        // Print the number of turns and the path

        Console.WriteLine("Turns taken: " + turns);

        Console.WriteLine("Path: ");

        foreach (Point p in path)

        {

            Console.WriteLine("(" + p.X + ", " + p.Y + ")");

        }

}

​

​

   static int FindPath(Point pointA, Point pointB, Circle[,] obstacles)

{

    // Initialize variables to store the current position,

    // the number of turns taken, and the direction we are facing

    Point currentPos = pointA;

    int turns = 0;

    int direction = 0; // 0 = right, 1 = up, 2 = left, 3 = down

​

    // Initialize a queue to store the points we need to visit

    Queue<Point> pointsToVisit = new Queue<Point>();

​

    // Add all of the points on the grid to the queue

    for (int x = 0; x < 10; x++)

    {

        for (int y = 0; y < 10; y++)

        {

            pointsToVisit.Enqueue(new Point(x, y));

        }

    }

​

    // Initialize a set to store the points we have visited

    HashSet<Point> visitedPoints = new HashSet<Point>();

​

    // While there are still points to visit

    while (pointsToVisit.Count > 0)

    {

        // Dequeue the next point

        Point nextPoint = pointsToVisit.Dequeue();

​

        // If we have reached the destination, return the number of turns

        if (nextPoint == pointB)

        {

            return turns;

        }

​

        // If we have made too many turns, skip this point

        if (turns >= 2)

        {

            continue;

        }

​

        // Check if the point is an obstacle

        if (obstacles[nextPoint.X, nextPoint.Y] != null)

        {

            continue;

        }

​

        // Mark the point as visited

        visitedPoints.Add(nextPoint);

​

        // Add the point to the path

        path.Add(nextPoint);

​

        // Calculate the Manhattan distance from the current position to the destination

        int distance = Math.Abs(nextPoint.X - currentPos.X) + Math.Abs(nextPoint.Y - currentPos.Y);

​

        // If the distance is greater than 1, we need to turn

        if (distance > 1)

        {

            // Increment the number of turns

            turns++;

​

            // Determine the direction we need to turn towards

            if (nextPoint.X > currentPos.X)

            {

                direction = 0;

            }

            else if (nextPoint.Y > currentPos.Y)

                   {

            direction = 1;

        }

        else if (nextPoint.X < currentPos.X)

        {

            direction = 2;

        }

        else if (nextPoint.Y < currentPos.Y)

        {

            direction = 3;

        }

    }

​

    // Add the neighboring points to the queue

    switch (direction)

    {

        case 0:

            // If we are facing right, add the point to the right if it is not an obstacle

            if (obstacles[currentPos.X + 1, currentPos.Y] == null)

            {

                pointsToVisit.Enqueue(new Point(currentPos.X + 1, currentPos.Y));

            }

            break;

        case 1:

            // If we are facing up, add the point above if it is not an obstacle

            if (obstacles[currentPos.X, currentPos.Y - 1] == null)

            {

                pointsToVisit.Enqueue(new Point(currentPos.X, currentPos.Y - 1));

            }

            break;

        case 2:

            // If we are facing left, add the point to the left if it is not an obstacle

            if (obstacles[currentPos.X - 1, currentPos.Y] == null)

            {

                pointsToVisit.Enqueue(new Point(currentPos.X - 1, currentPos.Y));

            }

            break;

             case 3:

            // If we are facing down, add the point below if it is not an obstacle

            if (obstacles[currentPos.X, currentPos.Y + 1] == null)

            {

                pointsToVisit.Enqueue(new Point(currentPos.X, currentPos.Y + 1));

            }

            break;

    }

​

    // Update the current position

    currentPos = nextPoint;

}

​

// If we have reached this point, it means we have not found a path

return -1;

}

}

​

public class Point

{

    public int X { get; set; }

    public int Y { get; set; }

​

    public Point(int x, int y)

    {

        X = x;

        Y = y;

    }

​

    public override bool Equals(object obj)

    {

        Point other = obj as Point;

        if (other == null)

        {

            return false;

        }

​

        return X == other.X && Y == other.Y;

    }

​

    public override int GetHashCode()

    {

        return X.GetHashCode() ^ Y.GetHashCode();

    }

}

​

public class Circle

{

    public int X { get; set; }

    public int Y { get; set; }

​

    public Circle(int x, int y)

    {

        X = x;

        Y = y;

    }

​

    public override bool Equals(object obj)

    {

        Circle other = obj as Circle;

        if (other == null)

        {

            return false;

        }

​

        return X == other.X && Y == other.Y;

    }

​

    public override int GetHashCode()

    {

        return X.GetHashCode() ^ Y.GetHashCode();

    }

}

​

​

​

​

​

​