Професионална програма
Loading...
+ Нов въпрос
Milko123 avatar Milko123 6 Точки

10. Radioactive Mutant Vampire Bunnies - Multidimensional Arrays - Exercise

Здравейте,

На задача https://judge.softuni.bg/Contests/Practice/Index/1455#9 с решение https://pastebin.com/bCygjASy Judge ми дава 80/100. Ще се радвам ако някой може да обърне внимание на моя код (разглеждал съм и други решения, но се интерсувам от моята грешка). Благодаря предварително.

Тагове:
0
C# Advanced
Axiomatik avatar Axiomatik 49 Точки
Best Answer

Rewrote your code, now it gives 100%:

 

using System;
using System.Linq;
using System.Collections.Generic;

namespace _10_Radio_Active_Mutant_Vampire_Bunnies
{
    class Program
    {
        static char[,] matrix;
        static void Main(string[] args)
        {
            var input = Console.ReadLine()
                .Split(" ", StringSplitOptions.RemoveEmptyEntries)
                .Select(int.Parse)
                .ToArray();

            matrix = new char[input[0], input[1]];

            int rowCheck = 0;
            int colCheck = 0;


            MatrixCreate(ref rowCheck, ref colCheck);

            char[] moves = Console.ReadLine()
                .ToCharArray();

            bool isSuccessMove = false;
            bool isLive = true;

            for (int i = 0; i < moves.Length; i++)
            {
                matrix[rowCheck, colCheck] = '.';

                isSuccessMove = false;

                if (moves[i] == 'R')
                {
                    if (IsValid(rowCheck, colCheck + 1) == true)
                    {
                        if (matrix[rowCheck, colCheck + 1] == '.')
                        {
                            isSuccessMove = true;
                        }
                        else if (matrix[rowCheck, colCheck + 1] == 'B')
                        {
                            isLive = false;
                            isSuccessMove = true;
                        }
                        colCheck = colCheck + 1;
                    }
                }
                else if (moves[i] == 'L')
                {
                    if (IsValid(rowCheck, colCheck - 1) == true)
                    {
                        if (matrix[rowCheck, colCheck - 1] == '.')
                        {
                            isSuccessMove = true;
                        }
                        else if (matrix[rowCheck, colCheck - 1] == 'B')
                        {
                            isLive = false;
                            isSuccessMove = true;
                        }
                        colCheck = colCheck - 1;
                    }
                }
                else if (moves[i] == 'U')
                {
                    if (IsValid(rowCheck - 1, colCheck) == true)
                    {
                        if (matrix[rowCheck - 1, colCheck] == '.')
                        {
                            isSuccessMove = true;
                        }
                        else if (matrix[rowCheck - 1, colCheck] == 'B')
                        {
                            isLive = false;
                            isSuccessMove = true;
                        }
                        rowCheck = rowCheck - 1;
                    }
                }
                else if (moves[i] == 'D')
                {
                    if (IsValid(rowCheck + 1, colCheck) == true)
                    {
                        if (matrix[rowCheck + 1, colCheck] == '.')
                        {
                            isSuccessMove = true;
                        }
                        else if (matrix[rowCheck, colCheck + 1] == 'B')
                        {
                            isLive = false;
                            isSuccessMove = true;
                        }
                        rowCheck = rowCheck + 1;
                    }
                }


                if (isLive == false)
                {
                    BonneyMoves();
                    MatrixPrint();
                    Console.WriteLine($"dead: {rowCheck} {colCheck}");
                    break;
                }
                else if (isSuccessMove == false)
                {
                    BonneyMoves();
                    MatrixPrint();
                    Console.WriteLine($"won: {rowCheck} {colCheck}");
                    break;
                }

                else
                {
                    matrix[rowCheck, colCheck] = 'P';
                    isLive = false;
                    BonneyMoves();

                    isLive = CheckLive(isLive);

                    if (isLive == false)
                    {
                        MatrixPrint();
                        Console.WriteLine($"dead: {rowCheck} {colCheck}");
                        return;
                    }
                }

            }
        }

        private static bool CheckLive(bool isLive)
        {
            foreach (var items in matrix)
            {
                if (items == 'P')
                {
                    isLive = true;
                }
            }

            return isLive;
        }

        private static void MatrixCreate(ref int rowCheck, ref int colCheck)
        {
            for (int row = 0; row < matrix.GetLength(0); row++)
            {
                string currentRow = Console.ReadLine();
                for (int col = 0; col < matrix.GetLength(1); col++)
                {
                    matrix[row, col] = currentRow[col];
                    if (currentRow[col] == 'P')
                    {
                        rowCheck = row;
                        colCheck = col;
                    }

                }
            }
        }

        private static bool IsValid(int rowCheck, int colCheck)
        {
            if ((rowCheck >= 0 && rowCheck < matrix.GetLength(0)) && (colCheck >= 0 && colCheck < matrix.GetLength(1)))
            {
                return true;
            }
                return false;
        }

        private static void MatrixPrint()
        {
            for (int row = 0; row < matrix.GetLength(0); row++)
            {
                for (int col = 0; col < matrix.GetLength(1); col++)
                {
                    Console.Write(matrix[row, col]);
                }
                Console.WriteLine();
            }
        }

        private static void BonneyMoves()
        {
            var indexBunnies = new Dictionary<int, List<int>>();
            int count = 0;

            for (int row = 0; row < matrix.GetLength(0); row++)
            {
                for (int col = 0; col < matrix.GetLength(1); col++)
                {
                    if (matrix[row, col] == 'B')
                    {
                        indexBunnies.Add(count, new List<int>());
                        indexBunnies[count].Add(row);
                        indexBunnies[count].Add(col);
                        count++;
                    }
                }
            }

            for (int i = 0; i < indexBunnies.Count; i++)
            {
                int row = indexBunnies[i][0];
                int col = indexBunnies[i][1];


                if (IsValid(row - 1, col) == true)
                {
                    matrix[row - 1, col] = 'B';
                }
                if (IsValid(row + 1, col) == true)
                {
                    matrix[row + 1, col] = 'B';
                }
                if (IsValid(row, col - 1) == true)
                {
                    matrix[row, col - 1] = 'B';
                }
                if (IsValid(row, col + 1) == true)
                {
                    matrix[row, col + 1] = 'B';
                }
            }
            indexBunnies.Clear();
        }
    }
}

1
Milko123 avatar Milko123 6 Точки

 

Тhank you very much for your attention!

0
Axiomatik avatar Axiomatik 49 Точки

Line 32, 52, 72, 92

  • After index-validation, you only check if( field == '.'), but not whether the player steps unto a bunny and gets eliminated. There is no check for :

    if(matrix[rowCheck + 1, colCheck] == 'B')

    {playerDead == true}

0
ivan_enchev avatar ivan_enchev 0 Точки

Hi Axiomatik,

Could you please try to find also my fault? 

https://pastebin.com/p7Nm0dfk

80/100

Test #4 (Incorrect answer)

Test #8 (Incorrect answer)

Thank you very much!

BR,

Ivan 

0
Axiomatik avatar Axiomatik 49 Точки

OK, I'll take a look at it today.

0
Axiomatik avatar Axiomatik 49 Точки

Two problems in your code: 

1. MultiplyBunny has to be moved from line 45 to 162. In the assignment, it says that first the player moves, then the bunnies multiply.

2. After line 169 (when the bunnies have multiplied, there is no check whether they have eaten up the player).

I've included the changes and now it gives 100%

Best,

using System;
using System.Collections.Generic;
using System.Linq;

namespace bunniesMay
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] size = Console.ReadLine().Split(' ', StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToArray();
            int rows = size[0];
            int cols = size[1];

            int playerRow = -1;
            int playerCol = -1;

            char[,] playGraund = new char[rows, cols];

            for (int row = 0; row < rows; row++)
            {
                char[] input = Console.ReadLine().ToCharArray();

                for (int col = 0; col < cols; col++)
                {
                    playGraund[row, col] = input[col];

                    if (playGraund[row, col] == 'P')
                    {
                        playerRow = row;
                        playerCol = col;
                    }
                }
            }

            char[] cmd = Console.ReadLine().ToArray();
            Queue<int[]> bunniesIndexes = new Queue<int[]>();

            for (int c = 0; c < cmd.Length; c++)
            {
                BunniesFinder(rows, cols, playGraund, bunniesIndexes);
                bool won = false;
                char currMove = cmd[c];

                //MultiplyBunny(rows, cols, playGraund, bunniesIndexes);

                if (currMove == 'U')
                {
                    if (playerRow - 1 >= 0)
                    {
                        if (playGraund[playerRow - 1, playerCol] == '.')
                        {
                            playGraund[playerRow, playerCol] = '.';
                            playGraund[playerRow - 1, playerCol] = 'P';
                            playerRow -= 1;
                        }

                        else
                        {
                            if (playGraund[playerRow, playerCol] != 'B')
                            {
                                playGraund[playerRow, playerCol] = '.';
                            }
                            MultiplyBunny(rows, cols, playGraund, bunniesIndexes);
                            PrintPlayground(rows, cols, playGraund);
                            Console.WriteLine($"dead: {playerRow - 1} {playerCol}");
                            break;
                        }
                    }

                    else
                    {
                        if (playGraund[playerRow, playerCol] != 'B')
                        {
                            playGraund[playerRow, playerCol] = '.';
                        }
                        won = true;
                    }
                }

                else if (currMove == 'D')
                {
                    if (playerRow + 1 < rows)
                    {
                        if (playGraund[playerRow + 1, playerCol] == '.')
                        {
                            playGraund[playerRow, playerCol] = '.';
                            playGraund[playerRow + 1, playerCol] = 'P';
                            playerRow += 1;
                        }

                        else
                        {
                            if (playGraund[playerRow, playerCol] != 'B')
                            {
                                playGraund[playerRow, playerCol] = '.';
                            }
                            MultiplyBunny(rows, cols, playGraund, bunniesIndexes);
                            PrintPlayground(rows, cols, playGraund);
                            Console.WriteLine($"dead: {playerRow + 1} {playerCol}");
                            break;
                        }
                    }

                    else
                    {
                        if (playGraund[playerRow, playerCol] != 'B')
                        {
                            playGraund[playerRow, playerCol] = '.';
                        }
                        won = true;
                    }
                }

                else if (currMove == 'L')
                {
                    if (playerCol - 1 >= 0)
                    {
                        if (playGraund[playerRow, playerCol - 1] == '.')
                        {
                            playGraund[playerRow, playerCol] = '.';
                            playGraund[playerRow, playerCol - 1] = 'P';
                            playerCol -= 1;
                        }

                        else
                        {
                            if (playGraund[playerRow, playerCol] != 'B')
                            {
                                playGraund[playerRow, playerCol] = '.';
                            }
                            
                            MultiplyBunny(rows, cols, playGraund, bunniesIndexes);
                            PrintPlayground(rows, cols, playGraund);
                            Console.WriteLine($"dead: {playerRow} {playerCol - 1}");
                            break;
                        }
                    }

                    else
                    {
                        if (playGraund[playerRow, playerCol] != 'B')
                        {
                            playGraund[playerRow, playerCol] = '.';
                        }
                        won = true;
                    }
                }

                else if (currMove == 'R')
                {
                    if (playerCol + 1 < cols)
                    {
                        if (playGraund[playerRow, playerCol + 1] == '.')
                        {
                            playGraund[playerRow, playerCol] = '.';
                            playGraund[playerRow, playerCol + 1] = 'P';
                            playerCol += 1;
                        }

                        else
                        {
                            if (playGraund[playerRow, playerCol] != 'B')
                            {
                                playGraund[playerRow, playerCol] = '.';
                            }
                            MultiplyBunny(rows, cols, playGraund, bunniesIndexes);
                            PrintPlayground(rows, cols, playGraund);
                            Console.WriteLine($"dead: {playerRow} {playerCol + 1}");
                            break;
                        }
                    }

                    else
                    {
                        if (playGraund[playerRow, playerCol] != 'B')
                        {
                            playGraund[playerRow, playerCol] = '.';
                        }
                        won = true;
                    }
                }

                MultiplyBunny(rows, cols, playGraund, bunniesIndexes);

                if (won)
                {
                    PrintPlayground(rows, cols, playGraund);

                    Console.WriteLine($"won: {playerRow} {playerCol}");
                    break;
                }

                bool alivePlayer = CheckLive(playGraund);

                if (alivePlayer == false)
                {
                    PrintPlayground(rows, cols, playGraund);
                    Console.WriteLine($"dead: {playerRow} {playerCol}");
                    break;
                }
            }
        }

        static bool CheckLive(char[,] playGraund)
        {
            foreach (var items in playGraund)
            {
                if (items == 'P')
                {
                    return true;
                }
            }

            return false;
        }

        static void MultiplyBunny(int rows, int cols, char[,] playGraund, Queue<int[]> bunniesIndexes)
        {
            while (bunniesIndexes.Count != 0)
            {
                int[] currBunny = bunniesIndexes.Dequeue();
                int row = currBunny[0];
                int col = currBunny[1];

                if (row - 1 >= 0)
                {
                    playGraund[row - 1, col] = 'B';
                }

                if (row + 1 < rows)
                {
                    playGraund[row + 1, col] = 'B';
                }

                if (col - 1 >= 0)
                {
                    playGraund[row, col - 1] = 'B';
                }

                if (col + 1 < cols)
                {
                    playGraund[row, col + 1] = 'B';
                }
            }
        }

        static void PrintPlayground(int rows, int cols, char[,] playGraund)
        {
            for (int row = 0; row < rows; row++)
            {
                for (int col = 0; col < cols; col++)
                {
                    Console.Write(playGraund[row, col]);
                }
                Console.WriteLine();
            }
        }
        static void BunniesFinder(int rows, int cols, char[,] playGraund, Queue<int[]> bunniesIndexes)
        {
            for (int row = 0; row < rows; row++)
            {
                for (int col = 0; col < cols; col++)
                {
                    if (playGraund[row, col] == 'B')
                    {
                        bunniesIndexes.Enqueue(new int[] { row, col });
                    }
                }
            }
        }
    }
}
 

0