【原创】2048游戏核心算法

da11

        //以下是2048核心算法主Main部分--------------------------------------------------------------------------
        private static void Main()
        {
            //初始化二维数组的另一种写法
            int[,] GameMaxSz = new int[4,4]
                {
                    {2,2,4,8},
                    {2,4,4,4},
                    {0,8,4,0},
                    {2,4,0,4}
                };

            /*
            GameMaxSz[1, 0] = 2;
            GameMaxSz[2, 0] = 2;
            GameMaxSz[3, 0] = 2;

            GameMaxSz[1, 1] = 2;
            GameMaxSz[3, 1] = 2;

            GameMaxSz[0, 2] = 4;
            GameMaxSz[1, 2] = 4;
            GameMaxSz[2, 2] = 2;
            GameMaxSz[3, 2] = 2;

            GameMaxSz[0, 3] = 4;
            GameMaxSz[1, 3] = 4;
            GameMaxSz[3, 3] = 2;
            */

            Console.WriteLine("输入wsad操作上下左右");
            string MoveButton = Console.ReadLine();
            if (MoveButton == "w")
            {
                GameUpSf(GameMaxSz);
            }
            else if(MoveButton=="s")
            {
                GameDownSf(GameMaxSz);
            }
            else if (MoveButton == "a")
            {
                GameLeftSf(GameMaxSz);
            }
            else
            {
                GameRightSf(GameMaxSz);
            }

            Console.ReadLine();
        }

        //打印出二维数组表格的方法
        private static void PrintSzToBG(int[,] GameMaxSz)
        {
            for (int HS = 0; HS < GameMaxSz.GetLength(0); HS++)
            {
                for (int LS = 0; LS < GameMaxSz.GetLength(1); LS++)
                {
                    Console.Write(GameMaxSz[HS, LS] + "\t");
                }
                Console.WriteLine("");
            }
        }

        //2048核心算法之-上移算法
        private static void GameUpSf(int[,] GameMaxSz)
        {
            //首先打印下数组
            PrintSzToBG(GameMaxSz);
            Console.ReadLine();

            //向上移动的行数for循环
            for (int HS = 0; HS < GameMaxSz.GetLength(0); HS++)
            {
                //向上移动的列数for循环
                for (int LS = 0; LS < GameMaxSz.GetLength(1); LS++)
                {
                    //检查判断数组中是否不为0，不为0才可允许向上移动
                    if (GameMaxSz[HS, LS] != 0)
                    {
                        //行数如果在首行，则跳过循环
                        if (HS == 0)
                        {
                            continue;
                        }
                        //检查判断数组中第一行是否等于0，等于0说明第一行没有数据，可以放在第一行中
                        if (GameMaxSz[0, LS] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[0, LS] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中第二行是否等于0，等于0说明第二行没有数据，可以放在第二行中，出现此判断代表前者有数据，可以判断是否想等然后合并
                        else if (GameMaxSz[1, LS] == 0)
                        {                           
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[0 + 1, LS] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中第三行是否等于0，等于0说明第三行没有数据，可以放在第三行中，出现此判断代表前者有数据，可以判断是否想等然后合并
                        else if (GameMaxSz[2, LS] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[0 + 2, LS] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中其余行是否等于0，等于0说明第0、一、二行都是有数据的，需要放在第四行中，出现此判断代表前者有数据，可以判断是否想等然后合并
                        else if(GameMaxSz[3,LS]==0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[0 + 3, LS] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }

                    }
                    //向上移动if结束

                }
                //向上移动的列数for循环结束


            }
            //向上移动的行数for循环结束

            //调试行
            PrintSzToBG(GameMaxSz);
            Console.WriteLine("");

            //合并的列数for循环--注意，因为这里是向上移动方法，所以合并的时候推荐使用列数为外层循环
            for (int LS = 0; LS < GameMaxSz.GetLength(1); LS++)
            {
                //合并的行数for循环--注意，因为这里是向上移动方法，所以合并的时候推荐使用行数为内层循环
                for (int HS = 0; HS < GameMaxSz.GetLength(0); HS++)
                {
                    if (HS + 1 < GameMaxSz.GetLength(0))
                    {
                        //判断是否与下一个行数的值相等
                        if (GameMaxSz[HS, LS] == GameMaxSz[HS + 1, LS])
                        {
                            //相等则将两个数值相加，并赋值一个变量，后将变量转移转移至此列的首行
                            int Temp = GameMaxSz[HS, LS] + GameMaxSz[HS + 1, LS];
                            GameMaxSz[HS, LS] = Temp;
                            GameMaxSz[HS + 1, LS] = 0;

                            //判断相隔两行之后是否大于数组的行数界限
                            if (HS + 2 < GameMaxSz.GetLength(0))
                            {
                                //判断相隔两行之后的数值是否有数据，有数据则赋值给相隔一行的位置
                                if (GameMaxSz[HS + 2, LS] != 0)
                                {
                                    GameMaxSz[HS + 1, LS] = GameMaxSz[HS + 2, LS];
                                    GameMaxSz[HS + 2, LS] = 0;
                                }
                            }

                            //判断相隔三行之后是否大于数组的行数界限
                            if (HS + 3 < GameMaxSz.GetLength(0))
                            {
                                //判断相隔三行之后的数值是否有数据，有数据则赋值给相隔两行的位置
                                if (GameMaxSz[HS + 3, LS] != 0)
                                {
                                    GameMaxSz[HS + 2, LS] = GameMaxSz[HS + 3, LS];
                                    GameMaxSz[HS + 3, LS] = 0;
                                }
                            }

                            //判断相等值之后跳出循环，2048游戏规则为只能执行一次，所以只要每列执行一次if语句即可跳出内层循环（行数）
                            break;
                        }
                    }
                }               
            }


            PrintSzToBG(GameMaxSz);

        }
        //上移方法结束

        //2048核心算法之-下移算法
        private static void GameDownSf(int[,] GameMaxSz)
        {
            //首先打印下数组
            PrintSzToBG(GameMaxSz);
            Console.ReadLine();

            //向下移动的行数for循环
            for (int HS = GameMaxSz.GetLength(0)-1; HS >=0; HS--)
            {
                //向下移动的列数for循环
                for (int LS = GameMaxSz.GetLength(1)-1; LS >=0 ; LS--)
                {
                    //检查判断数组中是否不为0，不为0才可允许向下移动
                    if (GameMaxSz[HS, LS] != 0)
                    {
                        //行数如果在最下面那行，则跳过循环
                        if (HS == 3)
                        {
                            continue;
                        }
                        //检查判断数组中倒数一行是否等于0，等于0说明倒数第一行没有数据，可以放在倒数第一行中
                        if (GameMaxSz[3, LS] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[3, LS] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中倒数第二行是否等于0，等于0说明倒数第二行没有数据，可以放在倒数第二行中
                        else if (GameMaxSz[2, LS] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[2, LS] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中倒数第三行是否等于0，等于0说明倒数第三行没有数据，可以放在倒数第三行中
                        else if (GameMaxSz[1, LS] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[1, LS] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中其余行是否等于0，等于0说明倒数第0、一、二行都是有数据的，需要放在倒数第四行中
                        else if (GameMaxSz[0, LS] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[0, LS] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }

                    }
                    //向下移动if结束

                }
                //向下移动的列数for循环结束


            }
            //向下移动的行数for循环结束

            //调试行
            PrintSzToBG(GameMaxSz);
            Console.WriteLine("");

            //合并的列数for循环--注意，因为这里是向下移动方法，所以合并的时候推荐使用列数为外层循环
            for (int LS = GameMaxSz.GetLength(1)-1; LS >=0; LS--)
            {
                //合并的行数for循环--注意，因为这里是向下移动方法，所以合并的时候推荐使用行数为内层循环
                for (int HS = GameMaxSz.GetLength(0)-1; HS >=0 ; HS--)
                {
                    if (HS - 1 >= 0)
                    {
                        //判断是否与上一个行数的值相等
                        if (GameMaxSz[HS, LS] == GameMaxSz[HS - 1, LS])
                        {
                            //相等则将两个数值相加，并赋值一个变量，后将变量转移转移至此列的尾行
                            int Temp = GameMaxSz[HS, LS] + GameMaxSz[HS - 1, LS];
                            GameMaxSz[HS, LS] = Temp;
                            GameMaxSz[HS - 1, LS] = 0;

                            //判断相隔两行之后是否大于数组的行数界限
                            if (HS - 2 >= 0)
                            {
                                //判断相隔两行之后的数值是否有数据，有数据则赋值给相隔一行的位置
                                if (GameMaxSz[HS - 2, LS] != 0)
                                {
                                    GameMaxSz[HS - 1, LS] = GameMaxSz[HS - 2, LS];
                                    GameMaxSz[HS - 2, LS] = 0;
                                }
                            }

                            //判断相隔三行之后是否大于数组的行数界限
                            if (HS - 3 >= 0)
                            {
                                //判断相隔三行之后的数值是否有数据，有数据则赋值给相隔两行的位置
                                if (GameMaxSz[HS - 3, LS] != 0)
                                {
                                    GameMaxSz[HS - 2, LS] = GameMaxSz[HS - 3, LS];
                                    GameMaxSz[HS - 3, LS] = 0;
                                }
                            }

                            //判断相等值之后跳出循环，2048游戏规则为只能执行一次，所以只要每列执行一次if语句即可跳出内层循环（行数）
                            break;
                        }
                    }
                }
            }


            PrintSzToBG(GameMaxSz);

        }
        //下移方法结束

        //2048核心算法之-左移算法
        private static void GameLeftSf(int[,] GameMaxSz)
        {
            //首先打印下数组
            PrintSzToBG(GameMaxSz);
            Console.ReadLine();

            //向左移动的行数for循环--和上移相反，外层循环是列数，内层循环是行数
            for (int LS = 0; LS < GameMaxSz.GetLength(0); LS++)
            {
                //向上移动的列数for循环
                for (int HS = 0; HS < GameMaxSz.GetLength(1); HS++)
                {
                    //检查判断数组中是否不为0，不为0才可允许向上移动
                    if (GameMaxSz[HS, LS] != 0)
                    {
                        //列数如果在首列，则跳过循环
                        if (LS == 0)
                        {
                            continue;
                        }
                        //检查判断数组中第一列是否等于0，等于0说明第一列没有数据，可以放在第一列中
                        if (GameMaxSz[HS, 0] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[HS, 0] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中第二列是否等于0，等于0说明第二列没有数据，可以放在第二列中
                        else if (GameMaxSz[HS, 1] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[HS, 1] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中第三列是否等于0，等于0说明第三列没有数据，可以放在第三列中
                        else if (GameMaxSz[HS, 2] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[HS, 2] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中其余列是否等于0，等于0说明第0、一、二列都是有数据的，需要放在第四列中
                        else if (GameMaxSz[HS, 3] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[HS, 3] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }

                    }
                    //向左移动if结束----修改至此

                }
                //向左移动的行数for循环结束


            }
            //向左移动的列数for循环结束

            //调试行
            PrintSzToBG(GameMaxSz);
            Console.WriteLine("");

            //合并的行数for循环--注意，因为这里是向左移动方法，所以合并的时候推荐使用行数为外层循环
            for (int HS = 0; HS < GameMaxSz.GetLength(0); HS++)
            {
                //合并的行数for循环--注意，因为这里是向左移动方法，所以合并的时候推荐使用列数为内层循环
                for (int LS = 0; LS < GameMaxSz.GetLength(1); LS++)
                {
                    if (LS + 1 < GameMaxSz.GetLength(1))
                    {
                        //判断是否与下一个列数的值相等
                        if (GameMaxSz[HS, LS] == GameMaxSz[HS, LS + 1])
                        {
                            //相等则将两个数值相加，并赋值一个变量，后将变量转移转移至此行的首列
                            int Temp = GameMaxSz[HS, LS] + GameMaxSz[HS, LS + 1];
                            GameMaxSz[HS, LS] = Temp;
                            GameMaxSz[HS, LS + 1] = 0;

                            //判断相隔两列之后是否大于数组的列数界限
                            if (LS + 2 < GameMaxSz.GetLength(1))
                            {
                                //判断相隔两列之后的数值是否有数据，有数据则赋值给相隔一列的位置
                                if (GameMaxSz[HS, LS + 2] != 0)
                                {
                                    GameMaxSz[HS, LS + 1] = GameMaxSz[HS, LS + 2];
                                    GameMaxSz[HS, LS + 2] = 0;
                                }
                            }

                            //判断相隔三列之后是否大于数组的列数界限
                            if (LS + 3 < GameMaxSz.GetLength(1))
                            {
                                //判断相隔三列之后的数值是否有数据，有数据则赋值给相隔两列的位置
                                if (GameMaxSz[HS, LS + 3] != 0)
                                {
                                    GameMaxSz[HS, LS + 2] = GameMaxSz[HS, LS + 3];
                                    GameMaxSz[HS, LS + 3] = 0;
                                }
                            }

                            //判断相等值之后跳出循环，2048游戏规则为只能执行一次，所以只要每列执行一次if语句即可跳出内层循环（行数）
                            break;
                        }
                    }
                }
            }


            PrintSzToBG(GameMaxSz);

        }
        //左移方法结束

        //2048核心算法之-右移算法
        private static void GameRightSf(int[,] GameMaxSz)
        {
            //首先打印下数组
            PrintSzToBG(GameMaxSz);
            Console.ReadLine();

            //向右移动的行数for循环
            for (int LS = GameMaxSz.GetLength(0)-1; LS >=0; LS--)
            {
                //向右移动的列数for循环
                for (int HS = GameMaxSz.GetLength(1)-1; HS >=0 ; HS--)
                {
                    //检查判断数组中是否不为0，不为0才可允许向右移动
                    if (GameMaxSz[HS, LS] != 0)
                    {
                        //列数如果在尾列，则跳过循环
                        if (LS == 3)
                        {
                            continue;
                        }
                        //检查判断数组中第4列是否等于0，等于0说明第4列没有数据，可以放在第4列中
                        if (GameMaxSz[HS, 3] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[HS, 3] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中第3列是否等于0，等于0说明第3列没有数据，可以放在第3列中
                        else if (GameMaxSz[HS, 2] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[HS, 2] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中第2列是否等于0，等于0说明第2列没有数据，可以放在第2列中
                        else if (GameMaxSz[HS, 1] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[HS, 1] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }
                        //检查判断数组中其余列是否等于0，等于0说明第4、3、2列都是有数据的，需要放在第1列中
                        else if (GameMaxSz[HS, 0] == 0)
                        {
                            int UpTemp = GameMaxSz[HS, LS];
                            GameMaxSz[HS, 0] = UpTemp;
                            GameMaxSz[HS, LS] = 0;
                        }

                    }
                    //向右移动if结束

                }
                //向右移动的行数for循环结束


            }
            //向右移动的列数for循环结束

            //调试行
            PrintSzToBG(GameMaxSz);
            Console.WriteLine("");

            //合并的行数for循环--注意，因为这里是向右移动方法，所以合并的时候推荐使用行数为外层循环
            for (int HS = GameMaxSz.GetLength(0)-1; HS >=0 ; HS--)
            {
                //合并的行数for循环--注意，因为这里是向左移动方法，所以合并的时候推荐使用列数为内层循环
                for (int LS = GameMaxSz.GetLength(1)-1; LS >=0 ; LS--)
                {
                    if (LS - 1 >= 0)
                    {
                        //判断是否与下一个列数的值相等
                        if (GameMaxSz[HS, LS] == GameMaxSz[HS, LS - 1])
                        {
                            //相等则将两个数值相加，并赋值一个变量，后将变量转移转移至此行的尾列
                            int Temp = GameMaxSz[HS, LS] + GameMaxSz[HS, LS - 1];
                            GameMaxSz[HS, LS] = Temp;
                            GameMaxSz[HS, LS - 1] = 0;

                            //判断相隔两列之后是否大于数组的列数界限
                            if (LS - 2 >= 0)
                            {
                                //判断相隔两列之后的数值是否有数据，有数据则赋值给相隔一列的位置
                                if (GameMaxSz[HS, LS - 2] != 0)
                                {
                                    GameMaxSz[HS, LS - 1] = GameMaxSz[HS, LS - 2];
                                    GameMaxSz[HS, LS - 2] = 0;
                                }
                            }

                            //判断相隔三列之后是否大于数组的列数界限
                            if (LS - 3 >= 0)
                            {
                                //判断相隔三列之后的数值是否有数据，有数据则赋值给相隔两列的位置
                                if (GameMaxSz[HS, LS - 3] != 0)
                                {
                                    GameMaxSz[HS, LS - 2] = GameMaxSz[HS, LS - 3];
                                    GameMaxSz[HS, LS - 3] = 0;
                                }
                            }

                            //判断相等值之后跳出循环，2048游戏规则为只能执行一次，所以只要每列执行一次if语句即可跳出内层循环（行数）
                            break;
                        }
                    }
                }
            }


            PrintSzToBG(GameMaxSz);

        }
        //右移方法结束

da11

        //以下内容为2048核心算法复习主Main--优化

        //2048核心算法新思路分析
        //方法一：将有用的数值（非0）移至后面
        //方法二：合并方法，将相同的数值合并，并再次调用方法一，去零方法
        //方法三：上移方法，将二维数组的一列数据，从上至下获取成一个一维数组
        //方法四：下移方法，将二维数组的一列数据，从下至上获取成一个一维数组
        //方法五：左移方法，将二维数组的一行数据，从左至右获取成一个一维数组
        //方法六：右移方法，将二维数组的一行数据，从右至左获取成一个一维数组


        private static void Main()
        {
        //初始化二维数组，并赋值初始值
            int[,] GameMapSZ = new int[4, 4]
        {
            {2,0,0,8},
            {0,2,2,4},
            {2,4,0,4},
            {4,0,0,2}
        };
            PrintErSZSF(GameMapSZ);
            Console.ReadLine();

            GameMapSZ =  GameRightSF(GameMapSZ);
            PrintErSZSF(GameMapSZ);
            Console.ReadLine();
        }
        //2048主Main方法结束

        //以表格的形式显示二维数组的方法
        private static void PrintErSZSF(int[,] Array)
        {
            for (int WC = 0; WC < Array.GetLength(0); WC++)
            {
                for (int NC = 0; NC < Array.GetLength(1); NC++)
                {
                    Console.Write(Array[WC,NC] + "\t");
                }
                //内层for循环结束
                Console.WriteLine("");
            }
            //外层for循环结束
        }
        //显示方法结束

        //方法一：将有用的数值（非0）移至前面
        private static int[] DropZeroSF(int[] Array)
        {
            for (int WC = 0; WC < Array.Length-1; WC++)
            {
                if (Array[WC] == 0)
                {
                    if (WC + 2 < Array.Length)
                    {
                        if (Array[WC + 1] == 0)
                        {
                            int Temp1 = Array[WC];
                            Array[WC] = Array[WC + 2];
                            Array[WC + 2] = Temp1;
                            continue;
                        }
                    }
                    int Temp = Array[WC];
                    Array[WC] = Array[WC + 1];
                    Array[WC + 1] = Temp;
                }
            }
            return Array;
        }

        //方法二：合并方法，将相同的数值合并，并再次调用方法一，去零方法
        private static int[] HBSF(int[] Array)
        {
            for (int WC = 0; WC < Array.Length; WC++)
            {
                if (Array[WC] == Array[WC + 1])
                {
                    Array[WC] = Array[WC] + Array[WC + 1];
                    Array[WC + 1] = 0;
                    Array =  DropZeroSF(Array);
                    break;
                }            
            }
            return Array;
        }

        //方法三：上移方法，将二维数组的一列数据，从上至下获取成一个一维数组
        private static int[,] GameUpSF(int[,] Array)
        {
            for (int LS = 0; LS < Array.GetLength(1); LS++)
            {
                int[] OneSz = new int[Array.GetLength(0)];

                for (int HS = 0; HS < Array.GetLength(0); HS++)
                {                  
                    OneSz[HS] =  Array[HS, LS];
                }

                OneSz = DropZeroSF(OneSz);
                OneSz = HBSF(OneSz);

                for (int HS = 0; HS < Array.GetLength(0); HS++)
                {
                    Array[HS, LS] = OneSz[HS];
                }

            }
            return Array;

        }

        //方法四：下移方法，将二维数组的一列数据，从下至上获取成一个一维数组
        private static int[,] GameDownSF(int[,] Array)
        {
            for (int LS = Array.GetLength(1)-1; LS >=0 ; LS--)
            {
                int[] OneSz = new int[Array.GetLength(1)];

                for (int HS = Array.GetLength(0)-1; HS >=0 ; HS--)
                {
                    OneSz[3-HS] = Array[HS, LS];
                }

                OneSz = DropZeroSF(OneSz);
                OneSz = HBSF(OneSz);

                for (int HS = Array.GetLength(0)-1; HS >= 0; HS--)
                {
                    Array[HS, LS] = OneSz[3 - HS];
                }

            }
            return Array;

        }

        //方法五：左移方法，将二维数组的一列数据，从左至右获取成一个一维数组
        private static int[,] GameLeftSF(int[,] Array)
        {
            for (int HS = 0; HS < Array.GetLength(0); HS++)
            {
                int[] OneSz = new int[Array.GetLength(1)];

                for (int LS = 0; LS < Array.GetLength(1); LS++)
                {
                    OneSz[LS] = Array[HS, LS];
                }

                OneSz = DropZeroSF(OneSz);
                OneSz = HBSF(OneSz);

                for (int LS = 0; LS < Array.GetLength(1); LS++)
                {
                    Array[HS, LS] = OneSz[LS];
                }

            }
            return Array;

        }

        //方法六：右移方法，将二维数组的一行数据，从右至左获取成一个一维数组
        private static int[,] GameRightSF(int[,] Array)
        {
            for (int HS = Array.GetLength(0)-1; HS >=0 ; HS--)
            {
                int[] OneSz = new int[Array.GetLength(0)];

                for (int LS = Array.GetLength(1)-1; LS >=0 ; LS--)
                {
                    OneSz[(Array.GetLength(1)-1)-LS] = Array[HS, LS];
                }

                OneSz = DropZeroSF(OneSz);
                OneSz = HBSF(OneSz);

                for (int LS = Array.GetLength(1) - 1; LS >= 0; LS--)
                {
                    Array[HS, LS] = OneSz[(Array.GetLength(1) - 1) - LS];
                }

            }
            return Array;

        }