Esempio n. 1
0
        public static bool CanGoToPosition(this int[,] matrix, Position position)
        {
            bool isRowInRange = 0 <= position.Row && position.Row < matrix.GetLength(0);
            bool isColInRange = 0 <= position.Col && position.Col < matrix.GetLength(1);

            return isRowInRange && isColInRange && matrix[position.Row, position.Col] == 0;
        }
Esempio n. 2
0
        public static bool AreNeighbourCellsFilled(this int[,] matrix, Position position)
        {
            int upRow;
            int downRow;
            int leftCol;
            int rightCol;

            if (position.Row > 0)
            {
                upRow = position.Row - 1;
            }
            else
            {
                upRow = position.Row;
            }

            if (position.Row < matrix.GetLength(0) - 1)
            {
                downRow = position.Row + 1;
            }
            else
            {
                downRow = position.Row;
            }

            if (position.Col < matrix.GetLength(1) - 1)
            {
                rightCol = position.Col + 1;
            }
            else
            {
                rightCol = position.Col;
            }

            if (position.Col > 0)
            {
                leftCol = position.Col - 1;
            }
            else
            {
                leftCol = position.Col;
            }

            for (int i = upRow; i <= downRow; i++)
            {
                for (int j = leftCol; j <= rightCol; j++)
                {
                    if (matrix[i, j] == 0)
                    {
                        return false;
                    }
                }
            }

            return true;
        }
Esempio n. 3
0
        public bool CanWalkToPosition(Position position)
        {
            for (int i = 0; i < steps.Length; i++)
            {
                if (this.CheckIfPositionIsValid(position.Row + steps[i].Vertical, position.Column + steps[i].Horizontal))
                {
                    return true;
                }
            }

            return false;
        }
        public static void RotateWalkInMatrix(int[,] matrix)
        {
            Position currentPosition = StartPosition;
            int currentDirection = 0;

            for (int step = 1; step <= matrix.GetLength(0) * matrix.GetLength(1); step++)
            {
                matrix[currentPosition.Y, currentPosition.X] = step;

                Position? newPosition = null;
                int newDirection = currentDirection;

                // Check all 8 directions
                for (int i = 0; i < Directions.Length; i++, newDirection++)
                {
                    if (newDirection == Directions.Length)
                    {
                        newDirection = 0;
                    }

                    int nextYPos = currentPosition.Y + Directions[newDirection].Y;
                    int nextXPos = currentPosition.X + Directions[newDirection].X;
                    bool canMoveTo =
                        nextYPos >= 0 && nextYPos < matrix.GetLength(0) &&
                        nextXPos >= 0 && nextXPos < matrix.GetLength(1) &&
                        matrix[nextYPos, nextXPos] == 0;

                    if (canMoveTo)
                    {
                        newPosition = new Position(nextYPos, nextXPos);
                        currentDirection = newDirection;
                        break;
                    }
                }

                if (!newPosition.HasValue)
                {
                    var mostTopLeftEmptyCell = FindMostTopLeftEmptyCell(matrix);
                    if (mostTopLeftEmptyCell.HasValue)
                    {
                        currentPosition = mostTopLeftEmptyCell.Value;
                        currentDirection = 0;
                    }
                }
                else
                {
                    currentPosition = newPosition.Value;
                }
            }
        }
Esempio n. 5
0
        public void FillMatrix()
        {
            Position position = this.matrix.FindFirstEmptyCell();
            Direction direction = Direction.DownRight;
            int rowMove = RotatingWalkUtils.ChangeByRow[(int)direction];
            int colMove = RotatingWalkUtils.ChangeByColumn[(int)direction];
            int cellValue = 1;

            while (cellValue <= this.Rows * this.Cols)
            {
                this.matrix[position.Row, position.Col] = cellValue;
                Position nextPosition = new Position(position.Row + rowMove, position.Col + colMove);

                if (!this.matrix.CanGoToPosition(nextPosition))
                {
                    bool areNeighbourCellsFilled = false;

                    if (this.matrix.AreNeighbourCellsFilled(position))
                    {
                        areNeighbourCellsFilled = true;

                        position = this.matrix.FindFirstEmptyCell();
                        if (position == null)
                        {
                            break;
                        }

                        direction = Direction.DownRight;
                    }
                    else
                    {
                        Position newPosition = new Position(position.Row, position.Col);
                        direction = this.matrix.FindNewPosition(direction, newPosition);
                    }

                    rowMove = RotatingWalkUtils.ChangeByRow[(int)direction];
                    colMove = RotatingWalkUtils.ChangeByColumn[(int)direction];

                    if (areNeighbourCellsFilled)
                    {
                        cellValue += 1;
                        continue;
                    }
                }

                position.Row += rowMove;
                position.Col += colMove;
                cellValue += 1;
            }
        }
Esempio n. 6
0
        public bool FindAvailablePosition(out Position position)
        {
            position = new Position(0, 0);

            for (int row = 0; row < this.matrix.GetLength(0); row++)
            {
                for (int column = 0; column < this.matrix.GetLength(1); column++)
                {
                    if (this.matrix[row, column] == 0)
                    {
                        position.Row = row;
                        position.Column = column;
                        return true;
                    }
                }
            }

            return false;
        }
Esempio n. 7
0
        public static int[,] FillMatrix(int n)
        {
            int[,] matrix = new int[n, n];
            Position position = new Position(0, 0);
            int value = 1, currentDirectionX = 1, currentDirectionY = 1;

            while (value <= n * n)
            {
                matrix[position.Row, position.Col] = value;
                if (!IsFreeCellExists(matrix, position.Row, position.Col))
                {
                    value++;

                    if (value > n * n)
                    {
                        break;
                    }

                    FindEmptyCellCoordinates(matrix, position);
                    matrix[position.Row, position.Col] = value;
                    currentDirectionX = 1;
                    currentDirectionY = 1;
                }

                while (IsPositionOutOfMatrix(n, position.Row, currentDirectionX) ||
                        IsPositionOutOfMatrix(n, position.Col, currentDirectionY) ||
                         matrix[position.Row + currentDirectionX, position.Col + currentDirectionY] != 0)
                {
                    ChangeDirection(ref currentDirectionX, ref currentDirectionY);
                }

                position.Update(currentDirectionX, currentDirectionY);
                value++;
            }

            return matrix;
        }
Esempio n. 8
0
        public static Direction FindNewPosition(this int[,] matrix, Direction direction, Position position)
        {
            for (int i = 0; i < DirectionCount; i++)
            {
                Direction currDirection = (Direction)(((int)direction + i) % DirectionCount);
                int currRow = position.Row + ChangeByRow[(int)currDirection];
                int currCol = position.Col + ChangeByColumn[(int)currDirection];
                Position newPosition = new Position(currRow, currCol);

                if (CanGoToPosition(matrix, newPosition))
                {
                    return currDirection;
                }
            }

            throw new InvalidOperationException("Matrix is already filled.");
        }
Esempio n. 9
0
        public void RotatingWalk()
        {
            this.Clear();

            int count = 1;
            Position position = new Position(0, 0);
            Walk walk = new Walk(Directions.SE);

            while (true)
            {
                this.matrix[position.Row, position.Column] = count;

                if (!this.CanWalkToPosition(position))
                {
                    bool positionAvailable = this.FindAvailablePosition(out position);
                    if (positionAvailable)
                    {
                        count++;
                        this.matrix[position.Row, position.Column] = count;
                        walk.Direction = Directions.SE;
                    }
                    else
                    {
                        break;
                    }
                }

                while (!this.CheckIfPositionIsValid(position.Row + walk.Vertical, position.Column + walk.Horizontal))
                {
                    walk.ChangeDirection();
                }

                position.UpdatePosition(walk);
                count++;
            }
        }
Esempio n. 10
0
        private static void FindEmptyCellCoordinates(int[,] matrix, Position position)
        {
            position.Row = 0;
            position.Col = 0;

            for (int row = 0; row < matrix.GetLength(0); row++)
            {
                for (int col = 0; col < matrix.GetLength(1); col++)
                {
                    // if the cell is free
                    if (matrix[row, col] == 0)
                    {
                        position.Row = row;
                        position.Col = col;
                        return;
                    }
                }
            }
        }