import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;
 
public class HW5Driver {
 
	public final static String FILE_AND_PATH = "longwords.txt";
	/* 
	 * TODO: Be sure to change the FILE_AND_PATH to point to your local 
	 * copy of longwords.txt or a FileNotFoundException will result
	 */	
 
 
	//Note how we deal with Java's Catch-or-Declare rule here by declaring the exceptions we might throw
	public static void main(String[] args) throws FileNotFoundException {
		Scanner input = new Scanner(new File(FILE_AND_PATH));
		int wordCount = 0;
		ArrayList<String> theWords = new ArrayList<String>();
 
		//read in words, count them
		while(input.hasNext())  {
			theWords.add( input.next() );
			wordCount++;
		}
 
		//make a standard array from an ArrayList
		String[] wordsToSearch = new String[theWords.size()];
		theWords.toArray(wordsToSearch);
 
 
 
		//start with the linear searches
		tryLinearSearch(wordsToSearch, "DISCIPLINES");
		tryLinearSearch(wordsToSearch, "TRANSURANIUM");
		tryLinearSearch(wordsToSearch, "HEURISTICALLY");
		tryLinearSearch(wordsToSearch, "FOO");
 
		//and compare these results to the binary searches
		tryBinarySearch(wordsToSearch, "DISCIPLINES");
		tryBinarySearch(wordsToSearch, "TRANSURANIUM");
		tryBinarySearch(wordsToSearch, "HEURISTICALLY");
		tryBinarySearch(wordsToSearch, "FOO");
 
	}
 
	/**
	 * Method tryBinarySearch
	 * precondition: wordsToSearch is a nonempty array of Strings, and target is a non-null string to search for 
	 * 				 in our collection of strings
	 * postcondition: Uses a BinarySearch object (which implements this style of search) to try to find the target string
	 */
	private static void tryBinarySearch(String[] wordsToSearch, String target) {
		//Todo: Build a LinearSearch class that inherits from SearchAlgorithm, and put it in the same directory as this class to successfully compile
		SearchAlgorithm bs = new BinarySearch();
 
		try {
			System.out.print( target + " found at index: " + bs.search(wordsToSearch,target));
			System.out.println( " taking " + bs.getCount() + " comparisons.");
		} 
		catch( ItemNotFoundException e ) {
			System.out.println( target + ":" + e.getMessage());
		}	
	}
 
	/**
	 * Method tryLinearSearch
	 * precondition: wordsToSearch is a nonempty array of Strings, and target is a non-null string to search for 
	 * 				 in our collection of strings
	 * postcondition: Uses a LinearSearch object to try to find the target string
	 */
	private static void tryLinearSearch(String[] wordsToSearch, String target) {
		//Todo: Build a LinearSearch class that inherits from SearchAlgorithm, and put it in the same directory as this class to successfully compile
		SearchAlgorithm bs = new LinearSearch();
 
		try {
			System.out.print( target + " found at index: " + bs.search(wordsToSearch,target));
			System.out.println( " taking " + bs.getCount() + " comparisons.");
 
		} 
		catch( ItemNotFoundException e ) {
			System.out.println( target + ":" + e.getMessage());
		}	
	}
 
}

public class ItemNotFoundException extends Exception{
 
    public ItemNotFoundException(){
        super("Word not found.");
    }
 
    public ItemNotFoundException(String message){
        super(message);
    }
 
}

public class LinearSearch extends SearchAlgorithm{
 
    public int search(String[] words, String wordToFind){
 
        for(int i = 0; i < words.length ; i++){ 
            if(words[i].equals(wordToFind)){
                break;
            }else{
                incrementCount();
            }
        }
        return getCount();
 
    }
}

public abstract class SearchAlgorithm {
 
	/**
	 * Method search: a "to-be-defined" method used to implement a specific search strategy over the given array looking for the target word
	 * Precondition: words is a nonempty array and target is a non-null string
	 * Postcondition: if the target word is found, return its index.  
	 *                If not found, throw an ItemNotFoundException (a subclass which you have to make)
	 * 
	 */
	public abstract int search(String[] words, String wordToFind) throws ItemNotFoundException;
 
	/**
	 * Utility Features: This class can be used to track the number of search comparisons
	 *                   for use in comparing two different search algorithms
	 */
	private int count = 0;
	public void incrementCount() {
		count++;
	}
	public int getCount() {
		return count;
	}
	public void resetCount() {
		count = 0;
	}
}

    /**
public static final String SENTENCE_SEPARATORS = "[.?!]";
 
     * Given an ArrayList of lines from a text file, create a new array list
     * in which each entry is a sentence from the file 
     * with SENTENCE_SEPARATORS removed but no other changes.
     * A sentence is defined to be a sequence of characters that 
     * (1) is terminated by (but doesn't include) the characters ! ? . or the end of the file, 
     * (2) excludes whitespace on either end, and 
     * (3) is not empty.
     */
    public static ArrayList<String> convertFileLinesToSentences(ArrayList<String> filelines)
    {
        String allLines = "";
        for(String lines : filelines) { // add all lines into a single string
            allLines = (lines + " ");
        }
        String[] sentencesArray = allLines.split(SENTENCE_SEPARATORS);  // split at sentence separators
        ArrayList<String> entries = new ArrayList<>(Arrays.asList(sentencesArray)); // add sentences from array into ArrayList
        for(String sentence : entries) { // remove the sentence separators
            sentence.trim().replaceAll(SENTENCE_SEPARATORS, "");
        }
        return entries;
    }

public class List{
 
    Node head = null; //the start of the linked list
    private 
 
    public void add(Object next, int index){
        if(head == null){ //adding to an empty list (changes head)
            head = new Node(next, head);     //what about index?
        }else if( ){ //adding to a single element list (changes head)
 
        }else if(){ //adding to a populated list (n>=2)
            Node temp = head;
            while(temp.next != null){
                temp = temp.next;
            }
            temp.next = new Node(next, index) //not correct.....
        }
 
    }
}

package objectclasstrain;
import javax.swing.SwingUtilities;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Dimension;
import java.awt.Color;
import java.awt.Graphics;
 
 
 
 
public class ObjectClassTrain {
 
 
 
 
 
 
    public static void main(String[] args) {
 
        square squareRed = new square();
        System.out.println(squareRed.returnXposition());
        System.out.println(squareRed.returnYposition());
 
        SwingUtilities.invokeLater(new Runnable(){
            @Override
            public void run(){
                createAndShowGUI();
            }
        });
 
    }
 
    public static void createAndShowGUI(){
 
        JFrame f = new JFrame("JFrame test");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setResizable(false);
        f.add(new myPanel());
        f.pack();
        f.setVisible(true);
 
    }
 
}
 
class myPanel extends JPanel{
 
 
     int room_width = 640;
     int room_height = 480;
 
 
 
 
    public myPanel(){
 
 
 
    }
 
 
 
 
 
 
    @Override
    public Dimension getPreferredSize(){
 
        return new Dimension(room_width, room_height);
 
    }
 
    @Override
    public void paintComponent(Graphics g){
        super.paintComponent(g);        
        g.setColor(Color.BLACK);
        g.fillRect(squareRed.returnXposition(), 0, room_width, room_height);
 
    }
 
 
}
 
 
class square{
 
    int room_width = 640;
     int room_height = 480;
 
    double Xposition;
    double Yposition;
 
         public square(){
 
             Xposition = (int) (Math.random() * room_width);
             Yposition = (int) (Math.random() * room_height);
             }
 
         public double returnXposition(){
             return Xposition;
         }
 
         public double returnYposition(){
             return Yposition;
         }
 
 
}

package javagametest;
import javax.swing.SwingUtilities;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Color;
 
 
 
 
 
 
public class JavaGameTest{
 
    public static void main(String[] args){
 
        SwingUtilities.invokeLater(new Runnable(){
 
            @Override
            public void run(){
                createAndShowGUI();
            }
 
        });
 
    }
 
    public static void createAndShowGUI(){
 
        JFrame f = new JFrame("JFrame test");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.add(new myPanel());
        f.pack();
        f.setVisible(true);
 
 
    }
 
}
 
class myPanel extends JPanel{
 
    //Global
    static int Room_Width = 966;
    static int Room_Height = 600;
 
    //The red box variables
    private double RedBoxX = (int) (Math.random() * 640);
    private double RedBoxY = (int) (Math.random() * 480);
    private int RedBoxW = 32;
    private int RedBoxH = 32;
    private int RedBoxVert = 1;
    private int RedBoxHoro = 1;
    private double RedBoxSpeed = 0.3;
 
 
    public myPanel(){
 
 
 
 
 
 
    }
 
 
    private void MoveObject(){
 
            switch (RedBoxVert)
            {
                case 0: RedBoxY-=RedBoxSpeed;
                    break;
                case 1: RedBoxY+=RedBoxSpeed;
                    break;
            }
 
            switch (RedBoxHoro)
            {
                case 0: RedBoxX-=RedBoxSpeed;
                    break;
                case 1: RedBoxX+=RedBoxSpeed;
                    break;
            }
 
 
        }
 
 
    static int checkCollisionHOROSONTAL(double x, double y, int horo, int width){
 
                if ((x + width >= Room_Width))
                {horo = 0;}
 
                if ((x  <= 0))
                {horo = 1;}
 
                return horo;
 
            }
 
 
            static int checkCollisionVertical(double x, double y, int vert1, int height){
 
                if ((x + height >= Room_Height))
                {vert1 = 0;}
 
                if ((x  <= 0))
                vert1 = 1;
 
                return vert1;
 
            }
 
 
 
 
 
 
 
 
    @Override
    public Dimension getPreferredSize(){
        return new Dimension(Room_Width,Room_Height);
    }
 
 
 
 
 
 
    @Override
    public void paintComponent(Graphics g){
 
        super.paintComponent(g);
        {
         super.paintComponent(g);
                MoveObject();
                checkCollisionHOROSONTAL(RedBoxX, RedBoxY, RedBoxHoro, RedBoxW);
                checkCollisionVertical(RedBoxX, RedBoxY, RedBoxVert, RedBoxH);
 
                int RedBoxXINT = (int)RedBoxX;
                int RedBoxYINT = (int)RedBoxY;
 
         g.setColor(Color.RED);
         g.fillRect(RedBoxXINT, RedBoxYINT, RedBoxW, RedBoxH);
         g.setColor(Color.BLACK);
         g.drawRect(RedBoxXINT, RedBoxYINT, RedBoxW, RedBoxH);
 
 
         repaint();
 
        }
 
    }
 
 
}

import java.util.Scanner;
 
// The Bandwidth class
 
 
public class WebHostOrder14 {
 
    private double highestCharge; // instance variable for highestCharge
    private double lowestCharge; // instance variable for lowestCherge
 
    private Scanner scanner;
 
    //create a new constructor to do the work
    public WebHostOrder14() {
        WebHost webHost;
        double average;
        double shipping;
        double highest;
        double lowest;
 
        System.out.println("\nWelcome to the Web Host Ordering System\n");
        scanner = new Scanner(System.in);
        average = computeAverageSales();
        System.out.printf("\nThe average sales for these packages is: $" + average);
        if (average >= 200) {
            System.out.println("\nWow! Those sales are awesome!!\n");
        }
        shipping = computeShippingCharges();
         System.out.printf("\nThe shipping charges total up to $" + shipping);
    }
 
    private double computeAverageSales() {
        WebHost webHost;
        double average;
        double total = 0;
        int counter = 0;
 
        while (true) {
            System.out.printf("Please enter the price of the new package: $");
            double webHostPrice = scanner.nextDouble();
            total = webHostPrice + total;
            counter++;
            if (webHostPrice == 0 || webHostPrice == 0.00) {
                break;
            } else if (webHostPrice <= -1) {
                System.out.println("Please, enter a positive number!");
            } else if (webHostPrice > 500) {
                System.out.println("That is unrealistic, please enter the correct amount!");
            } else if (webHostPrice >=1  || webHostPrice <= 500){
            System.out.printf("You entered price $" + webHostPrice);
            }// end webHostPrice validation
 
            System.out.print("What will be the product ID: ");
            int webHostId = scanner.nextInt();
            scanner.nextLine();
            if (webHostId <= 0) {
                System.out.println("Please, enter a positive number!");
            } else if (webHostId > 10000) {
                System.out.println("Please enter the correct produce ID!");
            } // end webHostId validation statements
 
            System.out.print("What is the product name: ");
            String webHostName = scanner.next();
            if (webHostName == null){
                System.out.println("Please enter a valid product name!");
            }// end webHostName validation
 
            System.out.print("Please enter the required Bandwidth needed for your site? ");
            double webHostBandwidth = scanner.nextDouble();
            if (webHostBandwidth <= 0){
                System.out.println("Please enter a positive number!");
            } else if (webHostBandwidth > 1000000){
                System.out.println("That seems high are you sure?");
            } // end webHostBandwidth validation
 
            System.out.print("How many FTP accounts do you need? ");
            int webHostFtp = scanner.nextInt();
            if (webHostFtp <= 0){
                System.out.println("Please enter a positive number!");
            } else if (webHostFtp > 100){
                System.out.println("Please enter a valid number!");
            } // emd webHostFtp validation
 
            System.out.print("How many email accounts do you need? ");
            int webHostMail = scanner.nextInt();
            if (webHostMail <= 0){
                System.out.print("Please enter a positive number!");
            } else if (webHostMail > 500){
                System.out.println("Please enter a valid number!");
            } // end webHostMail validation
 
            System.out.print("What is your domain name? ");
            String webHostDomain = scanner.next();
            if (webHostDomain == null){
                System.out.println("Please enter a valid domain!");
            } // end webHostDomain validation
        } // end while statement
    average  = total / (counter - 1);
    return average;
} // end computeAverageSales
 
 
   [SIZE=4] /*Here is where my problem is*/[/SIZE]
private double computeShippingCharges() {
    WebHost webHost;
        double shipping = 0;
        double highest;
        double lowest;
        double x = 0;
        double y = 0;
 
 
        System.out.println("\nWelcome to the Shipping Wizard!\n");
        System.out.println("\nEnter 0 to end!\n");
 
 
 
       // while (true) {
            // Acquire a price. A price == 0 indicates end-of-data
 
            System.out.print("Please enter shipping charges: $");
            double charges = scanner.nextDouble();
            charges = x;
            if (charges < x){
                highest = x;
                System.out.printf("The highest sales price added was $" + highest);
            } else if (charges > x){
                x= y;
                lowest = y;
                System.out.print("The lowest value was $" + lowest);
            }
 
            // Test for end-of-data
           /*  if (charges <= -1) {
                System.out.println("Please enter a positive number!");
                charges = scanner.nextDouble();
            } else if (charges > 1000) {
                System.out.println("That is unrealistic please enter the correct value!");
                charges = scanner.nextDouble();
            } else if (charges == 0){
                break;
            }
 
 
 
        }*/
 
        return shipping;
}
 
    public static void main(String[] args) {
        WebHost webHost = new WebHost();
        new WebHostOrder14();
    } // end main
} // end program

class WebHost {
 
    private double bandwidth, price, [SIZE=4]highest, lowest[/SIZE];
    private int ftp, mail, id;
    private String domain, name;
 
    // Constructors
    WebHost() {
        setWebHostBandwidth(0.0);
        setWebHostPrice(0.0);
        [SIZE=4]setWebHostHighest(0.0); //// added this////
        setWebHostLowest(0.0); //// and added this////[/SIZE]
        setWebHostFtp(0);
        setWebHostMail(0);
        setWebHostId(0);
        setWebHostDomain("");
        setWebHostName("");
 
    } // End WebHost
 
    WebHost(double bandwidth, double price, [SIZE=4]double highest, double lowest[/SIZE], int ftp, int mail, int id,
            String domain, String name) {
        setWebHostBandwidth(bandwidth);
        setWebHostPrice(price);
        [SIZE=4]setWebHostHighest(highest);
        setWebHostLowest(lowest);[/SIZE]
        setWebHostFtp(ftp);
        setWebHostMail(mail);
        setWebHostId(id);
        setWebHostDomain(domain);
        setWebHostName(name);
 
    } // end WebHost
 
    //Getters and Setters
    public double getWebHostBandwidth() {
        return bandwidth;
    } //end getWebHostBandwidth
 
    public double getWebHostPrice() {
        return price;
    } //end getWebHostPrice
    [SIZE=4]////added the next 2 sections of code below//// 
    public double getWebHostHighest(){
        return highest;
    }
 
    public double getWebHostLowest(){
        return lowest;
    }
[/SIZE]
    public int getWebHostFtp() {
        return ftp;
    } //end getWebHostFtp
 
    public int getWebHostMail() {
        return mail;
    } //end getWebHostMail
 
    public int getWebHostId() {
        return id;
    } //end getWebHostId
 
    public String getWebHostDomain() {
        return domain;
    } //end getWebHostDomain
 
    public String getWebHostName() {
        return name;
    } //end getWebHostName  
 
    public final void setWebHostBandwidth(double bandwidth) {
        this.bandwidth = bandwidth;
    } //end setBandwidth
 
    public final void setWebHostPrice(double price) {
        this.price = price;
    }//end setPrice
    [SIZE=4]//// again I added the next 2 sections below as well//////
    public final void setWebHostHighest(double highest){
        this.highest = highest;
    }
 
    public final void setWebHostLowest(double lowest){
        this.lowest = lowest;
    }
[/SIZE]
    public final void setWebHostFtp(int ftp) {
        this.ftp = ftp;
    } //end setFtp
 
    public final void setWebHostMail(int mail) {
        this.mail = mail;
    } //end setMail
 
    public final void setWebHostId(int id) {
        this.id = id;
    } //end setId
 
    public final void setWebHostDomain(String domain) {
        this.domain = domain;
    } //end setDomain
 
    public final void setWebHostName(String name) {
        this.name = name;
    } //end setName
 
    // Display WebHost data
     public void display() {
     System.out.println("\nThank you for your order you ordered a package "
     + "with\n" + "Bandwidth: " + getWebHostBandwidth() + " Mbits\n"
     + getWebHostFtp() + " FTP accounts\n" + getWebHostMail()
     + " mail accounts\n" + "For the domain of\n " + getWebHostDomain());
     System.out.println("This package has an ID of: " + getWebHostId()
     + "/nThe package name is: " + getWebHostName() + "/nThe price is set at: $"
     + getWebHostPrice());
     } // end display()
} // end class WebHost

import javax.swing.JOptionPane;
 
 
public class hotelDemo2Arnette
{
	public static void main (String[] args)
	{
		getFloors();
		getRooms();
		getOccupied();
		displayMethod();
 
 
	}
	public static void getFloors()
		{
			String input; 
			double occNum;
			double occNext;
			double occTot = 0;										//Our variables....
			double toNum;
			double floorNum;
			double floorTot = 0;
 
			Hotel worker = new Hotel();								//We make a new object....
 
			input = JOptionPane.showInputDialog("How many floors does the hotel have?");				//Start getting our input.
			toNum = Double.parseDouble(input);
			for (int i = 1; i <= toNum; i++)
		}
 
	public static void getRooms()
		{
			input = JOptionPane.showInputDialog("How many rooms does floor " + i + " have?");
			floorNum = Double.parseDouble(input);
			floorTot += floorNum;
			worker.setTotalRooms(floorTot);
		}
 
 
	public static void getOccupied()
		{
			input = JOptionPane.showInputDialog("How many occupied rooms does floor 1 have?");
			occNum = Double.parseDouble(input);
			for (int i = 2; i <= toNum; i++)
 
			input = JOptionPane.showInputDialog("How many occupied rooms does floor " + i + " have?");
			occNext = Double.parseDouble(input);
			occTot += occNext + occNum;
			worker.setTotalFull(occTot);
		}
 
	public static void displayMethod()	
		{
			JOptionPane.showMessageDialog(null, "So that's " + worker.getTotalRooms() + " and " + worker.getTotalFull() + " are full.");
			JOptionPane.showMessageDialog(null, "That means you have " + worker.getOccupancy() + " rooms empty, " 
												+ "giving you an occupancy rate of " + worker.getVacancy() + "%" );
 
			if (worker.getVacancy() < 80.0)
			{
				JOptionPane.showMessageDialog(null, "Contact Manager");
			}
 
			System.exit(0);
		}										
 
 
}

public class hotelDemo1Arnette
{
	private double totalRooms;
	private double totalFull;
	private double occupancy;
	private double vacancy;
 
 
	public hotelDemo1Arnette()
	{
		totalRooms = 0.0;
		totalFull = 0.0;
		occupancy = 0.0;
		vacancy = 0.0;
	}
	public void setTotalRooms(double rooms)
	{
		totalRooms = rooms;
	}
 
	public void setTotalFull(double full)
	{
		totalFull = full;
	}
 
	public double getTotalRooms()
	{
		return totalRooms;
	}
 
	public double getTotalFull()
	{
		return totalFull;
	}
 
	public double getOccupancy()
	{
		occupancy = totalRooms - totalFull;
		return occupancy;
	}
 
	public double getVacancy()
	{
		vacancy = (occupancy / totalRooms) * 100;
		return vacancy;
	}