import java.awt.*;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.*;import java.io.*;
import javax.swing.*;import javax.imageio.*;
import java.awt.Color;
import java.awt.Graphics;
 
public class GridBags extends JFrame{
 
 
	JPanel thePanel;
 
	public GridBags(){
		super();
 
 
		//general settings
		this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		this.setSize(1000, 500);
 		this.setResizable(false);
 		this.setTitle("Biology Review Program");
 		this.setVisible(true);
 		this.setLayout(new GridBagLayout());
 
		initComponents();
 
	}
 
	public void initComponents(){
 
 
 
 
 
		//This variable is changed to allow us to place buttons
		//and other components flexibly on the page.
		GridBagConstraints c = new GridBagConstraints();
		c.fill = GridBagConstraints.NONE;
 
		JButton lesson = new JButton("Lessons");
		c.gridwidth = 1;
		c.gridheight = 1;
		c.gridx = 1;
		c.gridy = 500;
		this.add(lesson, c);
		lesson.addActionListener(new ActionListener() {
 
            public void actionPerformed(ActionEvent e){
				System.out.println("You clicked for Lesson?");
 
            }
        });  
 
		//create the myCreature object
		thePanel = new JPanel();
		//set the size and background of the panel
		thePanel.setPreferredSize(new Dimension(700, 500));
		thePanel.setBackground(new java.awt.Color(0, 0, 0));
		//add the panel to the pane
		c.gridwidth = 2;  //six "buttons" wide
		c.gridheight = 1;
		c.gridx = 3;		//left most
		c.gridy = 1;		//top most
		this.add(thePanel, c);
 
		JButton quiz = new JButton("Quiz");
		c.gridwidth = 1;
		c.gridheight = 1;
		c.gridx = 2;
		c.gridy = 500;
		this.add(quiz, c);
		quiz.addActionListener(new ActionListener() {
 
            public void actionPerformed(ActionEvent e){
				System.out.println("You clicked for Quiz?");
 
            }
        });  
 
 
		JButton help = new JButton("Help");
		c.gridwidth = 1;
		c.gridheight = 1;
		c.gridx = 3;
		c.gridy = 500;
		this.add(help, c);
		help.addActionListener(new ActionListener() {
  [COLOR="#FF0000"]	Image img=null;
    		try {img=ImageIO.read(new File("help.jpg"));}
  			catch(IOException e)
      	    {System.out.println("ok");System.exit(0);}
    		g.drawImage(img,200,0,this);[/COLOR]
 
 
                 public void actionPerformed(ActionEvent e){
				System.out.println("You clicked for Help?");
 
            }
        });  
 
 
	}
 
 
 
	public static void main(String[] args){
 
		GridBags example = new GridBags();
		example.pack();
		example.show();
	}
 
 
 
 
 
}

import java.util.*;
 
 
    class deadlineprototype
    {
 
 
    public static void main(String args[])
    {
 
 
    Scanner sc = new Scanner(System.in);
 
 
    System.out.println("enter no. of processes : ");
    int n=sc.nextInt();
    int job[]=new int[n+1];
    int burst[]=new int[n+1];
    int newburst[]=new int[n+1];
    int arrival[]=new int[n+1];
    int deadline[]=new int[n+1];
    int wt[]=new int[n+1];
    int turn[]=new int[n+1];
    int tot_turn=0;
    int tot_wait=0;
    float avg_turn=0;
    float avg_wait=0;
    int j;
 
    for(int m=1;m<=n;m++)
        {
        arrival[m]=m;
        }
    for(int m=1;m<=n;m++)
        {
        job[m]=m;
        }
 
    for(int m=1;m<=n;m++)
        {
        System.out.println("enter arrival time, burst time and deadline of process "+(m)+"(0 for none):");
        arrival[m]=sc.nextInt();
        burst[m]=sc.nextInt();
        deadline[m]=sc.nextInt();
 
    if (deadline[m]==0){
        deadline[m]=1000;
    }
        }
 
 
 
    int temp;
    for(int i=1;i<n;i++)
        {
        for(j=1;j<n;j++)
            {
 
                if(deadline[i+1]<deadline[j])
                {
                temp=deadline[j+1];
                deadline[j+1]=deadline[j];
                deadline[j]=temp;
 
                temp=job[j+1];
                job[j+1]=job[j];
                job[j]=temp;
 
                temp=burst[j+1];
                burst[j+1]=burst[j];
                burst[j]=temp;
                }
        }
        }
    turn[1]=burst[1];    
 
    for(int i=2;i<=n;i++)
        {
        turn[i]=burst[i]+turn[i-1];
        wt[i]=turn[i]-burst[i];
        }
    for(int i=1;i<=n;i++)
        {
        tot_turn+=(wt[i]+burst[i])-arrival[i];
        avg_turn=(float)tot_turn/n;
        tot_wait+=wt[i]-arrival[i];
        avg_wait=(float)tot_wait/n;
        }
    System.out.println("----------Earliest Deadline Scheduling Diagram----------");
    for(int m=1;m<=n;m++)
        {
    if(deadline[m]==1000){
            deadline[m]=0;
            }
    if(wt[m]==0){
            System.out.println("0"+wt[m]+" _____"); 
    }
    else{
    System.out.println(wt[m]+" _____"); 
    }
            System.out.println("  |     |");
 
            System.out.println("  |job "+job[m]+"|");
 
            System.out.println("  |_____|");
                    try
                 {
                 //newburst[m]=(burst[m]*1000);
                 Thread.sleep(1000);  
                 }catch (InterruptedException ie)
                 {
                 System.out.println(ie.getMessage());
                 }
    }
    System.out.println((wt[wt.length-1]+burst[burst.length-1]));

enter no. of processes : 
    2
    enter arrival time, burst time and deadline of process 1(0 for none):
    0 17 0
    enter arrival time, burst time and deadline of process 2(0 for none):
    0 13 10
    ----------Earliest Deadline Scheduling Diagram----------
    00 _____
      |     |
      |job 2|
      |_____|
    13 _____
      |     |
      |job 1|
      |_____|
    30

enter no. of processes : 
    3
    enter arrival time, burst time and deadline of process 1(0 for none):
    0 17 0
    enter arrival time, burst time and deadline of process 2(0 for none):
    0 13 10
    enter arrival time, burst time and deadline of process 3(0 for none):
    25 14 20
    ----------Earliest Deadline Scheduling Diagram----------
    00 _____
      |     |
      |job 2|
      |_____|
    13 _____
      |     |
      |job 3|
      |_____|
    27 _____
      |     |
      |job 1|
      |_____|
    44

enter no. of processes : 
    5
    enter arrival time, burst time and deadline of process 1(0 for none):
    0 17 0
    enter arrival time, burst time and deadline of process 2(0 for none):
    0 13 10
    enter arrival time, burst time and deadline of process 3(0 for none):
    25 14 20
    enter arrival time, burst time and deadline of process 4(0 for none):
    25 10 15
    enter arrival time, burst time and deadline of process 5(0 for none):
    30 5 0
    ----------Earliest Deadline Scheduling Diagram----------
    00 _____
      |     |
      |job 2|
      |_____|
    13 _____
      |     |
      |job 1|
      |_____|
    30 _____
      |     |
      |job 4|
      |_____|
    40 _____
      |     |
      |job 3|
      |_____|
    54 _____
      |     |
      |job 5|
      |_____|
    59

 
 
import java.util.*;
 
 
 
 
 
 
public class Grocery {
  public static void main(String[] args) {
    Scanner console = new Scanner(System.in);
 
  }
   private Scanner keybd;
    private ArrayList <> myList; //the <> are getting an error
 
  {
 
        keybd = new ArrayList(); //this is another error
        myList = new ArrayList(); //this is another error
    }
 
    public void startProgram()
    {
        int option = 0;
        System.out.println("Welcome to the Grocery Program!");
        System.out.println("1. Create a new Grocery List");
        System.out.println("2. Add sample items to the List");
        System.out.println("3. Remove an Item from the List");
        System.out.println("4. Print the list");
        System.out.println("5. Print the cost of all the Items");
        System.out.println("6. End the program");
        option = keybd.nextInt();
        keybd.nextLine();
 
         switch (option) {
 
 
            case 1:  createList(); //error
            //this is a break it will exit the loop
            break;
            case 2:  setList(); //error
            break;
            case 3:  removeItem(); //errpr
            break;
            case 4:  printList(); //error
            break;
            case 5:  printCost(); //error
            break;
            case 6:  endProgram(); //error
            break;
            default: inCorect(); //error
            startProgram();
            break;
        } 
    }
 
      private void createList()
    {
        //this is a stopper the program will continue until it is typed
        String stop = "st0p";
        String addAnother = ""; 
        String newItem = "";
        double newPrice = 0.0;
        //first we ask the question that the user will answer
        System.out.print("please enter an items name: ");
       String newItem = console.next();
        //next we need to check that variable with the stop
        while(!(newItem.equals(stop))){
            //now we ask the next question 
            System.out.print("please enter an items price: ");
            String newPrice = console.next();
            keybd.nextLine();
            //this will add a blank line
            System.out.println(); 
            //we than have to ask rhe question again 
            System.out.print("please enter an items name: ");
            String addAnother = console.next();
            if(newItem && newPrice ){
                System.out.println("incorect item please try again");
                createList();
            }else{
                myList.add();
            }
        }
        startProgram();
    }
 
  /*  private void setList()
    {
        //this is sample data that we will fill in for testing purposes 
        myList.add();
        myList.add();
        myList.add();
        myList.add(new Grocery();
        myList.add(;
        myList.add();
        myList.add();
        startProgram();
    }
*/
    private void removeItem()
    {
        //this is a for statement you need to have three statements inside  
        for(){
            //i add a number in front of every item for easy access to data
            System.out.print(index + " " );
            myList.get(index).printItem();
        }
        //ask a question
        System.out.println("which item would you like to remove?");
         String remove = keybd.nextInt();
        myList.remove();
        startProgram();
    }
    /**
     * this will print the list
     */
    private void printList()
    {
        for(; ;index++){ 
            myList.get();
        }
        startProgram();
    }
    /**
     * print just the price
     */
    private void printCost()
    {
        for(; index < myList.size();){ 
            System.out.println(myList.get());
        }
        startProgram();
    }
    /**
     * this is an incorrect message 
     */
    private void inCorect()
    {
        System.out.println("the item you are looking for is invalid please try again");
    }
    /**
     * this is the end message 
     */
    private void endProgram()
    {
        System.out.println("Thanks for using this program");
    }
 
 
 
 
 
    private double price;
    private String name;
 
    /**
     * This is the constructor
     */
    public Grocery(String newName, double newPrice)
    { 
        name = newName;
        price = newPrice;
    }
 
 
    //======================+Accessors+=================================
    /**
     * this method is to return the name of the item
     * 
     * @return name of item 
     */
 
    public String getName()
    {
        return name;
    }
 
    /**
     * this will return the price
     * 
     * @return price of item 
     */
 
    public double getPrice()
    {
        return price;
    }
 
    //======================+Mutators+==================================
    /**
     * this will set a new name of an item
     * 
     * @param  newName a caller will set the name
     */
 
    public void setName(String newName)
    { 
        name = newName;
    }
 
    /**
     * this will set a new price of an item
     * 
     * @param  newPrice a caller will set the price
     */
 
    public void setPrice(double newPrice)
    { 
        price = newPrice;
    }
 
    /**
     * this will print an item
     */
 
    public void printItem()
    {
        System.out.println("the item is: " + name + " the price is: "+ price);
 
 
 
 
 
    }}

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;
	}
}

pi = 4/1 + 4/3 - 4/5 + 4/7 ...

double pi = 0.0;
				long divisor = 1;
				boolean positive = false;
 
				for(long i = 0; i < Long.MAX_VALUE; i++)
				{
					double n = ((double)4 / (double)divisor);
					if(positive)
						pi -= n;
					else
						pi += n;
					positive = !positive;
					divisor += 2;
				}
 
				print("Pi calculated as: " + pi);