Advertisement
vvsvvs

Untitled

Jun 25th, 2022
1,139
133 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 Class_Matrix
  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.  
  47.         public Point CurrentPoint
  48.         {
  49.             get => this.currentPoint;
  50.  
  51.             set
  52.             {
  53.                 if (this.IsValidIndex(value))
  54.                 {
  55.                     this.currentPoint = value;
  56.                 }
  57.                 else
  58.                 {
  59.                     throw new IndexOutOfRangeException();
  60.                 }
  61.             }
  62.         }
  63.  
  64.         public Point ChekPoint
  65.         {
  66.             get => this.chekPoint;
  67.  
  68.             set
  69.             {
  70.                 if (this.IsValidIndex(value))
  71.                 {
  72.                     this.chekPoint = value;
  73.                 }
  74.                 else
  75.                 {
  76.                     throw new IndexOutOfRangeException();
  77.                 }
  78.             }
  79.         }
  80.  
  81.         public bool IsValidIndex(Point point)
  82.         {
  83.             bool isValid = ((point.Row >= 0) && (point.Row < this.MaxLengthRow));
  84.             isValid = ((isValid) && (point.Col >= 0) && (point.Col < this.matrix[point.Row].Length));
  85.  
  86.             return isValid;
  87.         }
  88.  
  89.         public int MaxLengthRow
  90.         {
  91.             get => this.maxLengthRow;
  92.  
  93.             private set
  94.             {
  95.  
  96.             }
  97.         }
  98.  
  99.         public int CurrentRowLength
  100.         {
  101.             get => this.currentRowLength;
  102.             private set
  103.             {
  104.  
  105.             }
  106.         }
  107.  
  108.         public Matrix(string newSpaceSeparator, int newRow, int newCol = 0)
  109.         {
  110.             this.CreateMatrix(null, newSpaceSeparator, newRow, newCol);
  111.         }
  112.  
  113.         public Matrix(T[,] newMatrix, string newSpaceSeparator)
  114.         {
  115.             int newRow = newMatrix.GetLength(0);
  116.             int newCol = newMatrix.GetLength(1);
  117.  
  118.             this.CreateMatrix(newMatrix, newSpaceSeparator, newRow, newCol);
  119.         }
  120.  
  121.         public void SetStartElement(T element)
  122.         {
  123.             this.startElement = element;
  124.             this.SetStartPoint(this.startElement);
  125.         }
  126.  
  127.         public void SetStartPoint(T newStartElement)
  128.         {
  129.             this.startElement = newStartElement;
  130.  
  131.             bool isLoopExit = false;
  132.             int row = 0;
  133.  
  134.             while ((row < MaxLengthRow) && (!isLoopExit))
  135.             {
  136.                 int col = 0;
  137.  
  138.                 while ((col < this.matrix[row].Length) && (!isLoopExit))
  139.                 {
  140.                     if (this.matrix[row][col].Equals(newStartElement))
  141.                     {
  142.                         this.startPoint = new Point(row, col);
  143.                         isLoopExit = true;
  144.                     }
  145.  
  146.                     col++;
  147.                 }
  148.  
  149.                 row++;
  150.             }
  151.  
  152.             this.SetStartToCurrentPoint();
  153.         }
  154.  
  155.         public void SetStartToCurrentPoint()
  156.         {
  157.             this.CurrentPoint = new Point(this.startPoint.Row, this.startPoint.Col);
  158.         }
  159.  
  160.         public void SetMatrixRow(int row, T[] colArr)
  161.         {
  162.             this.matrix[row] = colArr;
  163.  
  164.             this.SetLength();
  165.         }
  166.  
  167.         public void SetCurrentElement(T element)
  168.         {
  169.             this.matrix[currentPoint.Row][currentPoint.Col] = element;
  170.         }
  171.  
  172.         public T GetCurrentElement() => this.matrix[currentPoint.Row][currentPoint.Col];
  173.  
  174.         public void SetElementAtPosition(T element, Point point)
  175.         {
  176.             this.matrix[point.Row][point.Col] = element;
  177.         }
  178.  
  179.         public T GetElementAtPosition(Point point) => this.matrix[point.Row][point.Col];
  180.  
  181.         public void SetSpaceSeparator(string newSpaceSeparator)
  182.         {
  183.             this.spaceSeparator = newSpaceSeparator;
  184.         }
  185.  
  186.         public IEnumerable<Point> FoundAllElementPositions(T element)
  187.         {
  188.             Queue<Point> result = new Queue<Point>();
  189.  
  190.             for (int row = 0; row < this.matrix.Length; row++)
  191.             {
  192.                 int maxCol = this.matrix[row].Length;
  193.  
  194.                 for (int col = 0; col < maxCol; col++)
  195.                 {
  196.                     if (this.matrix[row][col].Equals(element))
  197.                     {
  198.                         Point newPoint = new Point(row, col);
  199.                         result.Enqueue(newPoint);
  200.                     }
  201.                 }
  202.             }
  203.  
  204.             return result as IEnumerable<Point>;
  205.         }
  206.  
  207.         public override string ToString()
  208.         {
  209.             StringBuilder sb = new StringBuilder();
  210.  
  211.             for (int row = 0; row < this.maxLengthRow; row++)
  212.             {
  213.                 StringBuilder temp = new StringBuilder();
  214.  
  215.                 int colLessOne = this.matrix[row].Length - 1;
  216.  
  217.                 for (int col = 0; col < colLessOne + 1; col++)
  218.                 {
  219.                     if (col == colLessOne)
  220.                     {
  221.                         temp.Append(this.matrix[row][col].ToString());
  222.                     }
  223.                     else
  224.                     {
  225.                         temp.Append(this.matrix[row][col].ToString() + this.spaceSeparator);
  226.                     }
  227.                 }
  228.  
  229.                 sb.AppendLine(temp.ToString());
  230.             }
  231.  
  232.             return sb.ToString().TrimEnd();
  233.         }
  234.  
  235.         public string GetChessCoordinates(Point position) => $"{((char)((int)'a' + position.Col)).ToString()}{position.Row + 1}";
  236.  
  237.         public Point ChangeCurrentPosition(Point newPoint, int stepRow, int stepCol)
  238.         {
  239.             Point result = null;
  240.             if (this.currentPoint.Row == newPoint.Row)
  241.             {
  242.                 result = new Point(newPoint.Row, this.matrix[this.currentPoint.Row].Length + (-1) * newPoint.Col * stepCol);
  243.             }
  244.             else if (currentPoint.Col == newPoint.Col)
  245.             {
  246.                 result = new Point(this.MaxLengthRow + (-1) * newPoint.Row * stepRow, newPoint.Col);
  247.             }
  248.  
  249.             try
  250.             {
  251.                 this.CurrentPoint = result;
  252.             }
  253.             catch (IndexOutOfRangeException)
  254.             {
  255.  
  256.                 result = new Point(-1, -1);
  257.             }
  258.  
  259.             return result;
  260.         }
  261.  
  262.         private void CreateMatrix(T[,] newMatrix, string newSpaceSeparator, int newRow, int newCol)
  263.         {
  264.             this.matrix = new T[newRow][];
  265.  
  266.             if (newMatrix == null)
  267.             {
  268.                 for (int row = 0; row < newRow; row++)
  269.                 {
  270.                     T[] temp = new T[newCol];
  271.                     this.matrix[row] = temp;
  272.                 }
  273.             }
  274.             else
  275.             {
  276.                 for (int row = 0; row < newRow; row++)
  277.                 {
  278.                     T[] temp = new T[newCol];
  279.                     this.matrix[row] = temp;
  280.  
  281.                     for (int col = 0; col < newCol; col++)
  282.                     {
  283.                         this.matrix[row][col] = newMatrix[row, col];
  284.                     }
  285.                 }
  286.             }
  287.  
  288.             this.SetLength();
  289.             this.SetSpaceSeparator(newSpaceSeparator);
  290.         }
  291.  
  292.         private void SetLength()
  293.         {
  294.             this.maxLengthRow = this.matrix.Length;
  295.         }
  296.  
  297.         public int GetCurrentCol(int row)
  298.         {
  299.             this.SetCurrentCol(row);
  300.             return this.CurrentRowLength;
  301.         }
  302.         private void SetCurrentCol(int row)
  303.         {
  304.             this.CurrentRowLength = this.matrix[row].Length;
  305.         }
  306.     }
  307.  
  308.     class Program
  309.     {
  310.         static void Main(string[] args)
  311.         {
  312.             const char VANKO = 'V';
  313.             const char HOLE = '*';
  314.             const char RODS = 'R';
  315.             const char CABLES = 'C';
  316.             const char ELDIED = 'E';
  317.             const char FREE = '-';
  318.  
  319.             int n = int.Parse(Console.ReadLine());
  320.  
  321.             Matrix<char> wall = new Matrix<char>(string.Empty, n, n);
  322.  
  323.             for (int i = 0; i < n; i++)
  324.             {
  325.                 char[] temp = Console.ReadLine().ToCharArray();
  326.                 wall.SetMatrixRow(i, temp);
  327.             }
  328.  
  329.             wall.SetStartElement(VANKO);
  330.             wall.SetElementAtPosition(HOLE, wall.CurrentPoint);
  331.  
  332.             bool isLoopExit = false;
  333.             int holeCount = 1;
  334.             int countOfRods = 0;
  335.             bool isDied = false;
  336.  
  337.             StringBuilder sb = new StringBuilder();
  338.  
  339.             while (!isLoopExit)
  340.             {
  341.                 string input = Console.ReadLine();
  342.  
  343.                 if (input.Equals("End"))
  344.                 {
  345.                     isLoopExit = true;
  346.                 }
  347.                 else
  348.                 {
  349.                     int stepRow = 0;
  350.                     int stepCol = 0;
  351.  
  352.                     switch (input)
  353.                     {
  354.                         case "up":
  355.                             stepRow--;
  356.                             break;
  357.                         case "down":
  358.                             stepRow++;
  359.                             break;
  360.                         case "left":
  361.                             stepCol--;
  362.                             break;
  363.                         case "right":
  364.                             stepCol++;
  365.                             break;
  366.                         default:
  367.                             break;
  368.                     }
  369.  
  370.                     Point newPosition = new Point(wall.CurrentPoint.Row + stepRow, wall.CurrentPoint.Col + stepCol);
  371.  
  372.                     if (wall.IsValidIndex(newPosition))
  373.                     {
  374.                         char ch = wall.GetElementAtPosition(newPosition);
  375.                         if (ch == CABLES)
  376.                         {
  377.                             isLoopExit = true;
  378.                             isDied = true;
  379.                             wall.SetElementAtPosition(ELDIED, newPosition);
  380.                             holeCount++;
  381.                         }
  382.                         else if (ch == FREE)
  383.                         {
  384.                             wall.CurrentPoint = newPosition;
  385.                             wall.SetElementAtPosition(HOLE, newPosition);
  386.                             holeCount++;
  387.                         }
  388.                         else if (ch == RODS)
  389.                         {
  390.                             countOfRods++;
  391.                             sb.AppendLine("Vanko hit a rod!");
  392.                         }
  393.                         else if (ch == HOLE)
  394.                         {
  395.                             wall.CurrentPoint = newPosition;
  396.                             sb.AppendLine($"The wall is already destroyed at position [{wall.CurrentPoint.Row}, {wall.CurrentPoint.Col}]!");
  397.                         }
  398.                     }
  399.                 }
  400.             }
  401.  
  402.             if (isDied)
  403.             {
  404.                 sb.AppendLine($"Vanko got electrocuted, but he managed to make {holeCount} hole(s).");
  405.             }
  406.             else
  407.             {
  408.                 sb.AppendLine($"Vanko managed to make {holeCount} hole(s) and he hit only {countOfRods} rod(s).");
  409.                 wall.SetElementAtPosition(VANKO, wall.CurrentPoint);
  410.             }
  411.  
  412.             sb.AppendLine(wall.ToString().TrimEnd());
  413.  
  414.             Console.WriteLine(sb.ToString().TrimEnd());
  415.         }
  416.     }
  417. }
  418.  
Advertisement
RAW Paste Data Copied
Advertisement