Проблем със задача 9. Miner

Във форума е въведено ограничение, което позволява на потребителите единствено да разглеждат публикуваните въпроси.

Stoianilliev 1 Точки

Проблем със задача 9. Miner

Здравейте, имам проблем с горепосочената задача, условието на която се намира тук:

https://softuni.bg/trainings/resources/officedocument/49688/exercise-csharp-advanced-may-2020/2834

Проблемът е следният:

Инпута представлява размер на матрицата, команди и самата char матрица. Обаче тя е изписана с разстояния между отделните символи, които моята програма чете, и не взима цялата матрица. На първия пример взима това:

5
up right right up right
* * * c *
* * * e *
* * c * *
s * * c *
* * c * *

И ако проверя как се е запаметила матрицата, се оказва че се е запаметило това:

* * *
* * *
* * c
s * *
* * c

Тоест е взело само първите 5 символа(включително спейсовете).

Въпросът ми е как мога да си преправя кода така че да не брой празните места в char array-a?

Кодът ми в които съм оградил с коментари къде е проблема: https://pastebin.com/jQNJ74xr

Благодаря предварително!

Тагове:

01/06/2020 19:37:48 C# Advanced

MartinBG 4803 Точки

Best Answer

Използването на Multidimensional Array (char[,]) в тази задача само усложнява ненужно парсването и извеждането ѝ в конзолата.

Тези две операции са много по-лесни, ако се използва Jagged Array (char[][]):

            // Parse from Console
            var matrix = new char[n][];
            for (var row = 0; row < n; row++)
            {
                matrix[row] = Console.ReadLine()
                    .Split(' ', StringSplitOptions.RemoveEmptyEntries)
                    .Select(c => c[0])
                    .ToArray();
            }

            // Print back to Console
            foreach (var row in matrix)
            {
                Console.WriteLine(string.Join(' ', row));
            }

Работа Jagged Array: matrix[row][col] вместо matrix[row, col]

01/06/2020 23:27:49

nickwork 657 Точки

Вариант => когато четеш реда за запълване на матрицата през конзолата можеш допълнително да го сплитваш за спейсове и по този начин да ти останат само чаровете, другият вариант е да я обхождаш със спейсовете като при проверките няма да проверяваш, на пример row +1, a row +2 за да не попадаш спейсове. При първият вариант до колкото се сещам ще се наложи накрая да я преформатираш и да вършен спейсовете в нея при финалното принтиране за правилен изход.

01/06/2020 20:07:38

Elena123456 235 Точки

Здравейте,

решението ми е валидно, но може ли помощ за подобряване на четимостта му? Имам ужасно много повтарящ се код, но за първи път не успявам да го екстрактна в методи. Предполагам, че това се дължи на наличието на "return" и "break" в кода. Успях само четенето на матрицата и принтирането на резултата да ги изнеса в методи, но за жалост само тях. Осъзнавам, че в такова състояние не мога да си кача решението в github.

https://pastebin.com/a6w0vHcL

27/12/2020 23:38:42 27/12/2020 23:41:22

dZf1aeA-hardyyp 2 Точки

I just want you to know that I’m deeply grateful for your amazing post! Thanks for the kindness in sharing your expertise to us. visit our website amazon.com/mytv

28/12/2020 08:50:30

Axiomatik 2422 Точки

You just had to remove the break; command in the individual movement validations and then the automatic method-extractor was working again (taking care of all the needed variables for the new methods). Hope this helps.

Best,

using System;
using System.Linq;

namespace Miner
{
    class Program
    {
        static void Main(string[] args)
        {
            int rows = int.Parse(Console.ReadLine());
            int cols = rows;
            string[] commandArray = Console.ReadLine().Split().ToArray();
            char[,] matrix = new char[rows, cols];
            ReadTheMatrix(rows, cols, matrix);

            int rowStart = 0;
            int colStart = 0;
            bool foundStart = false;
            for (int row = 0; row < rows; row++) // validate the matrix
            {
                for (int col = 0; col < cols; col++)
                {
                    if (matrix[row, col] != '*'
                        && matrix[row, col] != 'e'
                        && matrix[row, col] != 'c'
                        && matrix[row, col] != 's')
                    {
                        return;
                    }

                    else if (matrix[row, col] == 's' && foundStart == false)
                    {
                        rowStart = row;
                        colStart = col;
                        foundStart = true;
                    }

                    else if (foundStart == true && matrix[row, col] == 's')
                    {
                        return;
                    }
                }
            }

            char start = matrix[rowStart, colStart];
            int currentRow = 0;
            int currentCol = 0;
            bool theEndOfTheRoad = false;
            for (int i = 0; i < commandArray.Length; i++)
            {
                string direction = commandArray[i];

                if (direction == "up") // command is Up
                {
                    if (rowStart - 1 >= 0)
                    {
                        MoveUp(matrix, ref rowStart, ref colStart, out currentRow, out currentCol, ref theEndOfTheRoad);
                    }
                }

                else if (direction == "down") // command is Down
                {
                    if (rowStart + 1 <= rows - 1)
                    {
                        MoveDown(matrix, ref rowStart, ref colStart, out currentRow, out currentCol, ref theEndOfTheRoad);
                    }
                }

                else if (direction == "left") // command is Left
                {
                    if (colStart - 1 >= 0)
                    {
                        MoveLeft(matrix, ref rowStart, ref colStart, out currentRow, out currentCol, ref theEndOfTheRoad);
                    }
                }

                else if (direction == "right") // command is Right
                {
                    if (colStart + 1 < cols)
                    {
                        MoveRight(matrix, ref rowStart, ref colStart, out currentRow, out currentCol, ref theEndOfTheRoad);
                    }
                }

                if (theEndOfTheRoad)
                {
                    break;
                }
            }

            PrintTheResult(matrix, currentRow, currentCol, theEndOfTheRoad);
        }

        private static bool CheckRoad(char[,] matrix, int currentRow, int currentCol, bool theEndOfTheRoad)
        {
            if (matrix[currentRow, currentCol] == 'c')
            {
                matrix[currentRow, currentCol] = '*';
            }

            else if (matrix[currentRow, currentCol] == 'e')
            {
                theEndOfTheRoad = true;
                //break;
            }

            return theEndOfTheRoad;
        }

        private static void MoveUp(char[,] matrix, ref int rowStart, ref int colStart, out int currentRow, out int currentCol, ref bool theEndOfTheRoad)
        {
            currentRow = rowStart - 1;
            currentCol = colStart;

            theEndOfTheRoad = CheckRoad(matrix, currentRow, currentCol, theEndOfTheRoad);

            rowStart = currentRow;
            colStart = currentCol;
        }


        private static void MoveDown(char[,] matrix, ref int rowStart, ref int colStart, out int currentRow, out int currentCol, ref bool theEndOfTheRoad)
        {
            currentRow = rowStart + 1;
            currentCol = colStart;

            theEndOfTheRoad = CheckRoad(matrix, currentRow, currentCol, theEndOfTheRoad);

            rowStart = currentRow;
            colStart = currentCol;
        }

        private static void MoveRight(char[,] matrix, ref int rowStart, ref int colStart, out int currentRow, out int currentCol, ref bool theEndOfTheRoad)
        {
            currentRow = rowStart;
            currentCol = colStart + 1;

            theEndOfTheRoad = CheckRoad(matrix, currentRow, currentCol, theEndOfTheRoad);

            rowStart = currentRow;
            colStart = currentCol;
        }

        private static void MoveLeft(char[,] matrix, ref int rowStart, ref int colStart, out int currentRow, out int currentCol, ref bool theEndOfTheRoad)
        {
            currentRow = rowStart;
            currentCol = colStart - 1;

            theEndOfTheRoad = CheckRoad(matrix, currentRow, currentCol, theEndOfTheRoad);

            rowStart = currentRow;
            colStart = currentCol;
        }

        private static void PrintTheResult(char[,] matrix, int currentRow, int currentCol, bool theEndOfTheRoad)
        {
            if (theEndOfTheRoad == true)
            {
                Console.WriteLine($"Game over! ({currentRow}, {currentCol})");
            }

            else
            {
                int countCoals = 0;
                foreach (var cell in matrix)
                {
                    if (cell == 'c')
                    {
                        countCoals++;
                    }
                }

                if (countCoals == 0)
                {
                    Console.WriteLine($"You collected all coals! ({currentRow}, {currentCol})");
                }

                else if (countCoals > 0)
                {
                    Console.WriteLine($"{countCoals} coals left. ({currentRow}, {currentCol})");
                }
            }
        }

        private static void ReadTheMatrix(int rows, int cols, char[,] matrix)
        {
            for (int row = 0; row < rows; row++)
            {
                char[] currentLine = Console.ReadLine().Split().Select(char.Parse).ToArray();
                for (int col = 0; col < cols; col++)
                {
                    matrix[row, col] = currentLine[col];
                }
            }
        }
    }
}

28/12/2020 09:52:26

Покажи всички коментари