如何在2D数组中搜索单词和替换

问题描述

我是C＃的新手。如何搜索整个单词并将其替换为我想要的单词。例如，找到“ SUCCESS”并替换为“ XXXXXXX”。正如您从if循环中看到的那样，我可以用1个单词替换它，但是我想替换整个循环。

有人可以给我提示吗？

public class CrossWordTable
    {
        public char[,] CrossWord
        {
            get
            {
                var table = new char[,]
                {
                    {'S','U','C','E','S','S' },{'E','U'},{'U','C'},{'S','S'},{'C','E'},'S'}

                };
                return table;
            }
        }

        public void PrintCrossWord()
        {
            PrintCrossWord(CrossWord);
        }

        static int[] x = { 0,-1,1,1 };
        static int[] y = { -1,-1 };

        public void PrintCrossWord(char[,] crossWordTable)
        {
            var totalRowNumber = crossWordTable.GetLength(0);
            var totalColumnNumber = crossWordTable.GetLength(1);
            String word;
            word = "SUCCESS";
            int len = word.Length;

            Console.WriteLine("*** Crossword Table *****");
            for (var row = 0; row < totalRowNumber; row++)
            {
                for (var column = 0; column < totalColumnNumber; column++)
                {
                    if (CrossWord[row,column] != word[0])
                    {



                        
                        Console.Write(crossWordTable[row,column]);
                    }
                    else
                    {
                        

                        crossWordTable[row,column] = 'X';
                        Console.Write(crossWordTable[row,column]);
                    }
                }
                Console.WriteLine();
            }
            Console.WriteLine("************************");

        }

解决方法

这是一种方法。这是一个递归解决方案。我第一次尝试重构代码失败，因此我选择不花费更多时间进行尝试。

public class CrossWordTable
    {
        private readonly char[,] _crossword;
        private readonly string _word;
        private const char MARKER = 'X';
        private readonly int _rowLength;
        private readonly int _colLength;
        private HashSet<(int,int)> _points;

        public CrossWordTable(char[,] crossword,string word)
        {
            _crossword = crossword;
            _word = word.ToUpper();
            _rowLength = _crossword.GetLength(0);
            _colLength = _crossword.GetLength(1);
            _points = new HashSet<(int,int)>();
        }

        private enum Direction { Right,Down,Left,Up,DiagonalUpRight,DiagonalUpLeft,DiagonalDownRight,DiagonalDownLeft }

        public void PrintCrossWord()
        {
            for (int i = 0; i < _rowLength; i++)
            {
                for (int j = 0; j < _colLength; j++)
                {
                    Console.Write($"{_crossword[i,j]}  ");
                }
                Console.WriteLine();
            }
        }

        public void SolveCrossWord()
        {
            for (int r = 0; r < _rowLength; r++)
            {
                for (int c = 0; c < _colLength; c++)
                {
                    Explore(r,c,Direction.Right);
                    Explore(r,Direction.Down);
                    Explore(r,Direction.Left);
                    Explore(r,Direction.Up);
                    Explore(r,Direction.DiagonalUpRight);
                    Explore(r,Direction.DiagonalUpLeft);
                    Explore(r,Direction.DiagonalDownRight);
                    Explore(r,Direction.DiagonalDownLeft);
                }
            }
            foreach (var (row,col) in _points)
            {
                _crossword[row,col] = MARKER;
            }
            PrintCrossWord();
        }

        private bool Explore(int row,int col,int wordIndex,Direction direction)
        {
            if (wordIndex == _word.Length)
                return true;
            if (_crossword[row,col] == _word[wordIndex])
            {
                if (direction == Direction.Right && col + _word.Length - wordIndex <= _colLength)
                {
                    var added = _points.Add((row,col));
                    if (!Explore(row,col + 1,wordIndex + 1,direction))
                    {
                        if (added)
                            _points.Remove((row,col));
                        return false;
                    }
                    return true;
                }
                else if (direction == Direction.Down && row + _word.Length - wordIndex <= _rowLength)
                {
                    var added = _points.Add((row,col));
                    if (!Explore(row + 1,col,col));
                        return false;
                    }
                    return true;
                }
                else if (direction == Direction.Left && col - (_word.Length - wordIndex) >= -1)
                {
                    var added = _points.Add((row,col - 1,col));
                        return false;
                    }
                    return true;
                }
                else if (direction == Direction.Up && row - (_word.Length - wordIndex) >= -1)
                {
                    var added = _points.Add((row,col));
                    if (!Explore(row - 1,col));
                        return false;
                    }
                    return true;
                }
                else if (direction == Direction.DiagonalUpRight && row - (_word.Length - wordIndex) >= -1 && col + _word.Length - wordIndex <= _colLength)
                {
                    var added = _points.Add((row,col));
                        return false;
                    }
                    return true;
                }
                else if (direction == Direction.DiagonalUpLeft && row - (_word.Length - wordIndex) >= -1 && col - (_word.Length - wordIndex) >= -1)
                {
                    var added = _points.Add((row,col));
                        return false;
                    }
                    return true;
                }
                else if (direction == Direction.DiagonalDownRight && row + _word.Length - wordIndex <= _rowLength && col + _word.Length - wordIndex <= _colLength)
                {
                    var added = _points.Add((row,col));
                        return false;
                    }
                    return true;
                }
                else if (direction == Direction.DiagonalDownLeft && row + _word.Length - wordIndex <= _rowLength && col - (_word.Length - wordIndex) >= -1)
                {
                    var added = _points.Add((row,col));
                        return false;
                    }
                    return true;
                }
            }
            return false;
        }
    }

该类采用二维数组，调用SolveCrossWord()可以解决填字游戏并打印结果。