using System;

using System.Collections.Generic;

​

namespace ShuffleCharacters

{

    public static class StringExtension

    {

        public static string ShuffleChars(string source, int count)

        {

            if (count == 0)

            {

                return source;

            }

​

            var shuffleMap = CalculateShuffleMap(source, count);

​

            var sourceCharArray = source.ToCharArray();

​

            var resultChars = Shuffle(shuffleMap, sourceCharArray);

​

            var charsList = new List<char>(resultChars);

            var charsArray = charsList.ToArray();

​

            var resultString = new string(charsArray);

​

            return resultString;

        }

​

        private static int[] CalculateShuffleMap(string source, int count)

        {

            var length = source.Length;

​

            var baseMap = CreateMap(length);

​

            if (count == 1)

            {

                return baseMap;

            }

​

            var sourceMap = new int[length];

            var resultMap = new int[length];

​

            Array.Copy(baseMap, resultMap, length);

​

            var mapRepeatPeriod = 0;

​

            for (var i = 1; i < count; i++)

            {

                SwapAndShuffle(baseMap, ref sourceMap, ref resultMap);

​

                // Этот код позволяет оптимизировать алгоритм, за счёт обнаружения периода повторения перестановок.

                var sameAsBase = IsEquals(baseMap, resultMap);

                if (sameAsBase)

                {

                    // В случае обнаружения периода, запоминаем его значение и выходим из цикла.

                    mapRepeatPeriod = i;

                    break;

                }

            }

​

            // Если был обнаружен период перестановок...

            if (mapRepeatPeriod > 0)

            {

                // Находим остаток необходимого количества перестановок

                var mapShuffleCountReminder = count % mapRepeatPeriod;

                // Выполняем остаток перестановок

                for (var i = 1; i < mapShuffleCountReminder; i++)

                {

                    SwapAndShuffle(baseMap, ref sourceMap, ref resultMap);

                }

            }

​

            return resultMap;

        }

​

        private static void SwapAndShuffle(int[] baseMap, ref int[] sourceMap, ref int[] targetMap)

        {

            var temp = targetMap;

            targetMap = sourceMap;

            sourceMap = temp;

​

            Shuffle(baseMap, sourceMap, targetMap);

        }

​

        private static bool IsEquals<T>(IEnumerable<T> a, IEnumerable<T> b)

        {

            var aEnumerator = a.GetEnumerator();

            var bEnumerator = b.GetEnumerator();

​

            while (aEnumerator.MoveNext() && bEnumerator.MoveNext())

            {

                if (!aEnumerator.Current.Equals(bEnumerator.Current))

                {

                    return false;

                }

            }

​

            var bothFinished = !aEnumerator.MoveNext() && !bEnumerator.MoveNext();

            return bothFinished;

        }

​

        private static void Shuffle<T>(IEnumerable<int> map, T[] sourceItems, T[] targetItems)

        {

            var i = 0;

            foreach (var sourceIndex in map)

            {

                targetItems[i] = sourceItems[sourceIndex];

                i++;

            }

        }

​

        private static IEnumerable<T> Shuffle<T>(IEnumerable<int> map, T[] items)

        {

            foreach (var sourceIndex in map)

            {

                yield return items[sourceIndex];

            }

        }

​

        private static int[] CreateMap(int length)

        {

            var map = new int[length];

            var middle = (length + 1) / 2;

​

            for (var i = 0; i < middle; i++)

            {

                map[i] = i * 2;

            }

​

            for (var i = middle; i < length; i++)

            {

                map[i] = (i - middle) * 2 + 1;

            }

​

            return map;

        }

    }

}

​