Tag: word search

Wordseach c# – WordToSearchGrid

The WordToSearchGrid is basically the last part of the beginning part of the wordsearch project. It brings together the grid class (which it in inheriting from) and the word class.

The direction of the words are like a compass directions, north, south, east and west and the north east, south east, north west and south west. Their are 8 directions in total that a word can take.

The getWords function gets the words to search for.

For testing, I have overloaded the createRowGrid method in the grid class. So just need to comment out the method in the class below.

I have already done a version of this code in PHP and more of a detailed information about the createSearchGrid method is on this PHP WordToSearchGrid webpage. But hopefully the comments are good enough in the code below to explain why and what is happening.

To compile up the whole thing, the Word and Grid classes will need to be included in the source code.

using System;
using System.Xml;
using System.Collections;
 
namespace wordsearchcsharp
{
	/*
	 * WordToSearchGrid extends / Inheritance from the base Grid class
	 * so that the basics of the grid class can be used e.g. creation of a random grid etc.
	 */
 
	class WordToSearchGrid : Grid
	{
		// I like to use privates instead of protected variables so that each class
		// has access to there private variables
		private String[] _words;
 
		// the constructor to call the base constructor would use 
		public WordToSearchGrid() : base() {}
		public WordToSearchGrid(int size) : base (size) {}
 
                // create a empty grid - override ('new') the base class method.
		public override char[] createGridRow()
		{
			char[] retArray = new char[returnSize()];
			for (int i =0; i < returnSize(); i++)
			{
				retArray[i] = ' ';
			}
			return retArray;
		}
 
		// get the words from the words class into this class.
		public void getWords(String[] wordsArray)
		{
			this._words = wordsArray;
		}
 
	    // print out the words to search for that have been inserted into the grid
		public void printTheWordsToSearch()
		{
			Console.WriteLine("Words to search for : ");
			foreach (string st in this._words)
			{
				Console.WriteLine(st);
			}
		}
 
		// insertIntoGrid at point position X (pX) and Y (pY) with the word and direction
		public void insertIntoGrid(int pX, int pY, String word, int direction)
		{
			int wordLen = word.Length;
 
			// move the starting point of the word to the correct place within the grid
			// the default is north and west, so will need to correct for south and east directions.
			if (direction >= 4 && direction <=6) pY-=(wordLen-1);
			if (direction >= 2 && direction <=4) pX-=(wordLen-1);
 
			// 1 = north , 2 = north east, 3 = east, 4 = south east, 5 = south, 6 = south west, 7 = west, 8= north west
			// process each letter of the word and move the position to insert in the correct direction
			for (int i =0; i < wordLen; i++)
			{
				insertCharIntoGrid(pX, pY, word[i]);
				switch (direction)
				{
			      case 1 : pY--; break;
			      case 2 : pY--; pX++; break;
			      case 3 : pX++; break;
			      case 4 : pY++; pX++; break;
			      case 5 : pY++; break;
			      case 6 : pY++; pX--; break;
			      case 7 : pX--; break;
			      case 8 : pY--; pX--; break;
			      default : break;
				}
			}
		}
 
	    // createSearchGrid, will insert the words onto a blank grid (for testing).
	    // in random places and directions.
		public void createSearchGrid()
		{
			Random rand = new Random((int)DateTime.Now.Ticks);
			int wordLen, direction, pointX, pointY, space, spaceY, spaceX;
			// loop thought the words to insert
			for (int i =0; i < _words.Length; i++)
			{
				wordLen = _words[i].Length;
				// if the word is larger than the size of the grid, it cannot be inserted.
 
			    // NOTE : at present there is no intersection (crossing search words) shall do in the next version
				if (wordLen < _size)
				{
			        //need to pick a direction and also a point on the grid.
			        // also need to try and place the word onto the grid x amount of times else break out.
					direction = rand.Next(1, _size);
					pointX = rand.Next(1, _size);
					pointY = rand.Next(1,_size);
 
				    // the remainder of the subtracting the points from the size of grid will basically say how much space is required
					space = _size - wordLen;
 
				    // check against the direction and the size of the word against where it is on the poistion in the grid
				    // 1 = north , 2 = north east, 3 = east, 4 = south east, 5 = south, 6 = south west, 7 = west, 8= north west
				    // from the points point of view.
					spaceY = _size - pointY;
					spaceX = _size - pointX;
 
				    // if the direction is not east or west, and there is not enought space, move the insertion pointY difference
					// north and south
					if (!((direction == 7) || (direction == 3)))
					{
						if (spaceY > space)
							pointY+= (spaceY - space);
					}
 
			        // if the direction is not north or south and there is not enought space, move the insertion pointX difference
			        // east and west.
					if (!((direction == 1) || (direction == 5)))
					{
						if (spaceX > space)
							pointX+= (spaceX - space);
					}
					this.insertIntoGrid(pointX, pointY, _words[i], direction);
				}
				else
				{
					Console.WriteLine("Word : " + _words[i] + " is too long for the grid of size " + _size);
				}
			}
		}
 
	}
 
	class MainClass
	{
		public static void Main(string[] args)
		{
			Word word = new Word("words.xml",3);
			WordToSearchGrid gridWithWords = new WordToSearchGrid();
 
			// place the words into the WordToSearchGrid 
			gridWithWords.getWords(word.returnWords());
			// create a search grid with the words passed above.
			gridWithWords.createSearchGrid();
			// print out the grid		
			gridWithWords.printOutGrid();
			// print out the words to search
			gridWithWords.printTheWordsToSearch();
			// of course could have used the Word class
			// but since this is the WordToSearchGrid, so just placed one method in there as well.
			word.printOutWords();
		}
	}
}

and a example output would be with the testing blank grid created.

The Grid
0 ..0 =  1 =  2 =  3 =  4 =  5 =  6 =  7 =  8 =  9 =  10 =  
1 ..0 =  1 =  2 =  3 =  4 =  5 =  6 =  7 =  8 = o9 =  10 =  
2 ..0 =  1 =  2 =  3 =  4 =  5 =  6 =  7 =  8 =  9 = l10 =  
3 ..0 =  1 =  2 =  3 =  4 =  5 =  6 =  7 =  8 =  9 =  10 = d
4 ..0 =  1 =  2 =  3 =  4 =  5 =  6 =  7 =  8 =  9 =  10 =  
5 ..0 =  1 =  2 =  3 =  4 = s5 =  6 =  7 =  8 =  9 =  10 =  
6 ..0 =  1 =  2 =  3 =  4 =  5 = o6 =  7 =  8 =  9 =  10 =  
7 ..0 =  1 =  2 =  3 =  4 =  5 =  6 = l7 =  8 =  9 =  10 = w 
8 ..0 =  1 =  2 =  3 =  4 =  5 =  6 =  7 = e8 =  9 =  10 = a 
9 ..0 =  1 =  2 =  3 =  4 =  5 =  6 =  7 =  8 =  9 =  10 = s
10 ..0 =  1 =  2 =  3 =  4 =  5 =  6 =  7 =  8 =  9 =  10 =  
Words to search for : 
old
was
sole
Words : (  0 = old  1 = was  2 = sole)

and output without the testing blank grid

The Grid
0 ..0 = u1 = r2 = s3 = f4 = x5 = b6 = a7 = o8 = m9 = j10 = m
1 ..0 = s1 = s2 = o3 = l4 = e5 = k6 = h7 = g8 = v9 = e10 = h
2 ..0 = a1 = y2 = l3 = a4 = q5 = a6 = q7 = i8 = x9 = s10 = i
3 ..0 = t1 = j2 = q3 = x4 = r5 = b6 = s7 = m8 = g9 = f10 = d
4 ..0 = m1 = t2 = v3 = u4 = r5 = c6 = t7 = q8 = o9 = s10 = w
5 ..0 = g1 = f2 = c3 = s4 = r5 = d6 = v7 = u8 = x9 = f10 = r
6 ..0 = n1 = c2 = s3 = q4 = v5 = t6 = f7 = w8 = a9 = t10 = s
7 ..0 = h1 = m2 = y3 = o4 = v5 = u6 = h7 = b8 = i9 = h10 = n
8 ..0 = b1 = w2 = e3 = m4 = e5 = h6 = j7 = f8 = d9 = t10 = i
9 ..0 = u1 = i2 = j3 = k4 = w5 = w6 = l7 = k8 = l9 = h10 = c
10 ..0 = o1 = s2 = o3 = i4 = w5 = x6 = n7 = o8 = o9 = t10 = w
Words to search for : 
he
sole
old
Words : (  0 = he  1 = sole  2 = old)