OMG_test_template | C# Online Compiler

OMG_test_template by Anonymous

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)
        {
            string keyWord;
            string[] words = new string[15000];
            int wIndex = 0;
            int nIndex = 1;
            bool ret = false;

            Console.WriteLine("Сейчас мы посмотрим, сколько слов у тебя получиться составить из букв исходного!");

            do
            {
                Console.Write("Введи исходное слово: ");
                keyWord = Console.ReadLine();
            }
            while (keyWord.Length <= 2 || keyWord.Length > 15);

            Console.WriteLine("\nХорошо, а теперь введи слова, которые ты можешь составить!");

            for (int i = 0; ; i++, wIndex++, nIndex++)
            {
                char[] charsK = keyWord.ToCharArray();

                Console.Write($"Введи слово {nIndex} или нажми 'Enter' для продолжения:");

                words[i] = Console.ReadLine();
                Console.WriteLine();

                if (i > 0)
                {
                    for (int n = 0; n < i; n++)
                    {
                        if (words[i] == words[n])
                            ret = true;
                    }
                }

                if (ret == true)
                {
                    i--;
                    wIndex--;
                    ret = false;
                    continue;
                }

                if (words[i] == "")
                {
                    Console.WriteLine("\n");
                    break;
                }

                string chekWord = words[i];
                char[] charsW = chekWord.ToCharArray();

                for (int j = 0; j < charsW.Length; j++)
                {
                    for (int k = 0; k < charsK.Length; k++)
                    {
                        if (charsW[j] == charsK[k])
                        {
                            if (charsW[j] != '*')
                            {
                                charsW[j] = '*';
                                charsK[k] = '*';

                                if (charsW[j] < charsW.Length)
                                    j++;

                                k = -1;
                            }
                            continue;
                        }

                        if (j == charsW.Length - 1 && k == charsK.Length - 1)
                        {
                            int z = 0;

                            for (int m = 0; m < charsW.Length; m++)
                            {
                                if (charsW[m] == '*')
                                    z++;
                            }

                            if (z != charsW.Length)
                            {
                                i--;
                                wIndex--;
                            }
                        }
                    }
                }
            }

            string[] words2 = new string[wIndex];

            for (int i = 0; i < wIndex; i++)
                words2[i] = words[i];

            Array.Sort(words2);

            Console.WriteLine("Вот все подходящие слова, отсортированные в алфавитном порядке:");

            for (int i = 0; i < words2.Length; i++)
                Console.Write(words2[i] + "\t");

            Console.ReadLine();

            return new List<string>();
        }

        /// задание 2) Два уникальных символа
        public static int MaxLengthTwoChar(string word)
        {
            Console.WriteLine("Сейчас мы приступим к Заданию 2: Два уникальных символа.");

            string str;
            char[] charS;
            char[] charL = new char[26];
            bool En = true;
            int maxNewL = 0;
            string NewStr = "";

            do
            {
                Console.WriteLine("Введи строку длиной 1~1000, состоящий из a~z");
                str = Console.ReadLine();
                charS = str.ToCharArray();

                for (int i = 0; i < charS.Length; i++)
                {
                    if (charS[i] >= 'a' && charS[i] <= 'z' && charS.Length >= 1 && charS.Length <= 1000)
                        En = true;
                    else
                    {
                        En = false;
                        break;
                    }
                }
            }
            while (En == false);

            int Lindex = 0;

            for (int i = 0; i < charS.Length; i++)
            {
                if (i == 0)
                {
                    charL[Lindex] = charS[i];
                    Lindex++;
                }

                if (i > 0)
                {
                    for (int k = 0; k < i; k++)
                    {
                        if (charS[i] == charS[k])
                            break;

                        if (k == i - 1 && charS[i] != charS[k])
                        {
                            charL[Lindex] = charS[i];
                            Lindex++;
                        }
                    }
                }
            }

            if (Lindex == 1)
                maxNewL = 0;

            if (Lindex == 2)
                maxNewL = 2;

            if (Lindex > 2)
            {
                for (int i = 0; i < Lindex - 1; i++)
                {
                    for (int j = i + 1; j < Lindex; j++)
                    {
                        for (int k = 0; k < charS.Length; k++)
                        {
                            if (charS[k] == charL[i] || charS[k] == charL[j])
                                NewStr += charS[k].ToString();

                            if (k == charS.Length - 1)
                            {
                                for (int m = 1; m < NewStr.Length; m++)
                                {
                                    if (NewStr[m] == NewStr[m - 1])
                                    {
                                        NewStr = "";
                                        break;
                                    }
                                }
                                if (NewStr.Length > maxNewL)
                                    maxNewL = NewStr.Length;

                                NewStr = "";
                            }

                        }
                    }
                }
            }
            Console.Write("Длина самой длинной стрки: ");
            Console.WriteLine(maxNewL);
            Console.ReadLine();

            return 0;
        }

        /// задание 3) Предидущее число
        public static long GetPreviousMaxDigital(long value)
        {
            Console.WriteLine("Сейчас мы приступим к Заданию 3: Предыдущее число\n");

            bool isNumber;
            long Num;
            string Str;
            string sNum;
            char[] charNum;
            long PosIndex;
            long PosIndex2;
            char[] charNumNew;
            long SpaceIndex;


            do //проверка вводимых данных
            {
                Console.WriteLine("Введи число от 0 до 1*10^12:");

                Str = Console.ReadLine();
                isNumber = long.TryParse(Str, out Num);

                if (Num == 0 && Str != "0")
                    Num = -1;
            }
            while (Num < 0 || Num > 1000000000000);

            sNum = Num.ToString();
            charNum = sNum.ToCharArray();
            PosIndex = charNum.Length - 1;
            charNumNew = new char[charNum.Length];

            //старая структура: (0 ~ P1) , (P1 ~ P2) , (P2 ~ L)
            //новая структура: (0 ~ P1-1) , (P2-1) , (L ~ P2) , (P1) , (P2-2 ~ P1+1)

            do //находим переломное значение Р1
            {
                PosIndex--;
                if (PosIndex == -1)
                    break;
            }
            while (charNum[PosIndex] < charNum[PosIndex + 1]);

            if (PosIndex >= 0) //0 ~ P1-1
            {
                for (long i = 0; i < PosIndex; i++)
                    charNumNew[i] = charNum[i];
            }

            PosIndex2 = PosIndex + 1;

            if ((PosIndex2 < charNum.Length - 1) && (PosIndex2 != 0))
            {
                do //находим переломное значение Р2
                {
                    PosIndex2++;

                    if (PosIndex2 == charNum.Length - 1)
                    {
                        PosIndex2++;
                        break;
                    }
                }
                while (charNum[PosIndex] > charNum[PosIndex2]);

                charNumNew[PosIndex] = charNum[PosIndex2 - 1]; //P2-1

                if (PosIndex2 < charNum.Length)
                {
                    for (int i = 0; i < charNum.Length - PosIndex2; i++)  //L ~ Р2
                    {
                        charNumNew[PosIndex + 1 + i] = charNum[charNum.Length - 1 - i];

                        if (i == charNum.Length - 1 - PosIndex2)
                            charNumNew[PosIndex + 2 + i] = charNum[PosIndex]; //P1
                    }
                }
                else
                {
                    charNumNew[PosIndex + 1] = charNum[PosIndex];
                }

                SpaceIndex = PosIndex2 - PosIndex;

                if (SpaceIndex > 2)
                {
                    for (int i = 0; i < SpaceIndex - 2; i++) //P2-2 ~ P1+1
                    {
                        charNumNew[charNum.Length - SpaceIndex + 2 + i] = charNum[PosIndex2 - 2 - i];
                    }
                }

                if (charNumNew[0] == '0')
                    charNumNew = new char[2] { '-', '1' };
            }
            else if (PosIndex2 >= charNum.Length - 1)
            {
                charNumNew[PosIndex] = charNum[PosIndex2];
                charNumNew[PosIndex2] = charNum[PosIndex];

                if (charNumNew[0] == 0)
                    charNumNew = new char[2] { '-', '1' };
            }
            else
                charNumNew = new char[2] { '-', '1' };

            Console.WriteLine(charNumNew);
            Console.ReadLine();

            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(207034), 204730l);
            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]}");
                }
            }
        }

    }

}

​x
 
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)
        {
            string keyWord;
            string[] words = new string[15000];
            int wIndex = 0;
            int nIndex = 1;
            bool ret = false;
​
            Console.WriteLine("Сейчас мы посмотрим, сколько слов у тебя получиться составить из букв исходного!");
​
            do
            {
                Console.Write("Введи исходное слово: ");
                keyWord = Console.ReadLine();
            }
            while (keyWord.Length <= 2 || keyWord.Length > 15);
​
            Console.WriteLine("\nХорошо, а теперь введи слова, которые ты можешь составить!");
​
            for (int i = 0; ; i++, wIndex++, nIndex++)
            {
                char[] charsK = keyWord.ToCharArray();
​
                Console.Write($"Введи слово {nIndex} или нажми 'Enter' для продолжения:");
​
                words[i] = Console.ReadLine();
                Console.WriteLine();
​
                if (i > 0)
                {
                    for (int n = 0; n < i; n++)
                    {
                        if (words[i] == words[n])
                            ret = true;
                    }
                }
​
                if (ret == true)
                {
                    i--;
                    wIndex--;
                    ret = false;
                    continue;
                }
​
                if (words[i] == "")
                {
                    Console.WriteLine("\n");
                    break;
                }
​
                string chekWord = words[i];
                char[] charsW = chekWord.ToCharArray();
​
                for (int j = 0; j < charsW.Length; j++)
                {
                    for (int k = 0; k < charsK.Length; k++)
                    {
                        if (charsW[j] == charsK[k])
                        {
                            if (charsW[j] != '*')
                            {
                                charsW[j] = '*';
                                charsK[k] = '*';
​
                                if (charsW[j] < charsW.Length)
                                    j++;
​
                                k = -1;
                            }
                            continue;
                        }
​
                        if (j == charsW.Length - 1 && k == charsK.Length - 1)
                        {
                            int z = 0;
​
                            for (int m = 0; m < charsW.Length; m++)
                            {
                                if (charsW[m] == '*')
                                    z++;
                            }
​
                            if (z != charsW.Length)
                            {
                                i--;
                                wIndex--;
                            }
                        }
                    }
                }
            }
​
            string[] words2 = new string[wIndex];
​
            for (int i = 0; i < wIndex; i++)
                words2[i] = words[i];
​
            Array.Sort(words2);
​
            Console.WriteLine("Вот все подходящие слова, отсортированные в алфавитном порядке:");
​
            for (int i = 0; i < words2.Length; i++)
                Console.Write(words2[i] + "\t");
​
            Console.ReadLine();
​
            return new List<string>();
        }
​
        /// задание 2) Два уникальных символа
        public static int MaxLengthTwoChar(string word)
        {
            Console.WriteLine("Сейчас мы приступим к Заданию 2: Два уникальных символа.");
​
            string str;
            char[] charS;
            char[] charL = new char[26];
            bool En = true;
            int maxNewL = 0;
            string NewStr = "";
​
            do
            {
                Console.WriteLine("Введи строку длиной 1~1000, состоящий из a~z");
                str = Console.ReadLine();
                charS = str.ToCharArray();
​
                for (int i = 0; i < charS.Length; i++)
                {
                    if (charS[i] >= 'a' && charS[i] <= 'z' && charS.Length >= 1 && charS.Length <= 1000)
                        En = true;
                    else
                    {
                        En = false;
                        break;
                    }
                }
            }
            while (En == false);
​
            int Lindex = 0;
​
            for (int i = 0; i < charS.Length; i++)
            {
                if (i == 0)
                {
                    charL[Lindex] = charS[i];
                    Lindex++;
                }
​
                if (i > 0)
                {
                    for (int k = 0; k < i; k++)
                    {
                        if (charS[i] == charS[k])
                            break;
​
                        if (k == i - 1 && charS[i] != charS[k])
                        {
                            charL[Lindex] = charS[i];
                            Lindex++;
                        }
                    }
                }
            }
​
            if (Lindex == 1)
                maxNewL = 0;
​
            if (Lindex == 2)
                maxNewL = 2;
​
            if (Lindex > 2)
            {
                for (int i = 0; i < Lindex - 1; i++)
                {
                    for (int j = i + 1; j < Lindex; j++)
                    {
                        for (int k = 0; k < charS.Length; k++)
                        {
                            if (charS[k] == charL[i] || charS[k] == charL[j])
                                NewStr += charS[k].ToString();
​
                            if (k == charS.Length - 1)
                            {
                                for (int m = 1; m < NewStr.Length; m++)
                                {
                                    if (NewStr[m] == NewStr[m - 1])
                                    {
                                        NewStr = "";
                                        break;
                                    }
                                }
                                if (NewStr.Length > maxNewL)
                                    maxNewL = NewStr.Length;
​
                                NewStr = "";
                            }
​
                        }
                    }
                }
            }
            Console.Write("Длина самой длинной стрки: ");
            Console.WriteLine(maxNewL);
            Console.ReadLine();
​
            return 0;
        }
​
        /// задание 3) Предидущее число
        public static long GetPreviousMaxDigital(long value)
        {
            Console.WriteLine("Сейчас мы приступим к Заданию 3: Предыдущее число\n");
​
            bool isNumber;
            long Num;
            string Str;
            string sNum;
            char[] charNum;
            long PosIndex;
            long PosIndex2;
            char[] charNumNew;
            long SpaceIndex;
​
​
            do //проверка вводимых данных
            {
                Console.WriteLine("Введи число от 0 до 1*10^12:");
​
                Str = Console.ReadLine();
                isNumber = long.TryParse(Str, out Num);
​
                if (Num == 0 && Str != "0")
                    Num = -1;
            }
            while (Num < 0 || Num > 1000000000000);
​
            sNum = Num.ToString();
            charNum = sNum.ToCharArray();
            PosIndex = charNum.Length - 1;
            charNumNew = new char[charNum.Length];
​
            //старая структура: (0 ~ P1) , (P1 ~ P2) , (P2 ~ L)
            //новая структура: (0 ~ P1-1) , (P2-1) , (L ~ P2) , (P1) , (P2-2 ~ P1+1)
​
            do //находим переломное значение Р1
            {
                PosIndex--;
                if (PosIndex == -1)
                    break;
            }
            while (charNum[PosIndex] < charNum[PosIndex + 1]);
​
            if (PosIndex >= 0) //0 ~ P1-1
            {
                for (long i = 0; i < PosIndex; i++)
                    charNumNew[i] = charNum[i];
            }
​
            PosIndex2 = PosIndex + 1;
​
            if ((PosIndex2 < charNum.Length - 1) && (PosIndex2 != 0))
            {
                do //находим переломное значение Р2
                {
                    PosIndex2++;
​
                    if (PosIndex2 == charNum.Length - 1)
                    {
                        PosIndex2++;
                        break;
                    }
                }
                while (charNum[PosIndex] > charNum[PosIndex2]);
​
                charNumNew[PosIndex] = charNum[PosIndex2 - 1]; //P2-1
​
                if (PosIndex2 < charNum.Length)
                {
                    for (int i = 0; i < charNum.Length - PosIndex2; i++)  //L ~ Р2
                    {
                        charNumNew[PosIndex + 1 + i] = charNum[charNum.Length - 1 - i];
​
                        if (i == charNum.Length - 1 - PosIndex2)
                            charNumNew[PosIndex + 2 + i] = charNum[PosIndex]; //P1
                    }
                }
                else
                {
                    charNumNew[PosIndex + 1] = charNum[PosIndex];
                }
​
                SpaceIndex = PosIndex2 - PosIndex;
​
                if (SpaceIndex > 2)
                {
                    for (int i = 0; i < SpaceIndex - 2; i++) //P2-2 ~ P1+1
                    {
                        charNumNew[charNum.Length - SpaceIndex + 2 + i] = charNum[PosIndex2 - 2 - i];
                    }
                }
​
                if (charNumNew[0] == '0')
                    charNumNew = new char[2] { '-', '1' };
            }
            else if (PosIndex2 >= charNum.Length - 1)
            {
                charNumNew[PosIndex] = charNum[PosIndex2];
                charNumNew[PosIndex2] = charNum[PosIndex];
​
                if (charNumNew[0] == 0)
                    charNumNew = new char[2] { '-', '1' };
            }
            else
                charNumNew = new char[2] { '-', '1' };
​
            Console.WriteLine(charNumNew);
            Console.ReadLine();
​
            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(207034), 204730l);
            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]}");
                }
            }
        }
​
    }
​
}

-4
The number is negative

Last Run:	1:13:23 pm
Compile:	0.117s
Execute:	0s
Memory:	0b
CPU:	0s

View IL Code