Advertisement
vvsvvs

Untitled

May 18th, 2022
531
140 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 Beaver_Work
  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.         const char BEAVER = 'B';
  308.         const char FISH = 'F';
  309.         const char FREE = '-';
  310.         const char FIRST_WOOD = 'a';
  311.         const char LAST_WOOD = 'z';
  312.  
  313.         static void Main(string[] args)
  314.         {
  315.             int n = int.Parse(Console.ReadLine());
  316.  
  317.             int countWoods = 0;
  318.  
  319.             Matrix<char> pond = new Matrix<char>(" ", n, n);
  320.  
  321.             for (int i = 0; i < n; i++)
  322.             {
  323.                 char[] temp = Console.ReadLine().Split(' ').Select(char.Parse).ToArray();
  324.  
  325.                 for (int j = 0; j < temp.Length; j++)
  326.                 {
  327.                     if ((temp[j] >= FIRST_WOOD) && (temp[j] <= LAST_WOOD))
  328.                     {
  329.                         countWoods++;
  330.                     }
  331.                 }
  332.  
  333.                 pond.SetMatrixRow(i, temp);
  334.             }
  335.  
  336.             pond.SetStartElement(BEAVER);
  337.             Point beaverPosition = pond.StartPoint;
  338.  
  339.             List<char> collectedWool = new List<char>();
  340.  
  341.             bool isLoopExit = false;
  342.             bool isCollectAllWood = false;
  343.  
  344.             while ((!isCollectAllWood) && (!isLoopExit))
  345.             {
  346.                 string input = Console.ReadLine().ToLower();
  347.  
  348.                 if (input.Equals("end"))
  349.                 {
  350.                     isLoopExit = true;
  351.                 }
  352.                 else
  353.                 {
  354.                     int rowStep = 0;
  355.                     int colStep = 0;
  356.  
  357.                     switch (input)
  358.                     {
  359.                         case "up":
  360.                             rowStep--;
  361.                             break;
  362.                         case "down":
  363.                             rowStep++;
  364.                             break;
  365.                         case "left":
  366.                             colStep--;
  367.                             break;
  368.                         case "right":
  369.                             colStep++;
  370.                             break;
  371.                         default:
  372.                             break;
  373.                     }
  374.  
  375.                     Point nextPosition = new Point(beaverPosition.Row + rowStep, beaverPosition.Col + colStep);
  376.  
  377.                     if (pond.IsValidIndex(nextPosition))
  378.                     {
  379.                         pond.SetElementAtPosition(FREE, beaverPosition);
  380.                         beaverPosition = nextPosition;
  381.                         pond.CurrentPoint = beaverPosition;
  382.  
  383.                         char charInBeaverPosition = pond.GetElementAtPosition(beaverPosition);                        
  384.  
  385.                         if (charInBeaverPosition.Equals(FISH))
  386.                         {
  387.                             pond.SetElementAtPosition(FREE, beaverPosition);
  388.  
  389.                             Point goUnderWater = new Point(beaverPosition.Row + rowStep, beaverPosition.Col + colStep);
  390.  
  391.                             if (pond.IsValidIndex(goUnderWater))
  392.                             {
  393.                                 int newRowIndex = beaverPosition.Row;
  394.                                 int newColIndex = beaverPosition.Col;
  395.  
  396.                                 if (rowStep == -1)
  397.                                 {
  398.                                     newRowIndex = 0;
  399.                                 }
  400.                                 else if (rowStep == 1)
  401.                                 {
  402.                                     newRowIndex = pond.CurrentRowLength;
  403.                                 }
  404.                                 else if (colStep == -1)
  405.                                 {
  406.                                     newColIndex = 0;
  407.                                 }
  408.                                 else
  409.                                 {
  410.                                     newColIndex = pond.GetCurrentCol(beaverPosition.Row);
  411.                                 }
  412.  
  413.                                 beaverPosition = new Point(newRowIndex, newColIndex);                                
  414.                             }
  415.                             else
  416.                             {
  417.                                 beaverPosition = pond.ChangeCurrentPosition(goUnderWater, rowStep, colStep);                                
  418.                             }
  419.  
  420.                             pond.CurrentPoint = beaverPosition;
  421.  
  422.                            
  423.                         }
  424.  
  425.                         if (IsHasWood(charInBeaverPosition))
  426.                         {
  427.                             collectedWool.Add(charInBeaverPosition);
  428.                             countWoods--;
  429.                             pond.SetElementAtPosition(FREE, beaverPosition);
  430.  
  431.                             if (countWoods == 0)
  432.                             {
  433.                                 isCollectAllWood = true;
  434.                             }
  435.                         }
  436.                     }
  437.                     else
  438.                     {
  439.                         if (collectedWool.Count > 0)
  440.                         {
  441.                             collectedWool.RemoveAt(collectedWool.Count - 1);                            
  442.                         }
  443.                     }
  444.  
  445.                     pond.SetCurrentElement(BEAVER);
  446.                 }
  447.             }
  448.  
  449.             StringBuilder sb = new StringBuilder();
  450.  
  451.             if (isCollectAllWood)
  452.             {
  453.                 sb.AppendLine($"The Beaver successfully collect {collectedWool.Count} wood branches: {string.Join(", ", collectedWool)}.");
  454.             }
  455.             else
  456.             {
  457.                 sb.AppendLine($"The Beaver failed to collect every wood branch. There are {countWoods} branches left.");
  458.  
  459.             }
  460.  
  461.             sb.AppendLine(pond.ToString());
  462.  
  463.             Console.WriteLine(sb);
  464.         }
  465.  
  466.         private static bool IsHasWood(char ch)
  467.         {
  468.            
  469.             if ((ch >= FIRST_WOOD) && (ch <= LAST_WOOD))
  470.             {
  471.                 return true;
  472.             }
  473.  
  474.             return false;
  475.         }
  476.     }
  477. }
  478.  
Advertisement
RAW Paste Data Copied
Advertisement