using System;

using System.Collections.Generic;

using System.Linq;

​

namespace TaskExam

{

    internal class TaskSolver

    {

        public static void Main(string[] args)

        {

            TestGetWordSubWords();

            TestFindPath();

            TestFormatPrettyCoins();

            FindMaxRect();

            Console.WriteLine("All Test completed!");

        }

        /// задание 1) Индекс слова

        public static List<int> GetWordSubWords(List<string> words, List<string> wordDictionary)

        {

            //код алгоритма

            List<int> answers = new List<int>();

​

            for (int i = 0; i < words.Count; i++)

            {

                var kol = 0;

                for (int j = 0; j < wordDictionary.Count; j++)

                {

                    var currentWord = words[i];

                    var isConform = true;

                    foreach (char c in wordDictionary[j])

                    {

                        if (currentWord.IndexOf(c) < 0)

                        {

                            isConform = false;

                            break;

                        }

                        else

                            currentWord = currentWord.Remove(currentWord.IndexOf(c),1);

                    }

                if (isConform) kol++;

                }

                answers.Add(kol);

            }

            return answers;

        }

        /// задание 2) Луноход

        public static int FindPath(int[][] gridMap, int sX, int sY, int eX, int eY, int energyAmount)

        {

            //код алгоритма

            var find = false;

            int mapWidth = gridMap.Length;

            int mapHeight = gridMap[0].Length;

            int[,] wayMap = new int[mapHeight, mapWidth];

            int x, y, step = 0;

            for (x = 0; x < mapHeight; x++)

                for (y = 0; y < mapWidth; y++)

                    if (gridMap[x][y] == 0)

                        wayMap[mapHeight - 1 - x, y] = -2;

                    else

                        wayMap[mapHeight - 1 - x, y] = -1;

            wayMap[sX, sY] = 0;

​

            while (find == false)

            {

                if (step > mapWidth * mapHeight)

                    break;

                for (x = 0; x < mapHeight; x++)

                    for (y = 0; y < mapWidth; y++)

                    {

                        if (wayMap[x, y] == step)

                        {

                            if (x + 1 < mapHeight && wayMap[x + 1, y] == -1)

                                wayMap[x + 1, y] = step + 1;

                            if (y + 1 < mapWidth && wayMap[x, y + 1] == -1)

                                wayMap[x, y + 1] = step + 1;

                            if (x - 1 > 0 && wayMap[x - 1, y] == -1)

                                wayMap[x - 1, y] = step + 1;

                            if (y - 1 > 0 && wayMap[x, y - 1] == -1)

                                wayMap[x, y - 1] = step + 1;

                            if (x == eX && y == eY)

                                find = true;

                        }

                    }

                step++;

            }

​

            if (find && wayMap[eX,eY] <= energyAmount) 

                return wayMap[eX,eY];

            else return -1;

        }

        /// задание 3) Монетки

        public static string FormatPrettyCoins(long value, char separator)

        {

            //код алгоритма

            var digitsReplace = false;

            string valueStr = value.ToString();

            if (valueStr.Length >= 6 && valueStr.Length < 8)

            {

                valueStr = valueStr.Substring(0, valueStr.Length - 3) + 'K';

                digitsReplace = true;

​

            }

            else if (valueStr.Length >=8)

            {

                valueStr = valueStr.Substring(0, valueStr.Length - 6) + 'M';

                digitsReplace = true;

            }

            if (valueStr.Length >= 4 && !digitsReplace)

                valueStr = valueStr.Insert(valueStr.Length - 3, separator.ToString());

            else if (valueStr.Length >= 4 && digitsReplace)

                valueStr = valueStr.Insert(valueStr.Length - 4, separator.ToString());

            return valueStr;

        }

​

        /// задание 4) Самый большой прямоугольник на гистограмме

        public static int FindMaxRect(List<int> heights)

        {

            //algorithm

            var maxArea = 0;

            int currentArea;

            foreach (var currentHeight in heights)

            {

                var maxSequence = 0;

                var currentSequence = 0;

                for (int i = 0; i < heights.Count; i++)

                {

                    if (heights[i] >= currentHeight)

                    {

                        currentSequence++;

                    }

                    else

                    {

                        if (currentSequence > maxSequence)

                            maxSequence = currentSequence;

                        currentSequence = 0;

                    }

                }

                if (currentSequence > maxSequence)

                    maxSequence = currentSequence;

                currentArea = currentHeight * maxSequence;

                if (currentArea > maxArea)

                    maxArea = currentArea;

            }

            return maxArea;

        }

​

        /// Тесты (можно/нужно добавлять свои тесты) 

        private static void TestGetWordSubWords()

        {

            var wordsList = new List<string>

            {

                "кот", "ток", "око", "мимо", "гром", "ром", 

                "рог", "морг", "огр", "мор", "порог"

            };

            AssertSequenceEqual( GetWordSubWords(new List<string>{"кот"}, wordsList), new []{2} );

            AssertSequenceEqual( GetWordSubWords(new List<string>{"мама"}, wordsList), new []{0} );

            AssertSequenceEqual( GetWordSubWords(new List<string>{"погром", "гром"}, wordsList), new []{7, 6} );

            AssertSequenceEqual(GetWordSubWords(new List<string>{"рогатка", "море", "open my game"}, wordsList), new[] { 4, 2, 0} );

        }

        private static void TestFindPath()

        {

            int[][] gridA =

            {

                new[] {1, 1, 1, 0, 1, 1},

                new[] {1, 1, 1, 0, 1, 1},

                new[] {1, 1, 1, 0, 0, 0},

                new[] {1, 1, 1, 1, 1, 1},

                new[] {1, 1, 1, 1, 1, 1},

                new[] {1, 1, 1, 1, 1, 1},

            };

            AssertEqual(FindPath(gridA, 0,0,2, 2, 5), 4);

            AssertEqual(FindPath(gridA, 0,0,5, 5, 30), -1);

            AssertEqual(FindPath(gridA, 0,0,0, 5, 3), -1);

            AssertEqual(FindPath(gridA, 5, 5, 0, 0, 3), -1);

        }

        private static void TestFormatPrettyCoins()

        {

            AssertEqual(FormatPrettyCoins(10, ' '), "10");

            AssertEqual(FormatPrettyCoins(1233, ' '), "1 233");

            AssertEqual(FormatPrettyCoins(1717310, ' '), "1 717K");

            AssertEqual(FormatPrettyCoins(7172343310, ' '), "7 172M");

        }

        private static void FindMaxRect()

        {

            AssertEqual(FindMaxRect(new List<int>{1, 2, 3, 4, 4, 4, 5, 4, 6}), 24);

            AssertEqual(FindMaxRect(new List<int>{1, 2, 3, 5, 5, 4, 2, 4, 6}), 16);

            AssertEqual(FindMaxRect(new List<int>{8, 9, 3, 5, 5, 2, 3, 4, 6, 1, 6}), 18);

        }

        /// Тестирующая система, лучше не трогать этот код

        private static void Assert(bool value)

        {

            if (value)

            {

                return;

            }

​

            throw new Exception("Assertion failed");

        }

​

        private static void AssertEqual(object value, object expectedValue)

        {

            if (value.Equals(expectedValue))

            {

                return;

            }

​

            throw new Exception($"Assertion failed expected = {expectedValue} actual = {value}");

        }

​

        private static void AssertSequenceEqual<T>(IEnumerable<T> value, IEnumerable<T> expectedValue)

        {

            if (ReferenceEquals(value, expectedValue))

            {

                return;

            }

            if (value is null)

            {

                throw new ArgumentNullException(nameof(value));

            }

            if (expectedValue is null)

            {

                throw new ArgumentNullException(nameof(expectedValue));

            }

​

            var valueList = value.ToList();

            var expectedValueList = expectedValue.ToList();

            if (valueList.Count != expectedValueList.Count)

            {

                throw new Exception($"Assertion failed expected count = {expectedValueList.Count} actual count = {valueList.Count}");

            }

​

            for (var i = 0; i < valueList.Count; i++)

            {

                if (!valueList[i].Equals(expectedValueList[i]))

                {

                    throw new Exception($"Assertion failed expected value at {i} = {expectedValueList[i]} actual = {valueList[i]}");

                }

            }

        }

​

    }

}