CSC212 Homework 4 Solutions 2014

--D. Thiebaut (talk) 08:15, 6 October 2014 (EDT)

---

Problem 1

/**
 * evaluates RPN expressions known to be error free.
 * @author D. Thiebaut
 */

import java.util.Scanner;
import java.util.Stack;

@SuppressWarnings("unchecked")
public class Hw4_1 {
	static boolean debug = false; // used for debugging purposes
	
	/**
	 * test validity of string as containing an operator
	 * @param word contains the operator (no extra spaces)
	 * @return true if +, *, -, or /, false otherwise
	 */
	private static boolean isOperator( String word ) {
		String[] operators = new String[] { "+", "*", "-", "/" };
		for ( int i=0; i<operators.length; i++ )
			if ( word.equals(operators[i]) )
				return true;
		return false;
	}
	

	/**
	 * main entry point.
	 * @param args
	 */
	public static void main(String[] args) {
		
		// create a stack and a line scanner
		Stack stack = new Stack();
		Scanner lineScanner = new Scanner( System.in );
		
		// read lines until the end of input.
		while ( lineScanner.hasNextLine() ) {
			String line = lineScanner.nextLine();		
		
			// skip blank lines
			if ( line.isEmpty() )
				break;
			
			// create a word scanner for each line
			Scanner wordScanner = new Scanner( line );
			while ( wordScanner.hasNext() ) {
				String word = wordScanner.next();
				
				//System.out.println( word );
				
				// operate on operators
				if ( isOperator( word ) ) {
					int top = (int) stack.pop();
					int nextTop = (int) stack.pop();
					if ( word.equals( "+" ) ) stack.push( top + nextTop );
					if ( word.equals( "-" ) ) stack.push( nextTop - top );
					if ( word.equals( "*" ) ) stack.push( top * nextTop );
					if ( word.equals( "/" ) ) stack.push( nextTop / top );
					
					if (debug) System.out.println( "stack: " + stack );
					continue;
				}
				
				// otherwise, it's a number: push it.
				stack.push( (int)  Integer.parseInt( word ) );
				
				if (debug) System.out.println( "stack: " + stack );
			}
			
			// no more words in this line: print the top of stack and clear it.
			System.out.println(  stack.pop() );
			stack.clear();
		}
	}
}

Problem 2

/**
 * evaluates RPN arithmetic expressions on ints using a stack. 
 * 
 */
import java.util.Scanner;
import java.util.Stack;


public class Hw4_2 {
        static boolean debug = false;
        
        /**
         * given s tring containing only a possible operator, returns true if it's a valid
         * one (+, *, -, /) and false otherwise
         * @param word the string containing the parameter (no extra space allowed)
         * @return true if *, +, - or /, false otherwise
         */
        private static boolean isOperator( String word ) {
                String[] operators = new String[] { "+", "*", "-", "/" };
                for ( int i=0; i<operators.length; i++ )
                        if ( word.equals(operators[i]) )
                                return true;
                return false;
        }
        
        /**
         * displays the word ERROR.  
         * @param i used in debugging mode, to indicate where the error occured.
         */
        private static void error( int i ) {
                System.out.println( "ERROR " );// + i );
        }
 
        /**
         * main entry point.
         * @param args
         */
        public static void main(String[] args) {
                boolean error;
                Stack stack = new Stack();
                Scanner lineScanner = new Scanner( System.in );
                
                // scan the lines of input
                while ( lineScanner.hasNextLine() ) {
                        String line = lineScanner.nextLine().trim();

                        // skip blank lines
                        if ( line.isEmpty() )
                                continue;
                        
                        // scan each word in a line and either pushes it in stack if an int
                        // or pop numbers from the stack to evaluate operation.
                        error = false;
                        Scanner wordScanner = new Scanner( line );
                        while ( wordScanner.hasNext() ) {
                                String word = wordScanner.next();
                                
                                // --- operator? ---
                                if ( isOperator( word ) ) {
                                        if ( stack.size() < 2 ) {
                                                error( 1 );
                                                if ( wordScanner.hasNextLine() ) wordScanner.nextLine();
                                                error = true;
                                                break;
                                        }
                                        int top = (int) stack.pop();
                                        int nextTop = (int) stack.pop();
                                        if ( word.equals( "+" ) ) stack.push( top + nextTop );
                                        if ( word.equals( "-" ) ) stack.push( nextTop - top );
                                        if ( word.equals( "*" ) ) stack.push( top * nextTop );
                                        if ( word.equals( "/" ) ) { 
                                                if ( top != 0 ) 
                                                        stack.push( nextTop / top );
                                                else {
                                                        if ( wordScanner.hasNextLine() ) wordScanner.nextLine();
                                                        stack.clear();
                                                        error( 2 );
                                                        error = true;
                                                        break;
                                                }
                                        }
                                        if (debug) System.out.println( "stack: " + stack );
                                        continue;
                                }
                                
                                // --- no, then must be number ---
                                try {
                                        stack.push( (int)  Integer.parseInt( word ) );
                                }
                                catch ( NumberFormatException e ) {
                                        error( 3 );
                                        stack.clear();
                                        error = true;
                                        break;
                                }
                                
                                if (debug) System.out.println( "stack: " + stack );
                        }
                        
                        if ( error )
                                continue;
                        
                        if ( stack.size() != 1 ) {
                                error( 4 );
                                stack.clear();
                        }
                        else 
                                System.out.println(  stack.pop() );
                        
                        stack.clear();
                }
        }
}

Problem 3

/**
 * Hw4_3.java
 * @author thiebaut
 * Reads 4 arguments from the command line, a min distance, a min number of time,
 * and two files containing (t, x, y) triplets.
 */
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;

/**
 * Contains a pair of ints
 */
class MyPair{ 
	public int x;
	public int y;
	MyPair( int xx, int yy ) { x = xx; y = yy; }
	public String toString() { return "(" + x + "," + y + ")"; }
}

/**
 * The class opens two files that contain the same number of lines, 
 * reads them, and computes the distance between points in the nth
 * line of both files.
 */
public class Hw4_3 {
	
	/**
	 * returns the distance between 2 points defined by (x1,y1) and
	 * (x2, y2)
	 * @param x1
	 * @param y1
	 * @param x2
	 * @param y2
	 * @return the distance as a double.
	 */
	private static double distance( int x1, int y1, int x2, int y2 ) {
		return Math.sqrt( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) );
	}
	
	/**
	 * reads the file whose name is passed as a string.  Returns an array list
	 * of MyPairs.
	 * @param file the file name.
	 * @return an arraylist of pairs of x,y ints.
	 */
	private static ArrayList readFile(String file ) {
		Scanner in = null;
		
		// create an arraylist of mypairs 
		ArrayList list = new ArrayList();
		
		// open the file
		try {
			in = new Scanner( new File( file ) );
		} catch (FileNotFoundException e) {
			System.out.println( "File " + file + " does not exist" );
			System.exit( 1 );
		}
		
		// read its contents
		while ( in.hasNext() ) {
			String line = in.nextLine();
			Scanner wordScanner = new Scanner( line );
			if ( wordScanner.hasNext() ) {
				// get all 3 numbers.  Get rid of time.  
				int time = Integer.parseInt( wordScanner.next() );
				int x    = Integer.parseInt( wordScanner.next() );
				int y    = Integer.parseInt( wordScanner.next() );
				
				// create a new entry in array.
				list.add( new MyPair( x, y ) );
			}
		}
		return list;
	}

	/**
	 * displayList: displays the list of MyPairs.  useful for debugging.
	 * @param caption
	 * @param list
	 */
	private static void displayList( String caption, ArrayList list ) {
		System.out.print( caption );
		for ( int i=0; i<list.size(); i++ ) {
			MyPair p = (MyPair) list.get(i);
			System.out.print( p+ " " );
		}
		System.out.println( );
	}
	
	/**
	 * computerDistances gets 2 lists of MyPairs and returns a list of double distances.
	 * @param l1
	 * @param l2
	 * @return an ArrayList of MyPairs.
	 */
	private static ArrayList computeDistances(ArrayList l1, ArrayList l2) {
		ArrayList dist = new ArrayList();
		for ( int i=0; i< Math.min( l1.size(), l2.size()); i++ ) {
			MyPair p1 = (MyPair) l1.get( i );
			MyPair p2 = (MyPair) l2.get( i );
			dist.add( distance( p1.x, p1.y, p2.x, p2.y ) );
		}
		return dist;
	}

	/**
	 * Main entry point.
	 * @param args: command line arguments
	 */
	public static void main(String[] args) {

		// check syntax
		if ( args.length != 4 ) {
			System.out.println( "Syntax: java Hw4_3 minDist minTim file1 file2" );
			System.out.println( "          where minDist is the minimum distance for contact," );
			System.out.println( "          minTime is the minimum amount of time for contact");
			System.out.println( "          where file1 and file2 are data files with 3 numbers on each line.");
			return;
		}
		
		// get the command line arguments
		int minDist = Integer.parseInt( args[0] );
		int minTime = Integer.parseInt( args[1] );
		String file1 = args[2];
		String file2 = args[3];
		
		// create arrayLists of the data in the two files.
		ArrayList l1, l2;
		l1 = readFile( file1 );
		l2 = readFile( file2 );
		
		// for debugging: display the two lists
		//displayList( "l1 = ", l1 );
		//displayList( "l2 = ", l2 );

		// create a list of distances
		ArrayList distances = computeDistances( l1, l2 );
		
		// check for closeness and amount of time the data points are close (less than minDist)
		int count = 0;
		for ( int i = 0; i<distances.size(); i++ ) 
			if ( (double) distances.get( i ) <= minDist )
				count++;
		if ( count >= minTime )
			System.out.println( "CONTACT" );
		else
			System.out.println( "NOT" );
	}
}