Question

This task involves constructing a Java program that supports interaction via a graphical user interface.The object is to implement a Scrabble graphical game. The basis for the game is quite simple. Presented with a 6x6 grid of Scrabble tiles, the challenge is for the player(s) to form as many high scoring words as possible.

 Words may only be formed from sequences of adjacent tiles.
 Two tiles are adjacent if their edges or corners meet.
 A tile may be used in at most one word.
-one letter words accepted too.

Beyond these simple rules, there are no limits to the form of the game.
 It could be played by one or more people.
 There could be a time limit.
 There are a variety of ways in which scores can be calculated.
 When a tile is used, ‘consumed’ even, it could be replaced with a fresh tile.
Any form of the game that is desired may be implemented.
 The baseline is a single player game where the player simply seeks to get a good score.
 Creativity is highly recommended.

Resources
Tile class

public class Tile {

private char letter;
private int value;

/**
* Create a Tile for the given letter and value.
*/
public Tile(char letter, int value) {
this.letter = letter;
this.value = value;
}

/**
* Obtain the letter on this tile.
*/
public char letter() { return letter;}
  
/**
* Obtain the value of this letter tile.
*/
public int value() { return value;}

/**
* Obtain a String representation of this tile.
*/
public String toString() {
return "("+letter+", "+value+")";
}
}

TileCollection class

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
import java.util.NoSuchElementException;
import java.util.Random;

public class TileCollection {

private static int totalTiles() {
int total = 0;
for (int tileNumber=0; tileNumber<FREQUENCY.length; tileNumber++) {

total=total+FREQUENCY[tileNumber];
}
return total;
}

private final static char[] LETTER = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H','I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T','U', 'V', 'W', 'X', 'Y','Z'};
private final static int[] FREQUENCY = {9, 2, 2, 4, 12, 2, 3, 2, 9, 1, 1, 4, 2, 6, 8, 2, 1, 6, 4, 6, 4, 2, 2, 1, 2, 1};
private final static int[] VALUE = {1, 3, 3, 2, 1, 4, 2, 4, 1, 8, 5, 1, 3, 1, 1, 3, 10, 1, 1, 1, 1, 4, 4, 8, 4, 10};

private static Tile[] makeTileArray() {

Tile[] tiles = new Tile[totalTiles()];
int instanceIndex = 0;
  
for (int tileNumber=0; tileNumber<LETTER.length; tileNumber++) {
char tileLetter = LETTER[tileNumber];
int tileValue = VALUE[tileNumber];
  
for (int instances=0; instances<FREQUENCY[tileNumber]; instances++) {
tiles[instanceIndex] = new Tile(tileLetter, tileValue);
instanceIndex++;
}
}
return tiles;
}

private static void shuffleTiles(Tile[] tileArray) {

Random random = new Random();
int numberOfRuns = tileArray.length;

while (numberOfRuns>0) {

numberOfRuns--;

for (int index=0; index<tileArray.length-1; index++) {
  
int destination = random.nextInt(tileArray.length);

Tile tile = tileArray[destination];
tileArray[destination] = tileArray[index];
tileArray[index]=tile;
}
}
}

/* **************** Instance variables and methods *************** */
private List<Tile> collection;
  
/**
* Create a new collection of scrabble tiles.
*/
public TileCollection() {

Tile[] tileArray = makeTileArray();
shuffleTiles(tileArray);
this.collection = new ArrayList<Tile>(Arrays.asList(tileArray));
}

/**
* Remove a randomly chosen tile from the collection.
* @throws NoSuchElementException if the collection is empty.
*/
public Tile removeOne() {

if (this.size()==0) {
throw new NoSuchElementException("TileCollection:removeOne(): collection is empty");
}
else {
return collection.remove(0);
}
}

/**
* Obtain the number of tiles remaining in the collection.
*/
public int size() {
return collection.size();
}
}

TileGUI class

import javax.swing.JButton;
import javax.swing.JFrame;
import java.awt.Color;
import java.awt.Container;

public class TileGUI extends JButton {

private Tile model;

/**
* Create a TileGUI object that provides a graphical representation for the given Tile.
*/
public TileGUI(Tile tile) {
super();
model = tile;
setText(makeHTML(super.getForeground(), tile));
this.setContentAreaFilled(true);
}

private static String setTwoDigits(String string) {
if (string.length()==1) {
return "0"+string;
}
else if (string.length()==2) {
return string;
}
else {
throw new IllegalArgumentException("TileGUI:setTwoDigits("+string+"): more than two digits");
}
}

private static String makeHTML(Color colour, Tile tile) {

String redString = Integer.toHexString(colour.getRed());
String greenString = Integer.toHexString(colour.getGreen());
String blueString = Integer.toHexString(colour.getBlue());
redString = setTwoDigits(redString);
greenString = setTwoDigits(greenString);
blueString = setTwoDigits(blueString);

StringBuffer result = new StringBuffer();
result.append("<html><font color=\"#");
result.append(redString);
result.append(greenString);
result.append(blueString);
result.append("\" size=\"+5\">"+tile.letter()+"</font>_{"+tile.value()+"}");
return result.toString();
}

/**
* Set the foreground colour for this graphical component.
*/
public void setForeground(Color colour) {
super.setForeground(colour);
if (model!=null) {
this.setText(makeHTML(colour, model));
}
}

/**
* Obtain the Tile object graphically represented by this TileGUI object.
*/
public Tile getTile() { return model; }

/**
* Test program for TileGUI.
*
* Creates a JFrame with a TileGUI within it. The tile displayed is an 'A'
* with value 2. The foreground colour is yellow.
*
*/
public static void main(String[] args) {
JFrame frame = new JFrame("Test Script for TileGUI");
TileGUI gui = new TileGUI(new Tile('A', 2));
gui.setForeground(Color.yellow);
frame.getContentPane().add(gui);
frame.pack();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}

 A Tile object represents a Scrabble tile.
 A TileCollection represents a bag of Scrabble tiles.
 A TileGUI object may be used to provide a graphical representation of a Tile.

FileToArray

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class FileToArray {

private final static String START_LABEL = "START";

/**
* Constructs a word list from the named file. The file should be
* organized such that there is a single word per line.
*
* The file is assumed to contain a preamble such as a copyright notice.
* The beginning of the data should be marked by a line containing
* the single word "START".
*
* @throws FileNotFoundException if unable to open the named file.
* @throws IOException if some error occurs during reading of the file (uncommon).
*/
public static String[] read(String filename) throws IOException, FileNotFoundException {
BufferedReader buffer = new BufferedReader(new FileReader(filename));

String line = buffer.readLine();
while (! line.equals(START_LABEL) ) {
line = buffer.readLine();
}

List<String> words = new ArrayList<String>();
line = buffer.readLine();
  
while (line !=null) {
words.add(line.trim());
line = buffer.readLine();
}
buffer.close();
String[] arrayResult = new String[words.size()];
arrayResult = words.toArray(arrayResult);
return arrayResult;
}

/**
* Test harness for the read method.
*/
public static void main(String[] args) {
// File name in args[0].
try {
String[] results = FileToArray.read(args[0]);
for (String word : results) {
System.out.println(word);
}
}
catch (Exception exception) {
System.out.println("Whoops, file error:");
System.out.println(exception);
}
}
}

-The game requires a lexicon of words with which to check a player’s selection. Make sure that the there is a use of a any given text file given e.g. 'SpanishWords.txt' or ‘EnglishWords.txt’.
The class contains a static class method called “read’. Use it like:
String[] words = FileToArray.read(“SpanishWords.txt”);
-Provide an exception handling when error occurs.

Answer 1

scrabble game:

I have implemented it using array list

public class Scrabble {

public static ArrayList<String> numbers = new ArrayList<String>();
public static ArrayList<String> numbers2 = new ArrayList<String>() {
};

public static void main(String[] args) {
Scanner dict = null;

try {
dict = new Scanner(new File("SpanishWords.txt"));
} catch (FileNotFoundException ex) {
}

while (dict.hasNextLine()) {

numbers.add(dict.nextLine());
}

String n = "gojy";//random text here

rearrange("", n);
LinkedHashSet<String> listToSet = new LinkedHashSet<String>(numbers2);
ArrayList<String> listWithoutDuplicates = new ArrayList<String>(listToSet);
for (int i = 0; i < listWithoutDuplicates.size(); i++) {

if (numbers.contains(listWithoutDuplicates.get(i))) {
System.out.println(listWithoutDuplicates.get(i));
}
}

}

public static void rearrange(
String q, String w) {
if (w.length() <= 1) {
String k = q + w;
numbers2.add(k);//full word
numbers2.add(q);//smaller combination to get words with less letters. doesn't work too well
} else {

for (int i = 0; i < w.length(); i++) {

String c = w.substring(0, i)
+ w.substring(i + 1);

rearrange(q
+ w.charAt(i), c);

}
}
}
}