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)
        {		
			var CreateableWords = new List<string>();			
			for(int i = 0; i < wordDictionary.Count; i++)
			{
				//отсечение слов длинее слова-образца
				if(wordDictionary[i].Length < word.Length)
				{
					string word_copy = word;
					bool isCreateable = true;
			    	foreach(char c in wordDictionary[i])
					{
						//отсечение слова не содержащего свободного char c
						if(!word_copy.Contains(c))
						{
							isCreateable = false;
							break;
						}
						word_copy = word_copy.Remove(word_copy.IndexOf(c),1);
					}
					if(isCreateable==true)
					{
						CreateableWords.Add(wordDictionary[i]);
					}
				}
			}	
			CreateableWords.Sort();
            return CreateableWords;
        }
        
        /// задание 2) Два уникальных символа
        public static int MaxLengthTwoChar(string word)
        {
			//Dictionary, хранящий кол-во символов по символу-ключу
			Dictionary<char,int> charAmountDictionary = new Dictionary<char,int>();
			charAmountDictionary = CountAllChars(charAmountDictionary, word);
			if(charAmountDictionary.Count < 2)
			{
				return 0;
			}
			
			do
			{
				List<char> compatibleChars = new List<char>();
				
				int temp_maxAmount = charAmountDictionary.Values.Max();
				//выбор символом с макс кол-вом его в слове
				char maxChar = charAmountDictionary.Last(x => x.Value == temp_maxAmount).Key;
				charAmountDictionary.Remove(maxChar);	
				if(charAmountDictionary.Count() == 0)
				{
					return 0;
				}
				foreach(var c in charAmountDictionary)
				{
					//выборка для символа с макс кол-вом может быть только для символов с таким же кол-вом, либо меньше на один - abab or aba, где в приоритете с равным кол-вом 
					if(c.Value == temp_maxAmount)
					{
						compatibleChars.Add(c.Key);
					}
					if(c.Value == temp_maxAmount-1)
					{
						compatibleChars.Insert(0,c.Key);
					}
				}
				foreach(char compC in compatibleChars)
				{
					//строка содержащяя только два вида выбранных символов
					string strAB = new string((from c in word where c == compC || c == maxChar select c).ToArray());
					//если строка не содержит подстроку aa или bb следовательно она подходит, а так как выбираются символы с самым большим кол-вом в строке, то это будет макс. ответ
					if(!strAB.Contains(new string (maxChar,2)) && !strAB.Contains(new string (compC,2)))
					{
						return strAB.Length;
					}
				}
			}while(true);
        }
        public static Dictionary<char,int> CountAllChars(Dictionary<char,int> charAmountDictionary, string word)
		{
			//подсчёт и упорядочение символов в слове в словарь по символам-ключам
			for(int i = 0; i < word.Length; i++)
			{
				if(!charAmountDictionary.ContainsKey(word[i]))
				{
					charAmountDictionary[word[i]] = new int();
				}
				charAmountDictionary[word[i]]++;	
			}
			return charAmountDictionary;
		}  
        
        /// задание 3) Предидущее число
        public static long GetPreviousMaxDigital(long value)
        {
			var digits = value.ToString().ToCharArray();
			int i = digits.Count()-1;
			//отсечение слишком малоразрядных чисел
			if(digits.Length <= 1)
			{
				return -1;
			}
			//использую обратный Алгоритм Нарайаны	
			do
			{
				if(digits[i-1] > digits[i])
				{
					for(int j = digits.Count()-1; j > i-1; j--)
					{
						if(digits[j] < digits[i-1])
						{
							digits = SwapElements<char>(i-1,j,digits);							
							if(digits[0]=='0')
							{
								return -1;
							}							
							Array.Reverse(digits, i, digits.Count()-i);
							string s = new string(digits);
										
							value = long.Parse(s);
							return value;
						}
					}
				}	
				i--;
			}while(i > 0);
	        return -1;
        }
		public static T[] SwapElements<T>(int i1,int i2, T[] array)
		{
			var tmp_value = array[i1];
			array[i1] = array[i2];
			array[i2] = tmp_value;
			return array;
		}
        
        /// задание 4) Конь и Королева
        public static List<int> SearchQueenOrHorse(char[][] gridMap)
        {
			var result = FindStartPoint(gridMap);
			int[] startPoint = result.Item1;
			char[][] copy = new char[gridMap.Length][];
			copy = CopyArray(gridMap);
            return new List<int>(){HorsePathFinding(startPoint, copy), QueenPathFinding(startPoint, gridMap)};
        }
		static T[][] CopyArray<T>(T[][] array)
		{
  			var lenght = array.Length;
   			var dest = new T[lenght][];

    		for (var x = 0; x < lenght; x++)
    		{
        		var inner = array[x];
       			var ilen = inner.Length;
        		var newer = new T[ilen];
        		Array.Copy(inner, newer, ilen);
        		dest[x] = newer;
    		}
		return dest;
		}
		public static (int[],char[][])  FindStartPoint(char[][] map)
		{ 
			for(int y = 0; y < map.Length; y++)
			{
				for(int x = 0; x < map[y].Length; x++)
				{
					if(map[y][x] == 's')
					{
						map[y][x] = 'x';
						return (new int[]{x,y}, map);
					}
				}
			}
			return (new int[]{-1, -1}, map);
		}
		public static int QueenPathFinding(int[] startPoint, char[][] map)
		{
			List<int[]> stepWays = new List<int[]>(){new int[]{1,0}, new int[]{-1,0}, new int[]{0,1}, new int[]{0,-1}, new int[]{1,1}, new int[]{-1,1}, new int[]{1,-1}, new int[]{-1,-1}};
			List<int[]> nextToCheckCells = new List<int[]>();
			List<int[]> currentCellsToCheck = new List<int[]>();
			int yLenght = map.Length;
			int xLenght = map[0].Length;
			currentCellsToCheck.Add(startPoint);
			int cost = 1;
			do
			{
				foreach(var cell in currentCellsToCheck)
				{
					foreach(var way in stepWays)
					{
						int i = 1 ;
						do
						{
							int[] checkCell = new int[]{cell[0]+way[0]*i,cell[1]+way[1]*i};
							if(checkCell[0] > -1 && checkCell[1] > -1 && checkCell[0] < xLenght  && checkCell[1] < yLenght && map[checkCell[1]][checkCell[0]] != 'x')
							{
								if(map[checkCell[1]][checkCell[0]] != 'c')
								{
									if(map[checkCell[1]][checkCell[0]] == 'e')
									{
										return cost;
									}
									map[checkCell[1]][checkCell[0]] = 'c';
								}
								else
								{
									map[checkCell[1]][checkCell[0]]='x';
								}
								nextToCheckCells.Add(new int[]{checkCell[0], checkCell[1]});
							}
							else
							{
								break;
							}
							i++;
						}while(true);
					}
				}
				
				if(nextToCheckCells.Count() == 0)
				{
					return -1;
				}
				currentCellsToCheck = new List<int[]>(nextToCheckCells);
				nextToCheckCells.Clear();
				cost = cost+1;
			}while(true);
		}
		public static int HorsePathFinding(int[] startPoint, char[][] map)
		{
			List<int[]> stepWays = new List<int[]>(){new int[]{-2,-1}, new int[]{-2,1}, new int[]{2,-1}, new int[]{2,1}, new int[]{-1,-2}, new int[]{-1,2}, new int[]{1,-2}, new int[]{1,2}};
			List<int[]> nextToCheckCells = new List<int[]>();
			List<int[]> currentCellsToCheck = new List<int[]>();
			int yLenght = map.Length;
			int xLenght = map[0].Length;
			currentCellsToCheck.Add(startPoint);
			int cost = 1;
			do
			{
				foreach(var cell in currentCellsToCheck)
				{
					foreach(var way in stepWays)
					{
						int[] checkCell = new int[]{cell[0]+way[0],cell[1]+way[1]};
						if(checkCell[0] > -1 && checkCell[1] > -1 && checkCell[0] < xLenght  && checkCell[1] < yLenght && map[checkCell[1]][checkCell[0]] != 'x')
						{
							if(map[checkCell[1]][checkCell[0]] == 'e')
							{
								return cost;
							}
							nextToCheckCells.Add(new int[]{checkCell[0], checkCell[1]});
							map[checkCell[1]][checkCell[0]] = 'x';
						}
					}
				}
				
				if(nextToCheckCells.Count() == 0)
				{
					return -1;
				}
				currentCellsToCheck = new List<int[]>(nextToCheckCells);
				nextToCheckCells.Clear();
				cost = cost+1;
			}while(true);
		}
        
        /// задание 5) Жадина
        public static long CalculateMaxCoins(int[][] mapData, int idStart, int idFinish)
        {
			/*Данный алгоритм более оптимизирован под карты с большим кол-вом переплетенных точек и тупиков
			В случае если будет много оторванных от начальной и конечной точек городов, код сделает лишнии итерации расчёта*/
			Dictionary<int,List<int[]>> wayCostDictionary = new Dictionary<int,List<int[]>>();
			List<int> path = new List<int>();
			//сортировка путей в Dictionary для более быстрого поиска по городам
			wayCostDictionary = SortAllWaysToDictionary(wayCostDictionary, mapData);
			//удаление тупиков и путей связанных только с тупиком для уменьшения кол-ва ненужных итераций при рекурсии
			wayCostDictionary = RemoveDeadendsCities(wayCostDictionary, idStart, idFinish);
			int maxPathLenght = FindMaxPath(path, idStart, idFinish, wayCostDictionary);
			if(maxPathLenght == 0)
			{
				return -1;
			}
            return maxPathLenght;
        }
		private static Dictionary<int,List<int[]>> SortAllWaysToDictionary(Dictionary<int,List<int[]>> wayCostDictionary, int[][] mapData)
		{
			for(int i = 0; i < mapData.Length; i++)
			{
				int[] data = mapData[i];
				if(!wayCostDictionary.ContainsKey(data[0]))
				{
					wayCostDictionary[data[0]] = new List<int[]>();
				}
				wayCostDictionary[data[0]].Add(new int[]{data[1], data[2]});
				if(!wayCostDictionary.ContainsKey(data[1]))
				{
					wayCostDictionary[data[1]] = new List<int[]>();
				}
				wayCostDictionary[data[1]].Add(new int[]{data[0], data[2]});				
			}
			return wayCostDictionary;
		}
		private static Dictionary<int,List<int[]>> RemoveDeadendsCities(Dictionary<int,List<int[]>> wayCostDictionary, int idStart, int idFinish)
		{
			bool isDeadends;
			do
			{
				isDeadends = false;
				foreach(var (key, list) in wayCostDictionary)
				{
					if(wayCostDictionary[key].Count < 2 && key != idStart && key != idFinish)
					{
						isDeadends = true;
						wayCostDictionary.Remove(key);
						wayCostDictionary[list.Last()[0]] = wayCostDictionary[list.Last()[0]].Where(c => c[0] != key).ToList();
					}
				}
			}while(isDeadends == true);
			return wayCostDictionary;
		}
		private static int FindMaxPath(List<int> path, int idCity, int idFinish, Dictionary<int,List<int[]>> wayCostDictionary)
		{
			int maxPathLenght = -1;
			List<int> finishedPath = new List<int>();
			path.Add(idCity);
			foreach(var ways in wayCostDictionary[idCity])
			{
				if(!path.Contains(ways[0]))
				{
					if(ways[0] == idFinish)
					{
						finishedPath = new List<int>(path);
						finishedPath.Add(ways[0]);
					}
					else
					{
						//рекурсионный поиск макс пути
						maxPathLenght = Math.Max(maxPathLenght, FindMaxPath(path, ways[0], idFinish, wayCostDictionary));
						path.Remove(ways[0]);
					}
				}
			}
			int currentLenght = 0;
			for(int i = 0; i < finishedPath.Count()-1; i++)
			{
				int[] k = new int[]{0,0};
				k = wayCostDictionary[finishedPath.ElementAt(i)].Find(x => x[0]==finishedPath.ElementAt(i+1));
				currentLenght = currentLenght + k[1];
			}
			if(currentLenght > maxPathLenght)
			{
				maxPathLenght = currentLenght;
			}
			return maxPathLenght;
		}

        /// Тесты (можно/нужно добавлять свои тесты) 
		
        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>{ "гром", "мор", "морг", "огр", "порог", "рог", "ром"} );
			AssertSequenceEqual( GenerateWordsFromWord("ммокоаг", wordsList), new List<string>{"око"});
        }
        
         private static void TestMaxLengthTwoChar()
        {
            AssertEqual(MaxLengthTwoChar("beabeeab"), 5);
            AssertEqual(MaxLengthTwoChar("а"), 0);
            AssertEqual(MaxLengthTwoChar("aa"), 0);
            AssertEqual(MaxLengthTwoChar("ab"), 2);
			AssertEqual(MaxLengthTwoChar("aabb"), 0);
			AssertEqual(MaxLengthTwoChar("daabbggd"), 0);
			AssertEqual(MaxLengthTwoChar("fabgcad"), 3);
			AssertEqual(MaxLengthTwoChar("fabgcba"), 3);
			AssertEqual(MaxLengthTwoChar("abbabcdeedk"), 2);
			AssertEqual(MaxLengthTwoChar("cabbacbcdeedkkk"), 0);
			AssertEqual(MaxLengthTwoChar("aag"), 0);
		}
        
        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);
			AssertEqual(GetPreviousMaxDigital(100273), 100237l);
			AssertEqual(GetPreviousMaxDigital(103467), -1l);
			AssertEqual(GetPreviousMaxDigital(11223322), 11223232l);
			AssertEqual(GetPreviousMaxDigital(9865679), 9859766l);
			AssertEqual(GetPreviousMaxDigital(789311223335), 789253333211l);
        }
        
        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});
			
			char[][] gridH =
            {
                new[] {'#', '#', '#', '#'},
                new[] {'#', '#', '#', '#'},
                new[] {'#', 'x', '#', '#'},
                new[] {'e', 'x', 'x', '#'},
                new[] {'#', '#', '#', '#'},
                new[] {'#', 'x', 'x', '#'},
				new[] {'#', 'x', 'x', '#'},
                new[] {'#', 'x', '#', 'x'},
                new[] {'#', 'x', 'x', 'x'},
                new[] {'#', 'x', 'x', 's'},
                new[] {'#', '#', 'x', '#'},
                new[] {'#', 'x', '#', 'x'},
            };

            AssertSequenceEqual(SearchQueenOrHorse(gridH), new []{5, 4});
        }
 
        private static void TestCalculateMaxCoins()
        {
            var mapA = new []
            {
				new []{0, 5, 1},
                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);
			
			var mapD = new []
            {
                new []{7,3,1},
				new []{3,9,5},
				new []{0,9,10},
				new []{7,2,2},
				new []{2,9,2},
            };
            
            AssertEqual(CalculateMaxCoins(mapD, 7, 0), 16l);
			
			var mapF = new []
            {
                new []{0,1,1},
				new []{2,0,2},
				new []{2,1,3},
				new []{3,2,2},
				new []{1,3,4},
			};
			 AssertEqual(CalculateMaxCoins(mapF, 0, 3), 9l);
			
			var mapG = new []
            {
                new []{1,2,1},
				new []{2,3,2},
				new []{2,6,3},
				new []{2,7,10},
				new []{3,4,1},
				new []{3,5,1},
				new []{5,4,2},
				new []{6,5,1},
				new []{6,7,5},
				new []{8,7,19},
				new []{9,8,1},
			};
			 AssertEqual(CalculateMaxCoins(mapG, 1, 7), 12l);
			//pentagrama
			var mapH = new []
            {
                new []{1,2,1},
				new []{1,3,2},
				new []{1,4,3},
				new []{1,5,1},
				new []{2,3,2},
				new []{2,4,1},
				new []{2,5,1},
				new []{3,4,1},
				new []{3,5,2},
				new []{4,5,2},
			};
			 AssertEqual(CalculateMaxCoins(mapH, 1, 5), 8l);
			var mapJ = new []
            {
                new []{1,2,10},
				new []{1,6,1},
				new []{2,3,9},
				new []{3,4,6},
				new []{3,5,7},
				new []{4,5,5},
				new []{4,8,6},
				new []{8,7,2},
				new []{8,5,7},
				new []{7,6,1},
				new []{7,5,100},
				new []{1,2,1},
			};
			 AssertEqual(CalculateMaxCoins(mapJ, 1, 5), 133l);
        }
        
		/// Тестирующая система, лучше не трогать этот код
        
        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)
        {       
            var CreateableWords = new List<string>();           
            for(int i = 0; i < wordDictionary.Count; i++)
            {
                //отсечение слов длинее слова-образца
                if(wordDictionary[i].Length < word.Length)
                {
                    string word_copy = word;
                    bool isCreateable = true;
                    foreach(char c in wordDictionary[i])
                    {
                        //отсечение слова не содержащего свободного char c
                        if(!word_copy.Contains(c))
                        {
                            isCreateable = false;
                            break;
                        }
                        word_copy = word_copy.Remove(word_copy.IndexOf(c),1);
                    }
                    if(isCreateable==true)
                    {
                        CreateableWords.Add(wordDictionary[i]);
                    }
                }
            }   
            CreateableWords.Sort();
            return CreateableWords;
        }
        
        /// задание 2) Два уникальных символа
        public static int MaxLengthTwoChar(string word)
        {
            //Dictionary, хранящий кол-во символов по символу-ключу
            Dictionary<char,int> charAmountDictionary = new Dictionary<char,int>();
            charAmountDictionary = CountAllChars(charAmountDictionary, word);
            if(charAmountDictionary.Count < 2)
            {
                return 0;
            }
            
            do
            {
                List<char> compatibleChars = new List<char>();
                
                int temp_maxAmount = charAmountDictionary.Values.Max();
                //выбор символом с макс кол-вом его в слове
                char maxChar = charAmountDictionary.Last(x => x.Value == temp_maxAmount).Key;
                charAmountDictionary.Remove(maxChar);   
                if(charAmountDictionary.Count() == 0)
                {
                    return 0;
                }
                foreach(var c in charAmountDictionary)
                {
                    //выборка для символа с макс кол-вом может быть только для символов с таким же кол-вом, либо меньше на один - abab or aba, где в приоритете с равным кол-вом 
                    if(c.Value == temp_maxAmount)
                    {
                        compatibleChars.Add(c.Key);
                    }
                    if(c.Value == temp_maxAmount-1)
                    {
                        compatibleChars.Insert(0,c.Key);
                    }
                }
                foreach(char compC in compatibleChars)
                {
                    //строка содержащяя только два вида выбранных символов
                    string strAB = new string((from c in word where c == compC || c == maxChar select c).ToArray());
                    //если строка не содержит подстроку aa или bb следовательно она подходит, а так как выбираются символы с самым большим кол-вом в строке, то это будет макс. ответ
                    if(!strAB.Contains(new string (maxChar,2)) && !strAB.Contains(new string (compC,2)))
                    {
                        return strAB.Length;
                    }
                }
            }while(true);
        }
        public static Dictionary<char,int> CountAllChars(Dictionary<char,int> charAmountDictionary, string word)
        {
            //подсчёт и упорядочение символов в слове в словарь по символам-ключам
            for(int i = 0; i < word.Length; i++)
            {
                if(!charAmountDictionary.ContainsKey(word[i]))
                {
                    charAmountDictionary[word[i]] = new int();
                }
                charAmountDictionary[word[i]]++;    
            }
            return charAmountDictionary;
        }  
        
        /// задание 3) Предидущее число
        public static long GetPreviousMaxDigital(long value)
        {
            var digits = value.ToString().ToCharArray();
            int i = digits.Count()-1;
            //отсечение слишком малоразрядных чисел
            if(digits.Length <= 1)
            {
                return -1;
            }
            //использую обратный Алгоритм Нарайаны  
            do
            {
                if(digits[i-1] > digits[i])
                {
                    for(int j = digits.Count()-1; j > i-1; j--)
                    {
                        if(digits[j] < digits[i-1])
                        {
                            digits = SwapElements<char>(i-1,j,digits);                          
                            if(digits[0]=='0')
                            {
                                return -1;
                            }                           
                            Array.Reverse(digits, i, digits.Count()-i);
                            string s = new string(digits);
                                        
                            value = long.Parse(s);
                            return value;
                        }
                    }
                }   
                i--;
            }while(i > 0);
            return -1;
        }
        public static T[] SwapElements<T>(int i1,int i2, T[] array)
        {
            var tmp_value = array[i1];
            array[i1] = array[i2];
            array[i2] = tmp_value;
            return array;
        }
        
        /// задание 4) Конь и Королева
        public static List<int> SearchQueenOrHorse(char[][] gridMap)
        {
            var result = FindStartPoint(gridMap);
            int[] startPoint = result.Item1;
            char[][] copy = new char[gridMap.Length][];
            copy = CopyArray(gridMap);
            return new List<int>(){HorsePathFinding(startPoint, copy), QueenPathFinding(startPoint, gridMap)};
        }
        static T[][] CopyArray<T>(T[][] array)
        {
            var lenght = array.Length;
            var dest = new T[lenght][];
​
            for (var x = 0; x < lenght; x++)
            {
                var inner = array[x];
                var ilen = inner.Length;
                var newer = new T[ilen];
                Array.Copy(inner, newer, ilen);
                dest[x] = newer;
            }
        return dest;
        }
        public static (int[],char[][])  FindStartPoint(char[][] map)
        { 
            for(int y = 0; y < map.Length; y++)
            {
                for(int x = 0; x < map[y].Length; x++)
                {
                    if(map[y][x] == 's')
                    {
                        map[y][x] = 'x';
                        return (new int[]{x,y}, map);
                    }
                }
            }
            return (new int[]{-1, -1}, map);
        }
        public static int QueenPathFinding(int[] startPoint, char[][] map)
        {
            List<int[]> stepWays = new List<int[]>(){new int[]{1,0}, new int[]{-1,0}, new int[]{0,1}, new int[]{0,-1}, new int[]{1,1}, new int[]{-1,1}, new int[]{1,-1}, new int[]{-1,-1}};
            List<int[]> nextToCheckCells = new List<int[]>();
            List<int[]> currentCellsToCheck = new List<int[]>();
            int yLenght = map.Length;
            int xLenght = map[0].Length;
            currentCellsToCheck.Add(startPoint);
            int cost = 1;
            do
            {
                foreach(var cell in currentCellsToCheck)
                {
                    foreach(var way in stepWays)
                    {
                        int i = 1 ;
                        do
                        {
                            int[] checkCell = new int[]{cell[0]+way[0]*i,cell[1]+way[1]*i};
                            if(checkCell[0] > -1 && checkCell[1] > -1 && checkCell[0] < xLenght  && checkCell[1] < yLenght && map[checkCell[1]][checkCell[0]] != 'x')
                            {
                                if(map[checkCell[1]][checkCell[0]] != 'c')
                                {
                                    if(map[checkCell[1]][checkCell[0]] == 'e')
                                    {
                                        return cost;
                                    }
                                    map[checkCell[1]][checkCell[0]] = 'c';
                                }
                                else
                                {
                                    map[checkCell[1]][checkCell[0]]='x';
                                }
                                nextToCheckCells.Add(new int[]{checkCell[0], checkCell[1]});
                            }
                            else
                            {
                                break;
                            }
                            i++;
                        }while(true);
                    }
                }
                
                if(nextToCheckCells.Count() == 0)
                {
                    return -1;
                }
                currentCellsToCheck = new List<int[]>(nextToCheckCells);
                nextToCheckCells.Clear();
                cost = cost+1;
            }while(true);
        }
        public static int HorsePathFinding(int[] startPoint, char[][] map)
        {
            List<int[]> stepWays = new List<int[]>(){new int[]{-2,-1}, new int[]{-2,1}, new int[]{2,-1}, new int[]{2,1}, new int[]{-1,-2}, new int[]{-1,2}, new int[]{1,-2}, new int[]{1,2}};
            List<int[]> nextToCheckCells = new List<int[]>();
            List<int[]> currentCellsToCheck = new List<int[]>();
            int yLenght = map.Length;
            int xLenght = map[0].Length;
            currentCellsToCheck.Add(startPoint);
            int cost = 1;
            do
            {
                foreach(var cell in currentCellsToCheck)
                {
                    foreach(var way in stepWays)
                    {
                        int[] checkCell = new int[]{cell[0]+way[0],cell[1]+way[1]};
                        if(checkCell[0] > -1 && checkCell[1] > -1 && checkCell[0] < xLenght  && checkCell[1] < yLenght && map[checkCell[1]][checkCell[0]] != 'x')
                        {
                            if(map[checkCell[1]][checkCell[0]] == 'e')
                            {
                                return cost;
                            }
                            nextToCheckCells.Add(new int[]{checkCell[0], checkCell[1]});
                            map[checkCell[1]][checkCell[0]] = 'x';
                        }
                    }
                }
                
                if(nextToCheckCells.Count() == 0)
                {
                    return -1;
                }
                currentCellsToCheck = new List<int[]>(nextToCheckCells);
                nextToCheckCells.Clear();
                cost = cost+1;
            }while(true);
        }
        
        /// задание 5) Жадина
        public static long CalculateMaxCoins(int[][] mapData, int idStart, int idFinish)
        {
            /*Данный алгоритм более оптимизирован под карты с большим кол-вом переплетенных точек и тупиков
            В случае если будет много оторванных от начальной и конечной точек городов, код сделает лишнии итерации расчёта*/
            Dictionary<int,List<int[]>> wayCostDictionary = new Dictionary<int,List<int[]>>();
            List<int> path = new List<int>();
            //сортировка путей в Dictionary для более быстрого поиска по городам
            wayCostDictionary = SortAllWaysToDictionary(wayCostDictionary, mapData);
            //удаление тупиков и путей связанных только с тупиком для уменьшения кол-ва ненужных итераций при рекурсии
            wayCostDictionary = RemoveDeadendsCities(wayCostDictionary, idStart, idFinish);
            int maxPathLenght = FindMaxPath(path, idStart, idFinish, wayCostDictionary);
            if(maxPathLenght == 0)
            {
                return -1;
            }
            return maxPathLenght;
        }
        private static Dictionary<int,List<int[]>> SortAllWaysToDictionary(Dictionary<int,List<int[]>> wayCostDictionary, int[][] mapData)
        {
            for(int i = 0; i < mapData.Length; i++)
            {
                int[] data = mapData[i];
                if(!wayCostDictionary.ContainsKey(data[0]))
                {
                    wayCostDictionary[data[0]] = new List<int[]>();
                }
                wayCostDictionary[data[0]].Add(new int[]{data[1], data[2]});
                if(!wayCostDictionary.ContainsKey(data[1]))
                {
                    wayCostDictionary[data[1]] = new List<int[]>();
                }
                wayCostDictionary[data[1]].Add(new int[]{data[0], data[2]});                
            }
            return wayCostDictionary;
        }
        private static Dictionary<int,List<int[]>> RemoveDeadendsCities(Dictionary<int,List<int[]>> wayCostDictionary, int idStart, int idFinish)
        {
            bool isDeadends;
            do
            {
                isDeadends = false;
                foreach(var (key, list) in wayCostDictionary)
                {
                    if(wayCostDictionary[key].Count < 2 && key != idStart && key != idFinish)
                    {
                        isDeadends = true;
                        wayCostDictionary.Remove(key);
                        wayCostDictionary[list.Last()[0]] = wayCostDictionary[list.Last()[0]].Where(c => c[0] != key).ToList();
                    }
                }
            }while(isDeadends == true);
            return wayCostDictionary;
        }
        private static int FindMaxPath(List<int> path, int idCity, int idFinish, Dictionary<int,List<int[]>> wayCostDictionary)
        {
            int maxPathLenght = -1;
            List<int> finishedPath = new List<int>();
            path.Add(idCity);
            foreach(var ways in wayCostDictionary[idCity])
            {
                if(!path.Contains(ways[0]))
                {
                    if(ways[0] == idFinish)
                    {
                        finishedPath = new List<int>(path);
                        finishedPath.Add(ways[0]);
                    }
                    else
                    {
                        //рекурсионный поиск макс пути
                        maxPathLenght = Math.Max(maxPathLenght, FindMaxPath(path, ways[0], idFinish, wayCostDictionary));
                        path.Remove(ways[0]);
                    }
                }
            }
            int currentLenght = 0;
            for(int i = 0; i < finishedPath.Count()-1; i++)
            {
                int[] k = new int[]{0,0};
                k = wayCostDictionary[finishedPath.ElementAt(i)].Find(x => x[0]==finishedPath.ElementAt(i+1));
                currentLenght = currentLenght + k[1];
            }
            if(currentLenght > maxPathLenght)
            {
                maxPathLenght = currentLenght;
            }
            return maxPathLenght;
        }
​
        /// Тесты (можно/нужно добавлять свои тесты) 
        
        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>{ "гром", "мор", "морг", "огр", "порог", "рог", "ром"} );
            AssertSequenceEqual( GenerateWordsFromWord("ммокоаг", wordsList), new List<string>{"око"});
        }
        
         private static void TestMaxLengthTwoChar()
        {
            AssertEqual(MaxLengthTwoChar("beabeeab"), 5);
            AssertEqual(MaxLengthTwoChar("а"), 0);
            AssertEqual(MaxLengthTwoChar("aa"), 0);
            AssertEqual(MaxLengthTwoChar("ab"), 2);
            AssertEqual(MaxLengthTwoChar("aabb"), 0);
            AssertEqual(MaxLengthTwoChar("daabbggd"), 0);
            AssertEqual(MaxLengthTwoChar("fabgcad"), 3);
            AssertEqual(MaxLengthTwoChar("fabgcba"), 3);
            AssertEqual(MaxLengthTwoChar("abbabcdeedk"), 2);
            AssertEqual(MaxLengthTwoChar("cabbacbcdeedkkk"), 0);
            AssertEqual(MaxLengthTwoChar("aag"), 0);
        }
        
        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);
            AssertEqual(GetPreviousMaxDigital(100273), 100237l);
            AssertEqual(GetPreviousMaxDigital(103467), -1l);
            AssertEqual(GetPreviousMaxDigital(11223322), 11223232l);
            AssertEqual(GetPreviousMaxDigital(9865679), 9859766l);
            AssertEqual(GetPreviousMaxDigital(789311223335), 789253333211l);
        }
        
        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});
            
            char[][] gridH =
            {
                new[] {'#', '#', '#', '#'},
                new[] {'#', '#', '#', '#'},
                new[] {'#', 'x', '#', '#'},
                new[] {'e', 'x', 'x', '#'},
                new[] {'#', '#', '#', '#'},
                new[] {'#', 'x', 'x', '#'},
                new[] {'#', 'x', 'x', '#'},
                new[] {'#', 'x', '#', 'x'},
                new[] {'#', 'x', 'x', 'x'},
                new[] {'#', 'x', 'x', 's'},
                new[] {'#', '#', 'x', '#'},
                new[] {'#', 'x', '#', 'x'},
            };
​
            AssertSequenceEqual(SearchQueenOrHorse(gridH), new []{5, 4});
        }
 
        private static void TestCalculateMaxCoins()
        {
            var mapA = new []
            {
                new []{0, 5, 1},
                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);
            
            var mapD = new []
            {
                new []{7,3,1},
                new []{3,9,5},
                new []{0,9,10},
                new []{7,2,2},
                new []{2,9,2},
            };
            
            AssertEqual(CalculateMaxCoins(mapD, 7, 0), 16l);
            
            var mapF = new []
            {
                new []{0,1,1},
                new []{2,0,2},
                new []{2,1,3},
                new []{3,2,2},
                new []{1,3,4},
            };
             AssertEqual(CalculateMaxCoins(mapF, 0, 3), 9l);
            
            var mapG = new []
            {
                new []{1,2,1},
                new []{2,3,2},
                new []{2,6,3},
                new []{2,7,10},
                new []{3,4,1},
                new []{3,5,1},
                new []{5,4,2},
                new []{6,5,1},
                new []{6,7,5},
                new []{8,7,19},
                new []{9,8,1},
            };
             AssertEqual(CalculateMaxCoins(mapG, 1, 7), 12l);
            //pentagrama
            var mapH = new []
            {
                new []{1,2,1},
                new []{1,3,2},
                new []{1,4,3},
                new []{1,5,1},
                new []{2,3,2},
                new []{2,4,1},
                new []{2,5,1},
                new []{3,4,1},
                new []{3,5,2},
                new []{4,5,2},
            };
             AssertEqual(CalculateMaxCoins(mapH, 1, 5), 8l);
            var mapJ = new []
            {
                new []{1,2,10},
                new []{1,6,1},
                new []{2,3,9},
                new []{3,4,6},
                new []{3,5,7},
                new []{4,5,5},
                new []{4,8,6},
                new []{8,7,2},
                new []{8,5,7},
                new []{7,6,1},
                new []{7,5,100},
                new []{1,2,1},
            };
             AssertEqual(CalculateMaxCoins(mapJ, 1, 5), 133l);
        }
        
        /// Тестирующая система, лучше не трогать этот код
        
        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]}");
                }
            }
        }
​
    }
    
}

Environment version: .NET 9.0.0 (9.0.0)
Newtonsoft.Json version: Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed
AutoMapper version: AutoMapper, Version=9.0.0.0, Culture=neutral, PublicKeyToken=be96cd2c38ef1005

Dumping object(MyClassDTO)
C                               : value of A
D                               : value of B
IgnoreMe                        : null
LongNumber                      : 9223372036854775807
SomeField                       : value of SomeField
SomethingNotInTheOriginalClass  : null

Cached Result
Last Run:	8:22:21 pm
Compile:	0.022s
Execute:	0.27s
Memory:	26.36Mb
CPU:	0.292s

View IL Code