“金箍咒”我的全排列组合算法设计演化之一重组字符串

由约瑟夫环报数出局算法串联字符串启发起

        static string 金箍(int[] 数组, int 量, int 起位, int 间隔)
        {
            string 输出 = "";
            int 数 = 0;
            do
            {
                起位 = (起位 + 间隔) % 量;
                输出 += 数组[起位] != -1 ? 数组[起位].ToString() : 数组[++起位 % 量].ToString();
                数组[起位 % 量] = -1;
            } while (量 > ++数);
            return 输出;
        }
        int[] aa = { 1, 2, 3, 4 };
        Console.WriteLine("{0}", 金箍(aa, 4, 0, 1));

            int 起 = 0, 隔 = 1, 量 = 0;
            List<string> 金箍咒 = new List<string>();
            do
            {
                int[] aa = { 1, 2, 3, 4 }; 量 = aa.Count();
                //金箍咒.Add(金箍(aa, 量, 起, 隔++));
                //if (隔 > 量) { ++起; 隔 = 1; }
                Console.WriteLine("{0}", 金箍(aa, 量, 起, 隔++));
                if (隔 >= 量) { ++起; 隔 = 1; }
            } while (起 < 量);
            //Console.WriteLine("{0}", string.Join("\n\r", 金箍咒));
            //Console.WriteLine("----");
            //Console.WriteLine("{0}", string.Join("\n\r", 金箍咒.Distinct()));

“金箍”系列下标取值组合算法：

        static string 金箍(int[] 数组, int 量, int 起位, int 间隔)
        {
            string 输出 = "", 标记 = "";
            int 数 = 0;
            do
            {
                起位 = (起位 + 间隔) % 量;
                输出 += !标记.Contains(起位.ToString() + "-") ? 数组[起位].ToString() : 数组[++起位 % 量].ToString();
                标记 += (起位 % 量).ToString() + "-";
            } while (量 > ++数);
            return 输出;
        }

 

            int[] aa = { 1, 2, 3, 4 };
            int 起 = 0, 隔 = 1, 量 = aa.Count();
            do
            {
                Console.WriteLine("{0}", 金箍(aa, 量, 起, 隔++));
                if (隔 >= 量) { ++起; 隔 = 1; }
            } while (起 < 量);

 

        static string 金箍(string 字符串, int 量, int 起位, int 间隔)
        {
            string 输出 = "", 标记 = "";if(字符串.Count(a => a == '1') > 1)Console.WriteLine("取值错误出现重复");
            int 数 = 0;
            do
            {
                起位 = (起位 + 间隔) % 量;
                输出 += !标记.Contains(起位.ToString() + "-") ? 字符串[起位].ToString() : 字符串[++起位 % 量].ToString();
                标记 += (起位 % 量).ToString() + "-";
            } while (量 > ++数);
            return 输出;
        }

 

        static string[] 对换(string 字符串, int 量)
        {/*偶数的*/                               
            string[] 输出 = new string[量 / 2];
            char[] 字符串组 = 字符串.ToCharArray();
            int 数 = 0; //Console.Clear();          
            do
            {
                int 读 = 数 % 量;
                char 前 = 字符串组[读];
                字符串组[读] = 字符串组[(读 + 1) % 量];
                字符串组[(读 + 1) % 量] = 前;
                输出[数 / 2] = string.Join("", 字符串组);
            } while ((数 += 2) < 量);
            return 输出;
        }

 

        static string 金箍换(string 字符串, int 量, int 起位)
        {/*不用转换为数组进行相邻交换的算法*/
            string 输出 = "";
            int 数 = (起位 + 1) % 量 == 0 ? 1 : 0;
            do
            {
                if (数 < 起位)
                    输出 += 字符串[数++].ToString();
                else if (数 == 起位)
                {
                    输出 += 字符串[(数 + 1) % 量].ToString() + 字符串[数].ToString();
                    数 += 2; 
                }
                else if (数 > 起位)
                    输出 += 字符串[数++ % 量].ToString();
            } while (数 < 量);
            return 输出;
        }

修改为可按指定位置交换的算法：

        static string 金箍换(string 字符串, int 量, int 起位, int 间隔)
        {/*不用转换为数组进行相邻或指定交换的算法*/
            起位 %= 量;
            string 输出 = ""; //if (量 <= 起位) return "起位超过函数可运行范围";
            int 调位 = (起位 + 1 + 间隔) % 量, 数 = 调位 == 0 ? 1 : 0;
            do
            {
                if (数 < 起位)
                { 
                    输出 += 数 != 调位 ? 字符串[数].ToString() : ""; 
                    数++;
                }
                else if (数 == 起位)
                {
                    输出 += 字符串[调位].ToString();
                    if (间隔 > 0)
                    {
                        int 计 = 0;
                        do
                        {
                            int 范围 = (数 + 1 + 计) % 量;
                            if (范围 == 0) break;
                            输出 += 字符串[范围].ToString();
                        } while (++计 < 间隔);
                    }
                    输出 += 字符串[数].ToString();
                    数 += 2 + 间隔;
                }
                else if (数 > 起位)
                    输出 += 字符串[数++ % 量].ToString();
            } while (数 < 量);
            return 输出;
        }

 

Console.Write(金箍换("123456", 6, 4, 3));