Week 1 Assignment Word Search

Size: px

Start display at page:

Download "Week 1 Assignment Word Search"

Jewel Stevens
5 years ago
Views:

1 Week 1 Assignment Word Search Overview For this assignment, you will program functionality relevant to a word search puzzle game, the game that presents the challenge of discovering specific words in a twodimensional grid of random letters. You will be given 2.txt files, one containing the puzzle board (2D grid of letters), and another containing a set of words ( guesses ) that may or may not exist in the puzzle. Your job is to write a class that searches for the guess words inside the puzzle and returns the words it found. More precisely, you will write 3 separate search routines, a naïve search, a dataset transformation search, and finally your own custom search (whatever you want to do, so long as it meets the criteria specified below). A Main.java file will be provided which invokes the functionality of your WordSearch class. This test file must be compiled and run with your class as-is to test your program. You will see that it handles creating an instance of your class, calling the 3 search methods and printing the results. Thus your efforts will be concentrated on creating your class and testing it with this file. We will run your program with different puzzle and guess word files (not provided to you), so it is best to make sure your program works with various puzzles. The purpose of this assignment is to: Challenge you Ensure you know Java (or force you to pick it up quickly) since we will be using it for Android Test your ability to implement various algorithms Demonstrate algorithm efficiency across varying data sets (average case, worst case) Submissions WordSearch.java (only, nothing else) Grading Rubric A 0% will be given if the program fails to compile or run. search1() returns correct results 45% search2() returns correct results and runs faster than search1() 45% search3() returns correct results and runs fastest of all 10% Important Use the package name: edu.fullsail.mgms.apm.wordsearch The test program will use the same package name, giving it access to your class. 1

2 Directions You will write a class that compiles and runs with the test file provided. You can use any Java compiler/ide you wish, including command lines tools, so long as your program compiles and runs with the test file and loads the.txt files provided within the same directory. If you have never used a Java compiler or IDE, some popular ones include: Eclipse, IntelliJ IDEA, NetBeans, or simple command line shell. We have provided an Eclipse IDE primer document in the References section of the FSO page for this course. Unless you have already done some Android programming, you do not need to install the Google ADT tools for Eclipse (or Android Studio) at this time. They are not necessary for this assignment. Here is a screenshot of the entire program running in Eclipse: Note, when searching for words, you only have to handle matches in 3 directions: horizontally forward, vertically downward and diagonally southeast. After completing this assignment, adding matching for reverse words is trivial. Here is an example of valid finds of the words dog, cat, and rat : d v d j k o c r t d g i e a l e i c a t 2

3 Create 1 class called WordSearch in a file called WordSearch.java. Place it in the same directory/package as the Main.java test file provided to you. Your WordSearch class should contain the following: Any member variables you need to support the requirements A constructor void loadpuzzle( String ) takes the filename of the puzzle board and loads it into memory void loadguesses( String ) takes the filename of the guesses list and loads it into memory String[] search1( ) searches the puzzle for the list of guesses and returns those found o This is a naïve brute force algorithm, which will, for each guess word, visit every spot in the puzzle board and compare each letter of the guess word against the puzzle in the 3 directions: horizontal, vertical and diagonal. o The algorithm that you will use is as follows: for each guess word for each letter/location of the puzzle for each letter of the guess word check for a horizontal match against puzzle if match found, put guess word into list else for each letter of the guess word check for a vertical match against puzzle if match found, put guess word into list else for each letter of the guess word check for a diagonal match against puzzle if match found, put guess word into list return list as array of Strings String[] search2( ) searches the puzzle for the list of guesses and returns those found o This algorithm is much more elegant. You will transform the puzzle into a long string, with each row, column and diagonal appended to the string, and then do a simple String.contains() search with each of the guesses. The Java SE will use an optimized string search algorithm to match the guess word against the puzzle string. By transforming the puzzle into this string space, you can take advantage of this fast string search algorithm. o The algorithm that you will use is as follows: create an empty StringBuffer (mutable String) // append rows of puzzle delimited by space for each row for each column append puzzle[row][column] append a space after each row // append columns of puzzle delimited by space for each column 3

4 for each row append puzzle[row][column] append a space after each column // append diagonals of puzzle delimited by space for i=(-numrows)+1 to i<numcolumns, i++ for j=0,k=0 to j<numrows, j++, k++ if i+k>=0 and i+k<numcolmns append puzzle[j][i+k] append a space after diagonal for each guess word if buffer.contains(guess) put guess word into list return list as array of Strings o The diagonal transformation comes from looking at the puzzle board as a rhombus, starting out of bounds and traversing diagonally, but ignoring locations that are out of bounds of the rectangular board. For example: * * * d v d j k * * o c r t d * * g i e a l * * e i c a t * * * String[] search3( ) searches the puzzle for the list of guesses and returns those found o You can use any algorithm that you want, so long as it meets the criteria: Returns the correct list of found guess words Executes faster than the other algorithms o Here are some suggestions: Perhaps copy the first algorithm and then optimize it as much as possible, including a simple check that quickly breaks out of each puzzle letter check if the first letter of the guess doesn t match the puzzle letter at that spot. We only need to do comparisons if the guess word s first letter matches up with the puzzle letter. You could also cut down on dynamic allocation of variables, etc. Perhaps quickly generate a histogram of the letters in the puzzle into a data structure (like an int[26][]), that tells you how many a s are in the puzzle, and their offset locations, how many b s and their offset locations, etc. Then for each guess word, you could just take the first letter, jump to the right spot in the histogram array and visit each of the offsets into puzzle that are relevant to that letter. This way you avoid visiting every spot in the puzzle. Be creative Google o This is pretty challenging, since search2() s algorithm is very efficient already. Do your best. You may find that you can only design an algorithm that works well on certain puzzles, but not others... Welcome to graduate school! 4

5 Code Samples Here is a code snippet to append puzzle letters diagonally, with each diagonal separated by a space. for (int i=((-mheight)+1); i<mwidth; i++) for (int j=0, k=0; j<mheight; j++, k++) if (i+k >= 0 && i+k < mwidth) text.append(mpuzzle[j][i+k]); text.append(" "); Here is a code snippet to load the puzzle file: public void loadpuzzle(string filename) InputStream input = null; BufferedReader reader = null; try input = new FileInputStream(filename); reader = new BufferedReader(new InputStreamReader(input, Charset.forName("UTF-8"))); String line = reader.readline(); if (!line.isempty()) String[] tokens = line.split("x"); if (tokens.length >= 2 && tokens[0]!= null && tokens[1]!= null) mwidth = Integer.decode(tokens[0]); mheight = Integer.decode(tokens[1]); mpuzzle = new char[mheight][mwidth]; for (int j=0; j<mheight; j++) line = reader.readline(); if (line.isempty()) break; for (int i=0; i<mwidth; i++) mpuzzle[j][i] = line.charat(i); catch (Exception e) e.printstacktrace(); System.err.flush(); finally try if (reader!= null) reader.close(); catch (Exception e) e.printstacktrace(); System.err.flush(); 5

6 Sample Output Here is an example of what the output looks like with the default puzzle provided: 6

CS/COE 1501

CS/COE 1501 www.cs.pitt.edu/~lipschultz/cs1501/ Brute-force Search Brute-force (or exhaustive) search Find the solution to a problem by considering all potential solutions and selecting the correct one