Advertisement
vvsvvs

Untitled

May 19th, 2022
667
136 days
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace Miner
  7. {
  8.     public class Point : IComparable<Point>
  9.     {
  10.         public int Row { get; set; }
  11.         public int Col { get; set; }
  12.  
  13.         public Point(int newRow, int newCol)
  14.         {
  15.             this.Row = newRow;
  16.             this.Col = newCol;
  17.         }
  18.  
  19.         public int CompareTo(Point other)
  20.         {
  21.             int comp = this.Row.CompareTo(other.Row);
  22.  
  23.             if (comp == 0)
  24.             {
  25.                 comp = this.Col.CompareTo(other.Col);
  26.             }
  27.  
  28.             return comp;
  29.         }
  30.     }
  31.  
  32.     public class Matrix<T> where T : IComparable<T>
  33.     {
  34.         private T[][] matrix;
  35.         private Point startPoint;
  36.         private Point currentPoint;
  37.         private Point chekPoint;
  38.         private T startElement;
  39.         private int maxLengthRow;
  40.         private int currentRowLength;
  41.         private string spaceSeparator;
  42.         public Point StartPoint
  43.         {
  44.             get => this.startPoint;
  45.  
  46.             private set
  47.             {
  48.  
  49.             }
  50.         }
  51.  
  52.         public Point CurrentPoint
  53.         {
  54.             get => this.currentPoint;
  55.  
  56.             set
  57.             {
  58.                 if (this.IsValidIndex(value))
  59.                 {
  60.                     this.currentPoint = value;
  61.                 }
  62.                 else
  63.                 {
  64.                     throw new IndexOutOfRangeException();
  65.                 }
  66.             }
  67.         }
  68.  
  69.         public Point ChekPoint
  70.         {
  71.             get => this.chekPoint;
  72.  
  73.             set
  74.             {
  75.                 if (this.IsValidIndex(value))
  76.                 {
  77.                     this.chekPoint = value;
  78.                 }
  79.                 else
  80.                 {
  81.                     throw new IndexOutOfRangeException();
  82.                 }
  83.             }
  84.         }
  85.  
  86.         public bool IsValidIndex(Point point)
  87.         {
  88.             bool isValid = ((point.Row >= 0) && (point.Row < this.MaxLengthRow));
  89.             isValid = ((isValid) && (point.Col >= 0) && (point.Col < this.matrix[point.Row].Length));
  90.  
  91.             return isValid;
  92.         }
  93.  
  94.         public int MaxLengthRow
  95.         {
  96.             get => this.maxLengthRow;
  97.  
  98.             private set
  99.             {
  100.  
  101.             }
  102.         }
  103.  
  104.         public int CurrentRowLength
  105.         {
  106.             get => this.currentRowLength;
  107.             private set
  108.             {
  109.  
  110.             }
  111.         }
  112.  
  113.         public Matrix(string newSpaceSeparator, int newRow, int newCol = 0)
  114.         {
  115.             this.CreateMatrix(null, newSpaceSeparator, newRow, newCol);
  116.         }
  117.  
  118.         public Matrix(T[,] newMatrix, string newSpaceSeparator)
  119.         {
  120.             int newRow = newMatrix.GetLength(0);
  121.             int newCol = newMatrix.GetLength(1);
  122.  
  123.             this.CreateMatrix(newMatrix, newSpaceSeparator, newRow, newCol);
  124.         }
  125.  
  126.         public void SetStartElement(T element)
  127.         {
  128.             this.startElement = element;
  129.             this.SetStartPoint(this.startElement);
  130.         }
  131.  
  132.         public void SetStartPoint(T newStartElement)
  133.         {
  134.             this.startElement = newStartElement;
  135.  
  136.             bool isLoopExit = false;
  137.             int row = 0;
  138.  
  139.             while ((row < MaxLengthRow) && (!isLoopExit))
  140.             {
  141.                 int col = 0;
  142.  
  143.                 while ((col < this.matrix[row].Length) && (!isLoopExit))
  144.                 {
  145.                     if (this.matrix[row][col].Equals(newStartElement))
  146.                     {
  147.                         this.startPoint = new Point(row, col);
  148.                         isLoopExit = true;
  149.                     }
  150.  
  151.                     col++;
  152.                 }
  153.  
  154.                 row++;
  155.             }
  156.  
  157.             this.SetStartToCurrentPoint();
  158.         }
  159.  
  160.         public void SetStartToCurrentPoint()
  161.         {
  162.             this.CurrentPoint = new Point(this.startPoint.Row, this.startPoint.Col);
  163.         }
  164.  
  165.         public void SetMatrixRow(int row, T[] colArr)
  166.         {
  167.             this.matrix[row] = colArr;
  168.  
  169.             this.SetLength();
  170.         }
  171.  
  172.         public void SetCurrentElement(T element)
  173.         {
  174.             this.matrix[currentPoint.Row][currentPoint.Col] = element;
  175.         }
  176.  
  177.         public T GetCurrentElement() => this.matrix[currentPoint.Row][currentPoint.Col];
  178.  
  179.         public void SetElementAtPosition(T element, Point point)
  180.         {
  181.             this.matrix[point.Row][point.Col] = element;
  182.         }
  183.  
  184.         public T GetElementAtPosition(Point point) => this.matrix[point.Row][point.Col];
  185.  
  186.         public void SetSpaceSeparator(string newSpaceSeparator)
  187.         {
  188.             this.spaceSeparator = newSpaceSeparator;
  189.         }
  190.  
  191.         public IEnumerable<Point> FoundAllElementPositions(T element)
  192.         {
  193.             Queue<Point> result = new Queue<Point>();
  194.  
  195.             for (int row = 0; row < this.matrix.Length; row++)
  196.             {
  197.                 int maxCol = this.matrix[row].Length;
  198.  
  199.                 for (int col = 0; col < maxCol; col++)
  200.                 {
  201.                     if (this.matrix[row][col].Equals(element))
  202.                     {
  203.                         Point newPoint = new Point(row, col);
  204.                         result.Enqueue(newPoint);
  205.                     }
  206.                 }
  207.             }
  208.  
  209.             return result as IEnumerable<Point>;
  210.         }
  211.  
  212.         public override string ToString()
  213.         {
  214.             StringBuilder sb = new StringBuilder();
  215.  
  216.             for (int row = 0; row < this.maxLengthRow; row++)
  217.             {
  218.                 StringBuilder temp = new StringBuilder();
  219.  
  220.                 int colLessOne = this.matrix[row].Length - 1;
  221.  
  222.                 for (int col = 0; col < colLessOne + 1; col++)
  223.                 {
  224.                     if (col == colLessOne)
  225.                     {
  226.                         temp.Append(this.matrix[row][col].ToString());
  227.                     }
  228.                     else
  229.                     {
  230.                         temp.Append(this.matrix[row][col].ToString() + this.spaceSeparator);
  231.                     }
  232.                 }
  233.  
  234.                 sb.AppendLine(temp.ToString());
  235.             }
  236.  
  237.             return sb.ToString().TrimEnd();
  238.         }
  239.  
  240.         public string GetChessCoordinates(Point position) => $"{((char)((int)'a' + position.Col)).ToString()}{position.Row + 1}";
  241.  
  242.         public Point ChangeCurrentPosition(Point newPoint, int stepRow, int stepCol)
  243.         {
  244.             Point result = null;
  245.             if (this.currentPoint.Row == newPoint.Row)
  246.             {
  247.                 result = new Point(newPoint.Row, this.matrix[this.currentPoint.Row].Length + (-1) * newPoint.Col * stepCol);
  248.             }
  249.             else if (currentPoint.Col == newPoint.Col)
  250.             {
  251.                 result = new Point(this.MaxLengthRow + (-1) * newPoint.Row * stepRow, newPoint.Col);
  252.             }
  253.  
  254.             this.CurrentPoint = result;
  255.  
  256.             return result;
  257.         }
  258.  
  259.         private void CreateMatrix(T[,] newMatrix, string newSpaceSeparator, int newRow, int newCol)
  260.         {
  261.             this.matrix = new T[newRow][];
  262.  
  263.             if (newMatrix == null)
  264.             {
  265.                 for (int row = 0; row < newRow; row++)
  266.                 {
  267.                     T[] temp = new T[newCol];
  268.                     this.matrix[row] = temp;
  269.                 }
  270.             }
  271.             else
  272.             {
  273.                 for (int row = 0; row < newRow; row++)
  274.                 {
  275.                     T[] temp = new T[newCol];
  276.                     this.matrix[row] = temp;
  277.  
  278.                     for (int col = 0; col < newCol; col++)
  279.                     {
  280.                         this.matrix[row][col] = newMatrix[row, col];
  281.                     }
  282.                 }
  283.             }
  284.  
  285.             this.SetLength();
  286.             this.SetSpaceSeparator(newSpaceSeparator);
  287.         }
  288.  
  289.         private void SetLength()
  290.         {
  291.             this.maxLengthRow = this.matrix.Length;
  292.         }
  293.  
  294.         public int GetCurrentCol(int row)
  295.         {
  296.             this.SetCurrentCol(row);
  297.             return this.CurrentRowLength;
  298.         }
  299.         private void SetCurrentCol(int row)
  300.         {
  301.             this.CurrentRowLength = this.matrix[row].Length;
  302.         }
  303.     }
  304.  
  305.     class Program
  306.     {
  307.         static void Main(string[] args)
  308.         {
  309.             const char COAL = 'c';
  310.             const char MINER = 's';
  311.             const char FREE = '*';
  312.             const char END = 'e';
  313.  
  314.             int n = int.Parse(Console.ReadLine());
  315.  
  316.             Matrix<char> mineGalleries = new Matrix<char>(" ", n, n);
  317.  
  318.             Queue<string> commands = new Queue<string>(Console.ReadLine().Split(' ', StringSplitOptions.RemoveEmptyEntries));
  319.            
  320.             for (int row = 0; row < n; row++)
  321.             {
  322.                 char[] temp = Console.ReadLine().Split(' ', StringSplitOptions.RemoveEmptyEntries).Select(char.Parse).ToArray();
  323.  
  324.                 mineGalleries.SetMatrixRow(row, temp);                
  325.             }
  326.  
  327.             mineGalleries.SetStartElement(MINER);
  328.  
  329.             List<Point> coals = mineGalleries.FoundAllElementPositions(COAL).ToList();
  330.  
  331.             int countCoal = coals.Count;
  332.  
  333.             int minerRow = mineGalleries.StartPoint.Row;
  334.             int minerCol = mineGalleries.StartPoint.Col;
  335.  
  336.             int collectedCoal = 0;
  337.             bool isExitLoop = false;
  338.             bool isGameOver = false;
  339.  
  340.             while ((commands.Count > 0) && (!isExitLoop))
  341.             {
  342.                 int colStep = 0;
  343.                 int rowStep = 0;
  344.  
  345.                 switch (commands.Dequeue().ToLower())
  346.                 {
  347.                     case "left":
  348.                         colStep--;
  349.                         break;
  350.                     case "right":
  351.                         colStep++;
  352.                         break;
  353.                     case "up":
  354.                         rowStep--;
  355.                         break;
  356.                     case "down":
  357.                         rowStep++;
  358.                         break;
  359.                     default:
  360.                         break;
  361.                 }
  362.  
  363.                 Point newPosition = new Point(minerRow + rowStep, minerCol + colStep);
  364.  
  365.                 if (mineGalleries.IsValidIndex(newPosition))
  366.                 {
  367.                     mineGalleries.SetElementAtPosition(FREE, new Point(minerRow, minerCol));
  368.  
  369.                     char ch = mineGalleries.GetElementAtPosition(newPosition);
  370.                     if (ch.Equals(COAL))
  371.                     {
  372.                         collectedCoal++;
  373.                         countCoal--;
  374.                     }
  375.  
  376.                     if (ch.Equals(END))
  377.                     {
  378.                         isGameOver = true;
  379.                         isExitLoop = true;
  380.                     }
  381.  
  382.                     if (countCoal.Equals(0))
  383.                     {
  384.                         isExitLoop = true;
  385.                     }
  386.  
  387.                     minerRow = newPosition.Row;
  388.                     minerCol = newPosition.Col;
  389.  
  390.                     mineGalleries.SetElementAtPosition(MINER, newPosition);
  391.                 }
  392.             }// while (commands.Count > 0)
  393.  
  394.             if (countCoal.Equals(0))
  395.             {
  396.                 Console.WriteLine($"You collected all coals! ({minerRow}, {minerCol})");
  397.             }
  398.             else if (isGameOver)
  399.             {
  400.                 Console.WriteLine($"Game over! ({minerRow}, {minerCol})");
  401.             }
  402.             else
  403.             {
  404.                 Console.WriteLine($"{countCoal} coals left. ({minerRow}, {minerCol})");
  405.             }
  406.         }
  407.     }
  408. }
  409.  
Advertisement
RAW Paste Data Copied
Advertisement