/**
 * Solve a problem I found on Hacker News using trees and recursion.
 */  
import java.util.*;

public class ZachProblem{

	public int count = 0;
	public ArrayList AllTrees = new ArrayList();
	public HashMap results = new HashMap();
	
	//Classes for our tree representation of this problem.
	public abstract class ProblemNode {
		public ProblemNode Left = null;
		public ProblemNode Right = null;
		public ArrayList Operators = null;
				
		public abstract float performOperation();
		public abstract ProblemNode copy(ArrayList Operators);
		public abstract float calculate();
		
		public void slot(ArrayList SlotThese, ProblemNode Head) {
			if (SlotThese.size() == 2) {
				float value1 = (float)(Float)SlotThese.get(0);
				float value2 = (float)(Float)SlotThese.get(1);

				IntegerNode TempLeft = new IntegerNode();
				TempLeft.value = value1;
				this.Left = TempLeft;				
	
				IntegerNode TempRight = new IntegerNode();
				TempRight.value = value2;
				this.Right = TempRight;
				
				if(value2 == 9.0f) {
					ProblemNode NewTree = Head.copy(null);
					AllTrees.add(NewTree);
					count++;
				}
			} else {
				int i = (int)(Math.random() * (SlotThese.size() - 1));
				
					
				ArrayList A = new ArrayList();
				for(int ii = 0; ii <= i; ii++) {
					A.add(new Float((float)(Float)(SlotThese.get(ii))));
				}
				
				ArrayList B = new ArrayList();
				for(int iii = i+1; iii < SlotThese.size(); iii++) {
					B.add(new Float((float)(Float)(SlotThese.get(iii))));
				}
				
				if (A.size() == 1) {
					IntegerNode Temp = new IntegerNode();
					Temp.value = (float)(Float)A.get(0);
					this.Left = Temp;
				} else {
					this.Left = new OperationNode();
					this.Left.slot(A, Head);
				}
				
				if (B.size() == 1) {
					IntegerNode Temp = new IntegerNode();
					Temp.value = (float)(Float)B.get(0);
					this.Right = Temp;
					
					if (Temp.value == 9.0f) {
						ProblemNode NewTree = Head.copy(null);
						AllTrees.add(NewTree);
						count ++;
					}
					
				} else {
					this.Right = new OperationNode();
					this.Right.slot(B, Head);
				}
					
			}
		}
	}
	
	public class  OperationNode extends ProblemNode {
		public int operation = 0;
		public int MULTIPLY = 0;
		public int ADD = 1;
		public int SUBTRACT = 2;
		public int DIVIDE = 3;

		public String operationStrings[] = new String[]{"*", "+", "-", "/"};
	
		public float performOperation() {
			return Left.performOperation() * Right.performOperation();
		}
		
		public String toString() {
			String returnMe = "";
			if (Left instanceof IntegerNode) {
				returnMe += Left;
			} else {
				returnMe += "(" + Left + ")";
			}
			
			returnMe += operationStrings[operation];
			
			if (Right instanceof IntegerNode) {
				returnMe += Right;
			} else {
				returnMe += "(" + Right + ")";
			}
			
			return returnMe;
		}
		
		public ProblemNode copy(ArrayList Operators) {
		
			OperationNode copy = new OperationNode();
			
			if (Operators == null) {
				copy.Operators = new ArrayList();
				copy.Operators.add(copy);
				Operators = copy.Operators;
			} else {
				Operators.add(copy);
			}
			
			copy.Right = this.Right.copy(Operators);
			copy.Left = this.Left.copy(Operators);
			return copy;
		}
		
		public float calculate() {
			if (operation == MULTIPLY) {
				return Left.calculate() * Right.calculate();
			} else if(operation == DIVIDE) {
				return Left.calculate() / Right.calculate();
			} else if(operation == ADD) {
				return Left.calculate() + Right.calculate();
			} else {
				return Left.calculate() - Right.calculate();
			}
		}
	}
	
	public class IntegerNode extends ProblemNode {
		public float value;
	
		public float performOperation() {
			return value;
		}
		
		public String toString() {
			return "" + value;
		}
		
		public ProblemNode copy(ArrayList Operators) {
			IntegerNode copy = new IntegerNode();
			copy.value = this.value;
			return copy;
		}
		
		public float calculate() {
			return value;
		}
	}
		
	/**
	Construct the algorithm and execute it.
	*/
	public ZachProblem() {
		ArrayList SlotThese = new ArrayList();
		SlotThese.add(new Float(1.0));
		SlotThese.add(new Float(2.0));
		SlotThese.add(new Float(3.0));
		SlotThese.add(new Float(4.0));
		SlotThese.add(new Float(5.0));
		SlotThese.add(new Float(6.0));
		SlotThese.add(new Float(7.0));
		SlotThese.add(new Float(8.0));
		SlotThese.add(new Float(9.0));
		
		//Create the intial head node, this will be used to create all the trees.
		ProblemNode HeadNode = new OperationNode();
		
		while(AllTrees.size() < 1024) {
			HeadNode.slot(SlotThese, HeadNode);
		}
		
		System.out.println("Terminal condition hit " + count + " times.");
		
		bruteForce();
	}
	
	/**
	Perform the brute force search for solutions in the problem space.
	*/
	public void bruteForce() {
		int iteration = 0;
		
		for (int index = 0; index < AllTrees.size(); index++) {
			ProblemNode ProblemTree = (ProblemNode)AllTrees.get(index);
			
			Object Operators[] = (Object[])ProblemTree.Operators.toArray();
													
			for(int i=0;i<4;i++) {
			for(int ii=0;ii<4;ii++) {
			for(int iii=0;iii<4;iii++) {
			for(int iv=0;iv<4;iv++) {
			for(int v=0;v<4;v++) {
			for(int vi=0;vi<4;vi++) {
			for(int vii=0;vii<4;vii++) {
			for(int viii=0;viii<4;viii++) {

				((OperationNode)Operators[0]).operation = i;
				((OperationNode)Operators[1]).operation = ii;
				((OperationNode)Operators[2]).operation = iii;
				((OperationNode)Operators[3]).operation = iv;
				((OperationNode)Operators[4]).operation = v;
				((OperationNode)Operators[5]).operation = vi;
				((OperationNode)Operators[6]).operation = vii;
				((OperationNode)Operators[7]).operation = viii;

				float calculation = ProblemTree.calculate();
				if (calculation >= 1900 && calculation <= 2100) {
					int calculationInteger = (int)calculation;
					if (calculation - calculationInteger == 0) {
						results.put(new Integer(calculationInteger), "" + ProblemTree);
					}
				}
				
				iteration ++;
			}
			}
			}
			}
			}
			}
			}
			}
			
			if(results.size() == 201)
				break;
		}

		//Output the results for confirmation.
		Object[] key = results.keySet().toArray();
		Arrays.sort(key); 
		
		ArrayList FinalResults = new ArrayList();
		for (int i = 0; i < key.length; i++) {
			FinalResults.add(new Object[]{key<i>, results.get(key<i>)});
		}
		
		for (int i = 0; i< FinalResults.size(); i++) {
			Object O[] = (Object[])FinalResults.get(i);
			System.out.println(O[1] + " = " + O[0]);
		}
		

		Object[] data = results.values().toArray();
		System.out.println("Result Size = " + data.length);
	}
	
	//Testing main.
	public static void main(String args[]) {
		ZachProblem MyProblem = new ZachProblem();
	}
}

  

package ForkingServer;

import java.net.*;
import java.io.*;
import java.util.ArrayList;

/**
This is an implementation of a simple forking server used for accpeting incomming files
for the file bckup system.
*/
public class ServerThreadListener implements Runnable{
	//Data.
	private Thread t=null;//The thread that will listen for client connections.

	
	private ServerSocket SReceive=null;//The server socket.
	private int receiveSocket=8880;//The port to listen on.
	private int inSocketTimeOut=150000;//Wait time before we throw a socket exception.
	
	private int timeOut=180000;//Timeout that will be sent to new server threads.	

	//////////////////
	//Constuctors.
	public ServerThreadListener(){
		try{
			//Create the socket that will listen for inbound connections.
			SReceive=new ServerSocket(receiveSocket);
			SReceive.setSoTimeout(inSocketTimeOut);
		}catch(Exception e){
			e.printStackTrace();
		}
		//Initialize the server thread.
		t=new Thread(this);
		t.start();
	}

	
	/** The run method listens for a connection on the Send and Receive ports. */
	public void run(){
		while(true){
			//Check for a client to pass data to.
			try{

				Socket temp=SReceive.accept();//Accept a new connection.
				
				//Create a new threaded server from the connection accepted.
				ServerThread in=new ServerThread(temp);
				in.init(inSocketTimeOut);
				in.setTimeOut(timeOut);
				in.execute();
				System.out.println("Forking off new client connection.");
				
				Thread.sleep(10);//Always sleep in threads!
			}catch(Exception e){
			}
		}
	}

	//Testing main.
	public static void main(String args[]){
		ServerThreadListener STL=new ServerThreadListener();
	}

package ForkingServer;

import java.util.*;
import java.net.*;
import java.io.*;

/**
A simple inbound server thread.
*/

public class ServerThread implements Runnable{
	//Some constants used to keep track of the servers state in this simple example.
	public static final int READ_HEADER=0;
	public static final int SEND_EQUATION=1;
	public static final int READ_RESPONSE=2;
	public static final int HEADER_LENGTH=32;
	
	private int mode=READ_HEADER;//The initial state.

	//Variables used for this server's thread.
	private volatile Thread t=null;
	private boolean run=true;
	private int threadSleepTime=50;

	private int socketTimeOut=100000;//When should we force an exception on the socket if no operation has taken place?

	private Socket SReceive=null;//Our socket connection to the client.
	private InputStream in=null;//Read from client.
	private OutputStream out=null;//Write to client.

	//Kill our server thread after a given amount of inactivity from the client.
	private long timeOut=300000;//About 3 minutes.
	private long timeStamp=0;
	
	private String clientID="";

	/** Initialize the socket.*/
	public void init(int socketTimeOut){
		this.socketTimeOut=socketTimeOut;
		try{
			//Setup our object input stream.
			this.SReceive.setSoTimeout(socketTimeOut);//This function is important because it forces the socket to not permanently hang due to an error.
			
			//Little tweak that can help speed.
			this.SReceive.setTcpNoDelay(true);
			
			this.SReceive.setKeepAlive(true);
			
			//Get the streams from the socket.
			out=SReceive.getOutputStream();
			in=SReceive.getInputStream();
		}catch(Exception e){
			//	e.printStackTrace();
		}
	}

	///////////////////////////
	//Getters.
	
	/**
	 Check the current tick-count and see whether we should keep this connection alive.
	 */
	public boolean getAlive(){
		Calendar time = Calendar.getInstance();
		 if(time.getTimeInMillis()-timeStamp>timeOut)
		 	return(false);
		 return(true);
	}

	///////////////////////////
	//Setters.
	
	/**
	 How long should the thread sleep in each iteration of the run function?
	 */
	public void setThreadSleepTime(int threadSleepTime){
		this.threadSleepTime=threadSleepTime;
	}

	/**
	 Update the thread's timeout, allowing indicating it is still alive.
	 */
	public void setAlive(){
		Calendar time = Calendar.getInstance();
		timeStamp=time.getTimeInMillis();
	}

	/**
	 How much inactivity before we kill the thread?
	 */
	public void setTimeOut(int timeOut){
		this.timeOut=timeOut;
	}

	/**
	 How much idle time on the socket before we throw an exception.
	 */
	public void setSocketTimeOut(int socketTimeOut){
		this.socketTimeOut=socketTimeOut;
	}

	
	/** Start the server. */
	public void execute(){
		t=new Thread(this);
		t.start();
	}
	
	/**
	Helper functions for parsing the various parts of the inbound packet.
	*/
	public String parseHeader(String header){
		//In this example we just parse the user-name out of the header.
		String data[]=header.split(",");
		return(data[0]);
	}

	///////////////////////////
	// Methods.
	public void run(){		
	
		Thread thisThread = Thread.currentThread();
		while(run){
			try{
				
				//Make sure we haven't reached our timeout.
				if(!getAlive()){
					System.out.println("Killing connection.");
					kill();
				}
				
				//Read the header from the client and parse their id.
				if(mode==READ_HEADER&&in.available()>0){
				
					int offset=0;
					byte hb[]=new byte[HEADER_LENGTH];
					while(offset<HEADER_LENGTH){
						offset+=in.read(hb,offset,HEADER_LENGTH-offset);
						if(offset<0)
							break;
					}
					
					clientID=parseHeader(new String(hb));
					mode=SEND_EQUATION;
					
					System.out.println("Header Read, Starting Session for "+clientID+".");
					setAlive();
				}
				
				//Send a mathematical equation to the client for them to perform.
				if(mode==SEND_EQUATION){
					double a=Math.random()*32;
					double b=Math.random()*32;
					String equation=""+a+"*"+b+";";
					System.out.println("Sending client "+clientID+" equation "+equation+".");
					out.write(equation.getBytes());
					mode=READ_RESPONSE;
					setAlive();
				}
				
				//Receive the response from the client, with the result of the equation just sent.
				if(mode==READ_RESPONSE&&in.available()>0){
					int c=0;
					String response="";
					while((c=in.read())!=';')
						response+=(char)c;
					System.out.println("Client "+clientID+" returned response "+response+".");					
					kill();
				}
				
				Thread.sleep(threadSleepTime);
			}catch(Exception e){
			//	e.printStackTrace();
				if(!(e instanceof java.net.SocketTimeoutException)){
					this.kill();
				}
			}
		}

		//Clean up data.
		kill();
	}

	/** Kill this process. */
	public void kill(){
		//Stop the thread.
		run=false;
		t=null;
		
		//Clean the socket connections.
		try{
			if(out!=null)
				out.close();
			if(in!=null)
				in.close();
			if(SReceive!=null)
				SReceive.close();
		}catch(Exception e){
		//	e.printStackTrace();
		}
 
		//Set everything to null to avoid memory leaks.
		SReceive=null;
		in=null;
		out=null;
	}
}

package ForkingServer;

import java.util.*;
import java.net.*;
import java.io.*;

/**
A simple client that connects to our forking server, gets a mathematical equation to perform, and returns the result.
*/

public class Client{
	private Socket MySocket=null;//The socket that will connect to the server.
	private String clientID="";//An ID associated with the client.
	
	//Constructor.
	public Client(String clientID){
		this.clientID=clientID;
		runExample();
	}

	
	/**
	 This example function demonstrates client server communication. The sample
	 function simply performs mathematical operations sent over the server.
	 */
	public void runExample(){
		try{
			
			//Create a connection to our server.
			MySocket=new Socket("localhost",8880);//Connect the socket to the forking server.
			InputStream In=MySocket.getInputStream();
			OutputStream Out=MySocket.getOutputStream();
			
			//First we send the header to the server.
			String header=clientID+",";
			while(header.length()<32)
				header+=" ";
			Out.write(header.getBytes());
			
			//Now we receive the response from the server and perform the mathematical operation.
			int c=0;
			String equation="";
			while((c=In.read())!=';')
				equation+=(char)c;
			System.out.println("Client "+clientID+" Received equation "+equation+" performing operation.");
			
			String data[]=equation.split("\\*");
			double a=new Double(data[0]);
			double b=new Double(data[1]);
			String result=""+(a*b)+";";
			
			//Now we send the result back to the server easy.
			Out.write(result.getBytes());
			
		}catch(Exception e){
			e.printStackTrace();
		}
	}

	//Testing main.
	public static void main(String args[]){
		//Create a few sample clients to show our threaded server in action.
		Client C1=new Client("Example Client 1");
		Client C2=new Client("Example Client 2");
		Client C3=new Client("Example Client 3");
		Client C4=new Client("Example Client 4");
	}
}

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- The HTML 4.01 Transitional DOCTYPE declaration-->
<!-- above set at the top of the file will set     -->
<!-- the browser's rendering engine into           -->
<!-- "Quirks Mode". Replacing this declaration     -->
<!-- with a "Standards Mode" doctype is supported, -->
<!-- but may lead to some differences in layout.   -->

<html>
  <head>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">

    <!--                                                               -->
    <!-- Consider inlining CSS to reduce the number of requested files -->
    <!--                                                               -->
    <link type="text/css" rel="stylesheet" href="example.css">

    <!--                                           -->
    <!-- Any title is fine                         -->
    <!--                                           -->
    <title>Web Application Starter Project</title>
    
    <!--                                           -->
    <!-- This script loads your compiled module.   -->
    <!-- If you add any GWT meta tags, they must   -->
    <!-- be added before this line.                -->
    <!--                                           -->
    <script type="text/javascript" language="javascript" src="example/example.nocache.js"></script>
  </head>

  <!--                                           -->
  <!-- The body can have arbitrary html, or      -->
  <!-- you can leave the body empty if you want  -->
  <!-- to create a completely dynamic UI.        -->
  <!--                                           -->
  <body>

    <!-- OPTIONAL: include this if you want history support -->
    <iframe src="javascript:''" id="__gwt_historyFrame" tabIndex='-1' style="position:absolute;width:0;height:0;border:0"></iframe>

    <h1>Ben's GWT Example</h1>

	<div id="examplePanel" />
  </body>
</html>

  
  
/**
A simple example of using GWT to make a couple cool GUI components for a website.

Benjamin E. Coe (2009).

*/

package com.bencoe.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.event.dom.client.KeyUpEvent;
import com.google.gwt.event.dom.client.KeyUpHandler;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.*;
import com.google.gwt.user.client.*;

/**
 * Entry point classes define <code>onModuleLoad()</code>.
 */
public class example implements EntryPoint {

	
	//Used to generate a video pop-up event.
	private static class videoCommand implements Command,ClickListener{
		private String video="";
		
		//Constructor.
		public videoCommand(String video){
			this.video=video;
		}
		
		public void execute(){
			new VideoDialog(video).show();
		}

		public void onClick(Widget sender){
			new VideoDialog(video).show();
		}
	}

    

	//Create video commands for both the videos I use in this example.
	videoCommand portfollioVideo=new videoCommand("<object width=\"425\" height=\"344\"><param name=\"movie\" value=\"http://www.youtube.com/v/dKQRAGghfH0&hl=en&fs=1&\"></param><param name=\"allowFullScreen\" value=\"true\"></param><param name=\"allowscriptaccess\" value=\"always\"></param><embed src=\"http://www.youtube.com/v/dKQRAGghfH0&hl=en&fs=1&\" type=\"application/x-shockwave-flash\" allowscriptaccess=\"always\" allowfullscreen=\"true\" width=\"425\" height=\"344\"></embed></object>");

	videoCommand wikiearthVideo=new videoCommand("<object width=\"560\" height=\"340\"><param name=\"movie\" value=\"http://www.youtube.com/v/HsyHecofNHw&hl=en&fs=1&\"></param><param name=\"allowFullScreen\" value=\"true\"></param><param name=\"allowscriptaccess\" value=\"always\"></param><embed src=\"http://www.youtube.com/v/HsyHecofNHw&hl=en&fs=1&\" type=\"application/x-shockwave-flash\" allowscriptaccess=\"always\" allowfullscreen=\"true\" width=\"560\" height=\"340\"></embed></object>");

    

	//This class actually displays the video.
	private static class VideoDialog extends PopupPanel {
		
		public VideoDialog(String video) {
			HTML youtubeHTML=new HTML(video);
			
			Button ok = new Button("Close Video");
			ok.addClickListener(new ClickListener() {
								public void onClick(Widget sender) {
								VideoDialog.this.hide();
								}
								});
			
			VerticalPanel panel = new VerticalPanel();
			panel.add(youtubeHTML);
			panel.add(ok);
			setWidget(panel);
			
			this.center();
		}
	}

    
	
	/**
	 Create the menu GUI component and return it.
	 */
	MenuBar createMenu(){		
		//The top-level of our example menu.
		MenuBar exampleMenu = new MenuBar(true);

		//The sub-menu for the videos.
		MenuBar videos = new MenuBar(true);
		videos.addItem("<a style=\"color:black;text-decoration:none;\" >Portfollio Video</a>",true,portfollioVideo);
		videos.addItem("<a style=\"color:black;text-decoration:none;\" >Wikiearth Video</a>",true,wikiearthVideo);

		//Add our sub-menu to the parent menu item.
		exampleMenu.addItem("Videos", videos);

		//Add all the menus to our top-level menu-bar.
		MenuBar menu = new MenuBar();
		menu.addItem("Example Menu", exampleMenu);

		return(menu);
	}

    

	/**
	 Create a tree menu.
	 */
	public Tree createTree(){
		TreeItem exampleTree = new TreeItem("Example Tree");
		TreeItem videosNode = new TreeItem("Videos");
		
		exampleTree.addItem(videosNode);
		
		//Create the video labels.
		Label portfollioLabel=new Label("Portfollio Video");
		portfollioLabel.addClickListener(portfollioVideo);
		Label wikiearthLabel=new Label("Wikiearth Label");
		wikiearthLabel.addClickListener(wikiearthVideo);
		
		videosNode.addItem(portfollioLabel);
		videosNode.addItem(wikiearthLabel);
		
		Tree returnMe=new Tree();
		returnMe.addItem(exampleTree);
		
		return(returnMe);
	}

    
	/**
	 Create all the GUI components for this small tutorial.
	 */
	public void createGUI(){
		MenuBar menu=createMenu();
		Tree tree=createTree();

		//Create a panel for adding our components to.
		HorizontalPanel MyHorizontalPanel=new HorizontalPanel();
		
		//Add our menu to the horizontal panel.
		MyHorizontalPanel.add(menu);
		MyHorizontalPanel.add(tree);

		RootPanel.get("examplePanel").add(MyHorizontalPanel);
		RootPanel.get("examplePanel").setStylePrimaryName("examplePanel");
	}

	/**
	 * This is the entry point method.
	 */
	public void onModuleLoad() {
		createGUI();
	}
}