MyFirstTask

// Task
=====================================================================================================
Codenavirus
Assignment
Codenavirus is strange contagious disease. This is why:

One infected person will infect only one healthy person next to him each day
If a person is infected, he will infect the person on his right, unless the latter is already infected, then he will infect the person on his top instead, but if that person is also already infected, then he will infect the one on his left, lastly if this one is also already infected, the he will infect the one below if this one is still healthy. (The examples will clarify)
A newly infected person will start infecting other people one day after the infection.
An infected person will recover after exactly 3 days of illness, counting from the day he got infected, and he will become immune to the virus (he won't be infected anymore)
To help the WHO study this new virus, you must create a program that simulates the spread of the virus.

Inputs

world: a matrix of characters representing the proximity of people in a the world. A person is represented by "#" and empty spaces are represented by ".". One person is next to another one if they share the same row OR the same column and there is no empty space or another person between them.
firstInfected: an array of integer of size 2 ([row, col]) storing the coordinates of the first person to contract the virus on day 1.
Output
An array of 4 integers [a, b, c, d] where:

a : number of days until the virus stops spreading
b : number of infected people at the end of the spread
c : number of recovered people at the end
d : number of uninfected people
Prioritize lower indexes if there is a case where one person is about to be infected by two neighbors, in that case the neighbor with lower row/col will win (Eg. Day 3 of test 4).

Example

For
world = [["#","#","#"],
         ["#","#","#"],
         ["#","#","#"]]
and firstInfected = [1, 1], the answer is [7, 3, 6, 0]
Explanation: H for healthy, I for infected, R for recovered

DAY 0:
[
["H", "H", "H"],
["H", "H", "H"],
["H", "H", "H"],
]
DAY 1:
[
["H", "H", "H"],
["H", "I", "H"],
["H", "H", "H"],
]
DAY 2:
[
["H", "H", "H"],
["H", "I", "I"],
["H", "H", "H"],
]
DAY 3:
[
["H", "I", "I"],
["H", "I", "I"],
["H", "H", "H"],
]
DAY 4:
[
["I", "I", "I"],
["H", "R", "I"],
["H", "H", "I"],
]
DAY 5:
[
["I", "I", "I"],
["I", "R", "R"],
["H", "I", "I"],
]
DAY 6:
[
["I", "R", "R"],
["I", "R", "R"],
["I", "I", "I"],
]
DAY 7:
[
["R", "R", "R"],
["I", "R", "R"],
["I", "I", "R"],
]
[input] array.array.char world

[input] array.integer firstInfected

[output] array.integer


Deliverables
a single .cs file
the file must contain the following method signature, otherwise your submission is considered invalid
int[] Codenavirus (char[][] world, int[] firstInfected) {

}
3. The application is tested automatically and global variables are forbidden.

================================================================================================================

// Solution
================================================================================================================

using System;

namespace Codenavirus
{
    public class Program
    {
        public static void Main(string[] args)
        {
            char[][] world = new char[][]
            {
                new char[] { '#', '#', '#' },
                new char[] { '#', '#', '#' },
                new char[] { '#', '#', '#' },
            };

            int[] firstInfected = new int[2] { 1, 1 };

            var output = new Program();
            var results = output.Codenavirus(world, firstInfected);

            foreach (var score in results)
            {
                Console.WriteLine(score);
            }

        }

        public int[] Codenavirus(char[][] world, int[] firstInfected)
        {
            int[] populationHealthStatus = new int[4];
            int days = 0;
            int indexRow = firstInfected[0];
            int indexCol = firstInfected[1];
            const int indexRecover = 3;

            if (world[indexRow][indexCol] == '#')
            {
                world[indexRow][indexCol] = 'I';
                days++;

                int[][] worldStatusBoard = CreateHealthStatusBoard(world);

                worldStatusBoard[indexRow][indexCol] = indexRecover;

                Print(world);

                bool virusSpread = true;

                while (virusSpread == true)
                {
                    virusSpread = false;

                    RecoverInfectedPeople(world, worldStatusBoard);
                    SpreadCodenavirus(world, worldStatusBoard, ref virusSpread);
                    CureInfectedPeople(world, worldStatusBoard);
                    days++;
                    QuarantinePeople(world, worldStatusBoard, indexRecover);
                    Print(world);
                }

            }

            populationHealthStatus = ScoreHealthStatus(world, days);

            return populationHealthStatus;
        }

        private void QuarantinePeople(char[][] world, int[][] worldStatusBoard, int indexRecover)
        {
            for (int i = 0; i < world.Length; i++)
            {
                for (int j = 0; j < world[i].Length; j++)
                {
                    if (world[i][j] == 'I' && worldStatusBoard[i][j] == 0)
                    {
                        worldStatusBoard[i][j] = indexRecover;
                    }
                }
            }
        }

        private void CureInfectedPeople(char[][] world, int[][] worldStatusBoard)
        {
            for (int i = 0; i < world.Length; i++)
            {
                for (int j = 0; j < world[i].Length; j++)
                {
                    if (world[i][j] == 'I' && worldStatusBoard[i][j] != 0)
                    {
                        worldStatusBoard[i][j]--;
                    }
                }
            }
        }

        private void RecoverInfectedPeople(char[][] world, int[][] worldStatusBoard)
        {
            for (int i = 0; i < world.Length; i++)
            {
                for (int j = 0; j < world[i].Length; j++)
                {
                    if (world[i][j] == 'I' && worldStatusBoard[i][j] == 1)
                    {
                        world[i][j] = 'R';
                    }
                }
            }
        }

        private void Print(char[][] world)
        {
            for (int i = 0; i < world.Length; i++)
            {
                for (int j = 0; j < world[i].Length; j++)
                {
                    Console.Write($"{world[i][j]} ");
                }

                Console.WriteLine();
            }

            Console.WriteLine();
        }

        private int[][] CreateHealthStatusBoard(char[][] model)
        {
            int[][] board = new int[model.Length][];

            for (int i = 0; i < model.Length; i++)
            {
                board[i] = new int[model[i].Length];
            }

            return board;
        }

        private int[] ScoreHealthStatus(char[][] world, int days)
        {
            int infected = 0;
            int recovered = 0;
            int uninfected = 0;

            for (int i = 0; i < world.Length; i++)
            {
                for (int j = 0; j < world[i].Length; j++)
                {
                    switch (world[i][j])
                    {
                        case '#':
                            uninfected++;
                            break;
                        case 'I':
                            infected++;
                            break;
                        case 'R':
                            recovered++;
                            break;
                        default:
                            break;
                    }
                }
            }

            int[] healthStatusScore = new int[] { days, infected, recovered, uninfected };

            return healthStatusScore;
        }

        private void SpreadCodenavirus(char[][] world, int[][] worldStatusBoard, ref bool virusSpread)
        {
            for (int i = 0; i < world.Length; i++)
            {
                for (int j = 0; j < world[i].Length; j++)
                {
                    if (world[i][j] == 'I' && worldStatusBoard[i][j] != 0)
                    {
                        if (j + 1 < world[i].Length && world[i][j + 1] == '#')
                        {
                            world[i][j + 1] = 'I';
                            virusSpread = true;
                            continue;
                        }
                        else if (i - 1 >= 0 && j<world[i-1].Length && world[i - 1][j] == '#')
                        {
                            world[i - 1][j] = 'I';
                            virusSpread = true;
                            continue;
                        }
                        else if (j - 1 >= 0 && world[i][j - 1] == '#')
                        {
                            world[i][j - 1] = 'I';
                            virusSpread = true;
                            continue;
                        }
                        else if (i + 1 < world.Length && j < world[i + 1].Length && world[i + 1][j] == '#')
                        {
                            world[i + 1][j] = 'I';
                            virusSpread = true;
                            continue;
                        }
                    }

                }
            }

        }
    }
}
====================================================================================================================

// Result
====================================================================================================================

# # #
# # #
# # #

# # #
# I #
# # #

# # #
# I I
# # #

# I I
# I I
# # #

I I I
# R I
# # I

I I I
I R R
# I I

I R R
I R R
I I I

R R R
I R R
I I R

7
3
6
0