Пример #1
0
        public static List <Word> CanInsertWords(CrozzlePartial cp)
        {
            List <Word>   result     = new List <Word>();
            List <string> unUsedWord = cp.GetWordlist();
            int           length     = unUsedWord.Count();
            int           max        = 0;

            for (int i = 0; i < length; i++)
            {
                List <Word> words       = RelevantWords(cp, unUsedWord[i]);
                int         wordsLength = words.Count;
                for (int j = 0; j < wordsLength; j++)
                {
                    int score = CalInsertScore(cp, words[j]);
                    words[j].SetAddScore(score);
                    result.Add(words[j]);
                }
            }
            for (int i = 0; i < result.Count; i++)
            {
                if (max < result[i].GetAddScore())
                {
                    max = result[i].GetAddScore();
                }
            }
            if (max == 0)
            {
                for (int i = 0; i < result.Count; i++)
                {
                    if (result[i].GetAddScore() < max)
                    {
                        result.Remove(result[i--]);
                    }
                }
                return(result);
            }
            for (int i = 0; i < result.Count; i++)
            {
                if (result[i].GetAddScore() < max - 1)
                {
                    result.Remove(result[i--]);
                }
            }
            return(result);
        }
Пример #2
0
        public static CrozzlePartial InsertWord(CrozzlePartial cp, Word s, int addScore)
        {
            CrozzlePartial returnCP = new CrozzlePartial();

            returnCP.SetWidth(cp.GetWidth());
            returnCP.SetHeight(cp.GetHeight());
            returnCP.SetMaxHeight(cp.GetMaxHeight());
            returnCP.SetMinHeight(cp.GetMinHeight());
            returnCP.SetMaxWidth(cp.GetMaxWidth());
            returnCP.SetMinWidth(cp.GetMinWidth());
            List <string> wordlist = new List <string>();

            for (int i = 0; i < cp.GetWordlist().Count; i++)
            {
                wordlist.Add(cp.GetWordlist()[i]);
            }
            List <Word> usedWord = new List <Word>();

            for (int i = 0; i < cp.GetUsedWord().Count; i++)
            {
                usedWord.Add(cp.GetUsedWord()[i]);
            }
            Grid grid = new Grid();

            int score = cp.GetScore();

            wordlist.Remove(s.GetWordContent());
            usedWord.Add(s);
            char[,] charGrid = new char[PublicInfo.GetFullRows(), PublicInfo.GetFullColumns()];
            for (int i = 0; i < PublicInfo.GetFullRows(); i++)
            {
                for (int j = 0; j < PublicInfo.GetFullColumns(); j++)
                {
                    charGrid[i, j] = cp.GetGrid().GetGrid()[i, j];
                }
            }
            int minHeight = cp.GetMinHeight();
            int maxHeight = cp.GetMaxHeight();
            int minWidth  = cp.GetMinWidth();
            int maxWidth  = cp.GetMaxWidth();

            if (s.GetType().Equals("ROW"))
            {
                int rows         = s.GetRows() - 1;
                int columnsBegin = s.GetColumns() - 1;
                int columnsEnd   = s.GetColumns() + s.GetWordContent().Length - 2;
                if (rows > maxHeight)
                {
                    returnCP.SetMaxHeight(rows);
                }
                if (rows < minHeight)
                {
                    returnCP.SetMinHeight(rows);
                }
                if (columnsBegin < minWidth && columnsEnd > maxWidth)
                {
                    returnCP.SetMaxWidth(columnsEnd);
                    returnCP.SetMinWidth(columnsBegin);
                }
                else if (columnsBegin < minWidth && columnsEnd <= maxWidth)
                {
                    returnCP.SetMinWidth(columnsBegin);
                }
                else if (columnsBegin >= minWidth && columnsEnd > maxWidth)
                {
                    returnCP.SetMaxWidth(columnsEnd);
                }
                for (int i = 0; i < s.GetWordContent().Length; i++)
                {
                    charGrid[s.GetRows() - 1, s.GetColumns() + i - 1] = s.GetWordContent()[i];
                }
            }
            else if (s.GetType().Equals("COLUMN"))
            {
                int columns   = s.GetColumns() - 1;
                int rowsBegin = s.GetRows() - 1;
                int rowsEnd   = s.GetRows() + s.GetWordContent().Length - 2;
                if (columns > maxWidth)
                {
                    returnCP.SetMaxWidth(columns);
                }
                if (columns < minWidth)
                {
                    returnCP.SetMinWidth(columns);
                }
                if (rowsBegin < minHeight && rowsEnd > maxHeight)
                {
                    returnCP.SetMaxHeight(rowsEnd);
                    returnCP.SetMinHeight(rowsBegin);
                }
                else if (rowsBegin < minHeight && rowsEnd <= maxHeight)
                {
                    returnCP.SetMinHeight(rowsBegin);
                }
                else if (rowsBegin >= minHeight && rowsEnd > maxHeight)
                {
                    returnCP.SetMaxHeight(rowsEnd);
                }
                for (int i = 0; i < s.GetWordContent().Length; i++)
                {
                    charGrid[s.GetRows() + i - 1, s.GetColumns() - 1] = s.GetWordContent()[i];
                }
            }
            score += addScore;
            grid.SetGrid(charGrid);
            returnCP.SetGrid(grid);
            // Set & Return
            returnCP.SetUsedWord(usedWord);
            returnCP.SetWordlist(wordlist);
            returnCP.SetGrid(grid);
            returnCP.SetScore(score);
            return(returnCP);
        }