using System;

using System.Collections.Generic;

using System.Linq;

​

namespace TaskExam

{

    internal class TaskSolver

    {

        public static void Main(string[] args)

        {

            TestGenerateWordsFromWord();

            TestMaxLengthTwoChar();

            TestGetPreviousMaxDigital();

            TestSearchQueenOrHorse();

            TestCalculateMaxCoins();

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

        }

​

​

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

        public static List<string> GenerateWordsFromWord(string word, List<string> wordDictionary)

        {

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

            return new List<string>();

        }

        /// задание 2) Два уникальных символа

        public static int MaxLengthTwoChar(string word)

        {

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

            return 0;

        }

        /// задание 3) Предидущее число

        public static long GetPreviousMaxDigital(long value)

        {

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

            return -1;

        }

        /// задание 4) Конь и Королева

        public static List<int> SearchQueenOrHorse(char[][] gridMap)

        {

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

            return new List<int>{-1, -1};

        }

        /// задание 5) Жадина

        public static long CalculateMaxCoins(int[][] mapData, int idStart, int idFinish)

        {

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

            return -1;

        }

​

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

        private static void TestGenerateWordsFromWord()

        {

            var wordsList = new List<string>

            {

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

                "рог", "морг", "огр", "мор", "порог", "бра", "раб", "зубр"

            };

            AssertSequenceEqual( GenerateWordsFromWord("арбуз", wordsList), new []{ "бра", "зубр", "раб"} );

            AssertSequenceEqual( GenerateWordsFromWord("лист", wordsList), new List<string>() );

            AssertSequenceEqual( GenerateWordsFromWord("маг", wordsList), new List<string>() );

            AssertSequenceEqual( GenerateWordsFromWord("погром", wordsList), new List<string>{ "гром", "мор", "морг", "огр", "порог", "рог", "ром"} );

        }

        private static void TestMaxLengthTwoChar()

        {

            AssertEqual(MaxLengthTwoChar("beabeeab"), 5);

            AssertEqual(MaxLengthTwoChar("а"), 0);

            AssertEqual(MaxLengthTwoChar("ab"), 2);

        }

        private static void TestGetPreviousMaxDigital()

        {

            AssertEqual(GetPreviousMaxDigital(21), 12l);

            AssertEqual(GetPreviousMaxDigital(531), 513l);

            AssertEqual(GetPreviousMaxDigital(1027), -1l);

            AssertEqual(GetPreviousMaxDigital(2071), 2017l);

            AssertEqual(GetPreviousMaxDigital(135), -1l);

        }

        private static void TestSearchQueenOrHorse()

        {

            char[][] gridA =

            {

                new[] {'s', '#', '#', '#', '#', '#'},

                new[] {'#', 'x', 'x', 'x', 'x', '#'},

                new[] {'#', '#', '#', '#', 'x', '#'},

                new[] {'#', '#', '#', '#', 'x', '#'},

                new[] {'#', '#', '#', '#', '#', 'e'},

            };

            AssertSequenceEqual(SearchQueenOrHorse(gridA), new []{3, 2});

            char[][] gridB =

            {

                new[] {'s', '#', '#', '#', '#', 'x'},

                new[] {'#', 'x', 'x', 'x', 'x', '#'},

                new[] {'#', 'x', '#', '#', 'x', '#'},

                new[] {'#', '#', '#', '#', 'x', '#'},

                new[] {'x', '#', '#', '#', '#', 'e'},

            };

            AssertSequenceEqual(SearchQueenOrHorse(gridB), new []{-1, 3});

            char[][] gridC =

            {

                new[] {'s', '#', '#', '#', '#', 'x'},

                new[] {'x', 'x', 'x', 'x', 'x', 'x'},

                new[] {'#', '#', '#', '#', 'x', '#'},

                new[] {'#', '#', '#', 'e', 'x', '#'},

                new[] {'x', '#', '#', '#', '#', '#'},

            };

            AssertSequenceEqual(SearchQueenOrHorse(gridC), new []{2, -1});

            char[][] gridD =

            {

                new[] {'e', '#'},

                new[] {'x', 's'},

            };

​

            AssertSequenceEqual(SearchQueenOrHorse(gridD), new []{-1, 1});

            char[][] gridE =

            {

                new[] {'e', '#'},

                new[] {'x', 'x'},

                new[] {'#', 's'},

            };

​

            AssertSequenceEqual(SearchQueenOrHorse(gridE), new []{1, -1});

            char[][] gridF =

            {

                new[] {'x', '#', '#', 'x'},

                new[] {'#', 'x', 'x', '#'},

                new[] {'#', 'x', '#', 'x'},

                new[] {'e', 'x', 'x', 's'},

                new[] {'#', 'x', 'x', '#'},

                new[] {'x', '#', '#', 'x'},

            };

​

            AssertSequenceEqual(SearchQueenOrHorse(gridF), new []{-1, 5});

        }

        private static void TestCalculateMaxCoins()

        {

            var mapA = new []

            {

                new []{0, 1, 1},

                new []{0, 2, 4},

                new []{0, 3, 3},

                new []{1, 3, 10},

                new []{2, 3, 6},

            };

            AssertEqual(CalculateMaxCoins(mapA, 0, 3), 11l);

​

            var mapB = new []

            {

                new []{0, 1, 1},

                new []{1, 2, 53},

                new []{2, 3, 5},

                new []{5, 4, 10}

            };

            AssertEqual(CalculateMaxCoins(mapB, 0, 5), -1l);

            var mapC = new []

            {

                new []{0, 1, 1},

                new []{0, 3, 2},

                new []{0, 5, 10},

                new []{1, 2, 3},

                new []{2, 3, 2},

                new []{2, 4, 7},

                new []{3, 5, 3},

                new []{4, 5, 8}

            };

            AssertEqual(CalculateMaxCoins(mapC, 0, 5), 19l);

        }

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

        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]}");

                }

            }

        }

​

    }

}