Advertisement
vvsvvs

Untitled

May 20th, 2022
772
142 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.Text;
  4. using System.Linq;
  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.        
  43.         public Point StartPoint
  44.         {
  45.             get => this.startPoint;
  46.  
  47.             private set
  48.             {
  49.  
  50.             }
  51.         }
  52.        
  53.         public Point CurrentPoint
  54.         {
  55.             get => this.currentPoint;
  56.  
  57.             set
  58.             {
  59.                 if (this.IsValidIndex(value))
  60.                 {
  61.                     this.currentPoint = value;
  62.                 }
  63.                 else
  64.                 {
  65.                     throw new IndexOutOfRangeException();
  66.                 }
  67.             }
  68.         }
  69.        
  70.         public Point ChekPoint
  71.         {
  72.             get => this.chekPoint;
  73.  
  74.             set
  75.             {
  76.                 if (this.IsValidIndex(value))
  77.                 {
  78.                     this.chekPoint = value;
  79.                 }
  80.                 else
  81.                 {
  82.                     throw new IndexOutOfRangeException();
  83.                 }
  84.             }
  85.         }
  86.        
  87.         public bool IsValidIndex(Point point)
  88.         {
  89.             bool isValid = ((point.Row >= 0) && (point.Row < this.MaxLengthRow));
  90.             isValid = ((isValid) && (point.Col >= 0) && (point.Col < this.matrix[point.Row].Length));
  91.  
  92.             return isValid;
  93.         }
  94.        
  95.         public int MaxLengthRow
  96.         {
  97.             get => this.maxLengthRow;
  98.  
  99.             private set
  100.             {
  101.  
  102.             }
  103.         }
  104.        
  105.         public int CurrentRowLength
  106.         {
  107.             get => this.currentRowLength;
  108.             private set
  109.             {
  110.  
  111.             }
  112.         }
  113.        
  114.         public Matrix(string newSpaceSeparator, int newRow, int newCol = 0)
  115.         {
  116.             this.CreateMatrix(null, newSpaceSeparator, newRow, newCol);
  117.         }
  118.        
  119.         public Matrix(T[,] newMatrix, string newSpaceSeparator)
  120.         {
  121.             int newRow = newMatrix.GetLength(0);
  122.             int newCol = newMatrix.GetLength(1);
  123.  
  124.             this.CreateMatrix(newMatrix, newSpaceSeparator, newRow, newCol);
  125.         }
  126.        
  127.         public void SetStartElement(T element)
  128.         {
  129.             this.startElement = element;
  130.             this.SetStartPoint(this.startElement);
  131.         }
  132.        
  133.         public void SetStartPoint(T newStartElement)
  134.         {
  135.             this.startElement = newStartElement;
  136.  
  137.             bool isLoopExit = false;
  138.             int row = 0;
  139.  
  140.             while ((row < MaxLengthRow) && (!isLoopExit))
  141.             {
  142.                 int col = 0;
  143.  
  144.                 while ((col < this.matrix[row].Length) && (!isLoopExit))
  145.                 {
  146.                     if (this.matrix[row][col].Equals(newStartElement))
  147.                     {
  148.                         this.startPoint = new Point(row, col);
  149.                         isLoopExit = true;
  150.                     }
  151.  
  152.                     col++;
  153.                 }
  154.  
  155.                 row++;
  156.             }
  157.  
  158.             this.SetStartToCurrentPoint();
  159.         }
  160.        
  161.         public void SetStartToCurrentPoint()
  162.         {
  163.             this.CurrentPoint = new Point(this.startPoint.Row, this.startPoint.Col);
  164.         }
  165.        
  166.         public void SetMatrixRow(int row, T[] colArr)
  167.         {
  168.             this.matrix[row] = colArr;
  169.  
  170.             this.SetLength();
  171.         }
  172.        
  173.         public void SetCurrentElement(T element)
  174.         {
  175.             this.matrix[currentPoint.Row][currentPoint.Col] = element;
  176.         }
  177.        
  178.         public T GetCurrentElement() => this.matrix[currentPoint.Row][currentPoint.Col];
  179.        
  180.         public void SetElementAtPosition(T element, Point point)
  181.         {
  182.             this.matrix[point.Row][point.Col] = element;
  183.         }
  184.        
  185.        
  186.         public T GetElementAtPosition(Point point) => this.matrix[point.Row][point.Col];
  187.        
  188.         public void SetSpaceSeparator(string newSpaceSeparator)
  189.         {
  190.             this.spaceSeparator = newSpaceSeparator;
  191.         }
  192.        
  193.         public IEnumerable<Point> FoundAllElementPositions(T element)
  194.         {
  195.             Queue<Point> result = new Queue<Point>();
  196.  
  197.             for (int row = 0; row < this.matrix.Length; row++)
  198.             {
  199.                 int maxCol = this.matrix[row].Length;
  200.  
  201.                 for (int col = 0; col < maxCol; col++)
  202.                 {
  203.                     if (this.matrix[row][col].Equals(element))
  204.                     {
  205.                         Point newPoint = new Point(row, col);
  206.                         result.Enqueue(newPoint);
  207.                     }
  208.                 }
  209.             }
  210.  
  211.             return result as IEnumerable<Point>;
  212.         }
  213.        
  214.         public override string ToString()
  215.         {
  216.             StringBuilder sb = new StringBuilder();
  217.  
  218.             for (int row = 0; row < this.maxLengthRow; row++)
  219.             {
  220.                 StringBuilder temp = new StringBuilder();
  221.  
  222.                 int colLessOne = this.matrix[row].Length - 1;
  223.  
  224.                 for (int col = 0; col < colLessOne + 1; col++)
  225.                 {
  226.                     if (col == colLessOne)
  227.                     {
  228.                         temp.Append(this.matrix[row][col].ToString());
  229.                     }
  230.                     else
  231.                     {
  232.                         temp.Append(this.matrix[row][col].ToString() + this.spaceSeparator);
  233.                     }
  234.                 }
  235.  
  236.                 sb.AppendLine(temp.ToString());
  237.             }
  238.  
  239.             return sb.ToString().TrimEnd();
  240.         }
  241.        
  242.         public string GetChessCoordinates(Point position) => $"{((char)((int)'a' + position.Col)).ToString()}{position.Row + 1}";
  243.        
  244.         public Point ChangeCurrentPosition(Point newPoint, int stepRow, int stepCol)
  245.         {
  246.             Point result = null;
  247.             if (this.currentPoint.Row == newPoint.Row)
  248.             {
  249.                 result = new Point(newPoint.Row, this.matrix[this.currentPoint.Row].Length + (-1) * newPoint.Col * stepCol);
  250.             }
  251.             else if (currentPoint.Col == newPoint.Col)
  252.             {
  253.                 result = new Point(this.MaxLengthRow + (-1) * newPoint.Row * stepRow, newPoint.Col);
  254.             }
  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.        
  300.         private void SetCurrentCol(int row)
  301.         {
  302.             this.CurrentRowLength = this.matrix[row].Length;
  303.         }
  304.        
  305.        
  306.    
  307.     }
  308.    
  309.    
  310.     class Bee
  311.     {
  312.         const char SNAKE = 'S';
  313.         const char SNAKE_PASS = '.';
  314.         const char FREE = '-';
  315.         const char FOOD = '*';
  316.         const char BURROW = 'B';
  317.         const int EAT_LIMITS = 10;
  318.        
  319.         static void Main()
  320.         {
  321.             int n = int.Parse(Console.ReadLine());
  322.            
  323.             Matrix<char> territory = new Matrix<char>(string.Empty, n, n);
  324.            
  325.             for(int i = 0; i < n; i++)
  326.             {
  327.                 char[] temp = Console.ReadLine().ToCharArray();
  328.                
  329.                 territory.SetMatrixRow(i, temp);
  330.             }
  331.            
  332.             territory.SetStartElement(SNAKE);
  333.            
  334.             Stack<Point> burrows = new Stack<Point>(territory.FoundAllElementPositions(BURROW));
  335.            
  336.             Point burrow1 = new Point(-1, -1);
  337.             Point burrow2 = new Point(-1, -1);
  338.            
  339.             bool isSecondBurrowFill = false;
  340.            
  341.             while(burrows.Count > 0)
  342.             {
  343.                 if(isSecondBurrowFill)
  344.                 {
  345.                     burrow2 = burrows.Pop();
  346.                 }
  347.                 else
  348.                 {
  349.                     burrow1 = burrows.Pop();
  350.                     isSecondBurrowFill = true;
  351.                 }
  352.                
  353.             }
  354.            
  355.             int foodEaten = 0;
  356.            
  357.             bool isEatenLimits = false;
  358.             bool isGoesOut = false;
  359.            
  360.             while((!isGoesOut) && (!isEatenLimits))
  361.             {
  362.                 string direction = Console.ReadLine().ToLower();
  363.                
  364.                 int stepRow = 0;
  365.                 int stepCol = 0;
  366.                
  367.                 switch(direction)
  368.                     {
  369.                         case "up":
  370.                           stepRow--;
  371.                           break;
  372.                         case "down":
  373.                           stepRow++;
  374.                           break;
  375.                         case "left":
  376.                           stepCol--;
  377.                           break;
  378.                         case "right":
  379.                           stepCol++;
  380.                           break;
  381.                     }
  382.                    
  383.                 try
  384.                     {
  385.                         int newRow = territory.CurrentPoint.Row + stepRow;
  386.                         int newCol = territory.CurrentPoint.Col + stepCol;
  387.                        
  388.                         territory.SetElementAtPosition(SNAKE_PASS, territory.CurrentPoint);
  389.                         territory.CurrentPoint = new Point(newRow, newCol);
  390.                        
  391.                         char ch = territory.GetCurrentElement();
  392.                        
  393.                         if(ch.Equals(BURROW))
  394.                         {
  395.                             territory.SetElementAtPosition(SNAKE_PASS, territory.CurrentPoint);
  396.                            
  397.                             if(territory.CurrentPoint.CompareTo(burrow1).Equals(0))
  398.                             {
  399.                                 territory.CurrentPoint = burrow2;
  400.                             }
  401.                             else
  402.                             {
  403.                                 territory.CurrentPoint = burrow1;
  404.                             }
  405.                            
  406.                             burrow1 = new Point(-1, -1);
  407.                             burrow2 = new Point(-1, -1);
  408.                         }
  409.                        
  410.                         if(ch.Equals(FOOD))
  411.                         {
  412.                             foodEaten++;
  413.                             if(foodEaten >= EAT_LIMITS)
  414.                             {
  415.                                 isEatenLimits = true;
  416.                             }
  417.                         }
  418.                        
  419.                         territory.SetCurrentElement(SNAKE);
  420.                        
  421.                     }
  422.                 catch (IndexOutOfRangeException e)
  423.                     {
  424.                         isGoesOut = true;
  425.                     }
  426.                 }
  427.                
  428.                 StringBuilder sb = new StringBuilder();
  429.            
  430.             if(isGoesOut)
  431.             {
  432.                 sb.AppendLine($"Game over!");
  433.             }
  434.             else
  435.             {
  436.                 sb.AppendLine($"You won! You fed the snake.");
  437.             }
  438.            
  439.             sb.AppendLine($"Food eaten: {foodEaten}");
  440.            
  441.             sb.AppendLine(territory.ToString());
  442.            
  443.             Console.WriteLine(sb.ToString().TrimEnd());
  444.             }
  445.            
  446.            
  447.      
  448.     }
  449. }
Advertisement
RAW Paste Data Copied
Advertisement