PickerApp CLass.pdf
•
0 likes•1 view
//**************************** PickerApp CLass****************************************************** package increment.pick; import java.util.Random; public class PickerApp { private int upperLimit; private int number; private int guessCount; /** * Default constructor */ public PickerApp() { this(50); } /** * Parameterized constructor * param upperLimit */ public PickerApp(int upperLimit) { this.upperLimit = upperLimit; Random random = new Random(); number = random.nextInt(upperLimit - 1) + 1; guessCount = 1; } public int getNumber() { return number; } public int getGuessCount() { return guessCount; } public int getUpperLimit() { return upperLimit; } public void incrementGuessCount() { guessCount = guessCount + 1; } } //********************************** PICK CLass**************************************************** package increment.pick; import java.util.Scanner; public class Pick { public static void main(String args[]) { System.out.println(\"Hello \"); System.out.println(); Scanner sc = new Scanner(System.in); PickerApp game = new PickerApp(); System.out.println(\"I have selected a number between 0 and \" + game.getUpperLimit()); System.out.println(); while(true) { System.out.print(\"Enter your guess: \"); //A) a) int guess = 0; try { //C) g) guess = Integer.parseInt(sc.nextLine()); //A) a) } catch(NumberFormatException nfe) { System.out.println(\"Invalid number\"); continue; } //D) i) if((guess <= 0) || (guess >= game.getUpperLimit())) System.out.println(\"Enter a between 0 and \" + game.getUpperLimit() + \" both exclusive\"); else { if(guess == game.getNumber()) //A) b) If user guesses the correct number break break; else if (guess > (game.getNumber() + 10)) { //B) d) System.out.println(\"Way too high!\ \"); } else if (guess < game.getNumber()) { System.out.println(\"Your guess is too low.\ \"); } else if (guess > game.getNumber()) { System.out.println(\"Your guess is too high.\ \"); } } game.incrementGuessCount(); } //B) e) if(game.getGuessCount() <= 3) System.out.println(\"Great work! You are a mathematical wizard.\"); else if((game.getGuessCount() > 3) && (game.getGuessCount() <= 7)) System.out.println(\"Not too bad! You\'ve got some potential.\"); else if(game.getGuessCount() > 7) System.out.println(\"What took so you so long? Maybe you shoould take some lessons\"); //Close scanner sc.close(); } } SAMPLE OUTPUT: Hello I have selected a number between 0 and 50 Enter your guess: 0 Enter a between 0 and 50 both exclusive Enter your guess: 50 Enter a between 0 and 50 both exclusive Enter your guess: 2 Great work! You are a mathematical wizard. Solution //**************************** PickerApp CLass****************************************************** package increment.pick; import java.util.Random; public class PickerApp { private int upperLimit; private int number; private int guessCount; /** * Default constructor */ public PickerApp() { this(50); } /** * Parameterized constructor * param upperLimit */ public PickerApp(int upperLimit).
Report
Share
Report
Share
Download to read offline
![}
}
//********************************** PICK
CLass****************************************************
package increment.pick;
import java.util.Scanner;
public class Pick {
public static void main(String args[]) {
System.out.println("Hello ");
System.out.println();
Scanner sc = new Scanner(System.in);
PickerApp game = new PickerApp();
System.out.println("I have selected a number between 0 and " + game.getUpperLimit());
System.out.println();
while(true) {
System.out.print("Enter your guess: "); //A) a)
int guess = 0;
try { //C) g)
guess = Integer.parseInt(sc.nextLine()); //A) a)
} catch(NumberFormatException nfe) {
System.out.println("Invalid number");
continue;
}
//D) i)
if((guess <= 0) || (guess >= game.getUpperLimit()))
System.out.println("Enter a between 0 and " + game.getUpperLimit() + " both
exclusive");
else {
if(guess == game.getNumber()) //A) b) If user guesses the correct number break
break;
else if (guess > (game.getNumber() + 10)) { //B) d)
System.out.println("Way too high! ");
}
else if (guess < game.getNumber()) {](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
operating system linux,ubuntu,Mac Geometri.pdf
//operating system linux,ubuntu,Mac
/*********************GeometricObject.java**********************/
public abstract class GeometricObject {
private String color = \"white\";
private boolean filled;
// default constructure
public GeometricObject() {
super();
// TODO Auto-generated constructor stub
}
// construct a Geometric Object
// parameterized constructure
public GeometricObject(String color, boolean filled) {
this.color = color;
this.filled = filled;
}
/** Getter method for color */
public String getColor() {
return color;
}
/** Setter method for color */
public void setColor(String color) {
this.color = color;
}
/**
* Getter method for filled. Since filled is boolean, so the gret method
* name is isFilled
*/
public boolean isFilled() {
return filled;
}
/** Setter method for filled */
public void setFilled(boolean filled) {
this.filled = filled;
}
/** Abstract method for FindArea */
public abstract double findArea();
/** Abstract method for findPerimeter */
public abstract double findPerimeter();
}
/*****************************Octagon.java**************/
public class Octagon extends GeometricObject implements Cloneable, Comparable {
private double side;
/** construct a Octagon with specified side */
public Octagon(double side) {
super();
this.side = side;
}
/** Implement the abstract method findArea in GeometricObject */
@Override
public double findArea() {
double area = (2 + 4 / Math.sqrt(2)) * side * side;
return area;
}
/** Implement the abstract method findArea in findPerimeter */
@Override
public double findPerimeter() {
double perimeter = 8 * side;
return perimeter;
}
/** Implement the compareTo method in Comparable interface */
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
return 0;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
/*******************App.java*******************/
public class App {
public static void main(String[] args) {
Octagon a1 = new Octagon(5);//creating object of octagon
System.out.println(\"Area of a1 is \" + a1.findArea());
System.out.println(\"Perimeter of a1 is \" + a1.findPerimeter());
Object a2;
try {
a2 = a1.clone();
String result = (a1.compareTo(a2) == 0) ? \"a1 and its clone a2 have the same area\"
: \"a1 and its clone a2 have different areas\";
System.out.println(\"Compare a1 and its clone a2:\ \\t \" + result);
System.out.println(\"Hashcode of a1: \" + a1.hashCode());
System.out.println(\"Hashcode of a2: \" + a2.hashCode());
System.out.println(\"Displaying a1: \" + a1);
System.out.println(\"Displaying a2: \" + a2);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
/*****************output***************/
gopal@gopal:~/Desktop/chegg$ javac GeometricObject.java
gopal@gopal:~/Desktop/chegg$ javac Octagon.java
gopal@gopal:~/Desktop/chegg$ javac App.java
gopal@gopal:~/Desktop/chegg$ java App
Area of a1 is 120.71067811865476
Perimeter of a1 is 40.0
Compare a1 and its clone a2:
a1 and its clone a2 have the same area
.
New folderjsjfArrayStack.classpackage jsjf;publicsynchronize.docx
New folder/jsjf/ArrayStack.classpackage jsjf;
publicsynchronizedclass ArrayStack implements StackADT {
privatestaticfinal int DEFAULT_CAPACITY = 100;
private int top;
private Object[] stack;
public void ArrayStack();
public void ArrayStack(int);
public void push(Object);
private void expandCapacity();
public Object pop() throws exceptions.EmptyCollectionException;
public Object peek() throws exceptions.EmptyCollectionException;
public int size();
public boolean isEmpty();
public String toString();
}
New folder/jsjf/ArrayStack.javaNew folder/jsjf/ArrayStack.javapackage jsjf;
import jsjf.exceptions.*;
import java.util.Arrays;
// -------------------------------------------------------
// Author: Yifu Wu
// Date: 03/10/16
// Source Name: ArrayStack<T>
// Due date: 03/10/16
// Description:
/**
* An array implementation of a stack in which the bottom of the
* stack is fixed at index 0.
*
* @author Java Foundations
* @version 4.0
*/
publicclassArrayStack<T>implementsStackADT<T>
{
privatefinalstaticint DEFAULT_CAPACITY =100;
privateint top;
private T[] stack;
/**
* Creates an empty stack using the default capacity.
*/
publicArrayStack()
{
this(DEFAULT_CAPACITY);
}
/**
* Creates an empty stack using the specified capacity.
* @param initialCapacity the initial size of the array
*/
publicArrayStack(int initialCapacity)
{
top =0;
stack =(T[])(newObject[initialCapacity]);
}
/**
* Adds the specified element to the top of this stack, expanding
* the capacity of the array if necessary.
* @param element generic element to be pushed onto stack
*/
publicvoid push(T element)
{
if(size()== stack.length)
expandCapacity();
stack[top]= element;
top++;
}
/**
* Creates a new array to store the contents of this stack with
* twice the capacity of the old one.
*/
privatevoid expandCapacity()
{
//stack = Arrays.copyOf(stack, stack.length * 2);
System.out.println("Expanding stack capacity\n");
T[] temp =(T[])(newObject[2*top]);
for(int i=0; i< top; i++)
temp[i]= stack[i];
stack = temp;
}
/**
* Removes the element at the top of this stack and returns a
* reference to it.
* @return element removed from top of stack
* @throws EmptyCollectionException if stack is empty
*/
public T pop()throwsEmptyCollectionException
{
if(isEmpty())
thrownewEmptyCollectionException("stack");
top--;
T result = stack[top];
stack[top]=null;
return result;
}
/**
* Returns a reference to the element at the top of this stack.
* The element is not removed from the stack.
* @return element on top of stack
* @throws EmptyCollectionException if stack is empty
*/
public T peek()throwsEmptyCollectionException
{
if(isEmpty())
thrownewEmptyCollectionException("stack");
return stack[top-1];
}
/**
* Returns the number of elements in ...
StackInterface An interface for the ADT stack. Do not modif.pdf
StackInterface
/**
An interface for the ADT stack.
Do not modify this file
*/
package PJ2;
public interface StackInterface
{
/** Gets the current number of data in this stack.
@return the integer number of entries currently in the stack*/
public int size();
/** Adds a new data to the top of this stack.
@param aData an object to be added to the stack */
public void push(T aData);
/** Removes and returns this stack\'s top data.
@return either the object at the top of the stack or,
if the stack is empty before the operation, null */
public T pop();
/** Retrieves this stack\'s top data.
@return either the data at the top of the stack or
null if the stack is empty */
public T peek();
/** Detects whether this stack is empty.
@return true if the stack is empty */
public boolean empty();
/** Removes all data from this stack */
public void clear();
} // end StackInterface
SimpleLinkedStack.java
/**
A class of stacks whose entries are stored in a chain of nodes.
Implement all methods in SimpleLinkedStack class using
the inner Node class.
Main Reference : text book or class notes
Do not change or add data fields
Do not add new methods
You may access Node object fields directly, i.e. data and next
*/
package PJ2;
public class SimpleLinkedStack implements StackInterface
{
// Data fields
private Node topNode; // references the first node in the chain
private int count; // number of data in this stack
public SimpleLinkedStack()
{
// add stataments
} // end default constructor
public void push(T newData)
{
// add stataments
} // end push
public T peek()
{
// add stataments
return null;
} // end peek
public T pop()
{
// add stataments
return null;
} // end pop
public boolean empty()
{
// add stataments
return false;
} // end empty
public int size()
{
// add stataments
return -1;
} // end isEmpty
public void clear()
{
// add stataments
} // end clear
public String toString()
{
// add stataments
// note: data class in stack must implement toString() method
// return a list of data in Stack, separate them with \',\'
return \"\";
}
/****************************************************
private inner node class
Do not modify this class!!
you may access data and next directly
***************************************************/
private class Node
{
private T data; // entry in list
private Node next; // link to next node
private Node (T dataPortion)
{
data = dataPortion;
next = null; // set next to NULL
} // end constructor
private Node (T dataPortion, Node nextNode)
{
data = dataPortion;
next = nextNode; // set next to refer to nextNode
} // end constructor
} // end Node
/****************************************************
Do not modify: Stack test
****************************************************/
public static void main (String args[])
{
System.out.println(\"\ \"+
\"*******************************************************\ \"+
\"Sample Expected output:\ \"+
\"\ \"+
\"OK: stack is empty\ \"+
\"Push 3 data: 10, 30, 50\ \"+
\"Print stack [50,30,10,]\ \"+
\"OK: sta.
java write a program to evaluate the postfix expressionthe program.pdf
java write a program to evaluate the postfix expression
the program should ask users for input and show the postfix epression and then the result.
and to have a try and catch exception since we have an empty stack
Solution
Postfix.java
import java.util.Scanner;
public class Postfix
{
/**
* Reads and evaluates multiple postfix expressions.
*/
public static void main (String[] args)
{
String expression, again;
int result;
try
{
Scanner in = new Scanner(System.in);
do
{
PostfixEvaluator evaluator = new PostfixEvaluator();
System.out.println (\"Enter a valid postfix expression: \");
expression = in.nextLine();
result = evaluator.evaluate (expression);
System.out.println();
System.out.println (\"That expression equals \" + result);
System.out.print (\"Evaluate another expression [Y/N]? \");
again = in.nextLine();
System.out.println();
}
while (again.equalsIgnoreCase(\"y\"));
}
catch (Exception IOException)
{
System.out.println(\"Input exception reported\");
}
}
}
PostfixEvaluator.java
//import datastructures.ArrayStack;
import java.util.StringTokenizer;
public class PostfixEvaluator
{
/** constant for addition symbol */
private final char ADD = \'+\';
/** constant for subtraction symbol */
private final char SUBTRACT = \'-\';
/** constant for multiplication symbol */
private final char MULTIPLY = \'*\';
/** constant for division symbol */
private final char DIVIDE = \'/\';
/** the stack */
private ArrayStack stack;
/**
* Sets up this evaluator by creating a new stack.
*/
public PostfixEvaluator()
{
stack = new ArrayStack();
}
/**
* Evaluates the specified postfix expression. If an operand is
* encountered, it is pushed onto the stack. If an operator is
* encountered, two operands are popped, the operation is
* evaluated, and the result is pushed onto the stack.
* //param expr String representation of a postfix expression
* //return int value of the given expression
*/
public int evaluate (String expr)
{
int op1, op2, result = 0;
String token;
StringTokenizer tokenizer = new StringTokenizer (expr);
while (tokenizer.hasMoreTokens())
{
token = tokenizer.nextToken();
if (isOperator(token))
{
op2 = (stack.pop()).intValue();
op1 = (stack.pop()).intValue();
result = evalSingleOp (token.charAt(0), op1, op2);
stack.push (new Integer(result));
}
else
stack.push (new Integer(Integer.parseInt(token)));
}
return result;
}
/**
* Determines if the specified token is an operator.
* //param token String representing a single token
* //return boolean true if token is operator
*/
private boolean isOperator (String token)
{
return ( token.equals(\"+\") || token.equals(\"-\") ||
token.equals(\"*\") || token.equals(\"/\") );
}
/**
* Performs integer evaluation on a single expression consisting of
* the specified operator and operands.
* //param operation operation to be performed
* //param op1 the first operand
* //param op2 the second operand
* //return int value of the expression
*/
private int evalSingleOp (char operation, int op1, int op2)
{
int result = 0;
switch .
import java.util.Scanner;public class Factorial { method usi.pdf
import java.util.Scanner;
public class Factorial
{
// method using recursion to find factorial of number
public static int factorial(int input)
{
// factorial of 0 is 1
if (input == 0)
{
return 1;
}
// else recursively call the function
else
{
return input * factorial(input - 1);
}
}
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
int input;
System.out.println(\"Enter a number: \");
input = scan.nextInt();
// store result in answer
int answer = factorial(input);
System.out.println(\"The factorial of \" + input + \" is \" + answer);
}
}
Solution
import java.util.Scanner;
public class Factorial
{
// method using recursion to find factorial of number
public static int factorial(int input)
{
// factorial of 0 is 1
if (input == 0)
{
return 1;
}
// else recursively call the function
else
{
return input * factorial(input - 1);
}
}
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
int input;
System.out.println(\"Enter a number: \");
input = scan.nextInt();
// store result in answer
int answer = factorial(input);
System.out.println(\"The factorial of \" + input + \" is \" + answer);
}
}.
Recommended
operating system linux,ubuntu,Mac Geometri.pdf
//operating system linux,ubuntu,Mac
/*********************GeometricObject.java**********************/
public abstract class GeometricObject {
private String color = \"white\";
private boolean filled;
// default constructure
public GeometricObject() {
super();
// TODO Auto-generated constructor stub
}
// construct a Geometric Object
// parameterized constructure
public GeometricObject(String color, boolean filled) {
this.color = color;
this.filled = filled;
}
/** Getter method for color */
public String getColor() {
return color;
}
/** Setter method for color */
public void setColor(String color) {
this.color = color;
}
/**
* Getter method for filled. Since filled is boolean, so the gret method
* name is isFilled
*/
public boolean isFilled() {
return filled;
}
/** Setter method for filled */
public void setFilled(boolean filled) {
this.filled = filled;
}
/** Abstract method for FindArea */
public abstract double findArea();
/** Abstract method for findPerimeter */
public abstract double findPerimeter();
}
/*****************************Octagon.java**************/
public class Octagon extends GeometricObject implements Cloneable, Comparable {
private double side;
/** construct a Octagon with specified side */
public Octagon(double side) {
super();
this.side = side;
}
/** Implement the abstract method findArea in GeometricObject */
@Override
public double findArea() {
double area = (2 + 4 / Math.sqrt(2)) * side * side;
return area;
}
/** Implement the abstract method findArea in findPerimeter */
@Override
public double findPerimeter() {
double perimeter = 8 * side;
return perimeter;
}
/** Implement the compareTo method in Comparable interface */
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
return 0;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
/*******************App.java*******************/
public class App {
public static void main(String[] args) {
Octagon a1 = new Octagon(5);//creating object of octagon
System.out.println(\"Area of a1 is \" + a1.findArea());
System.out.println(\"Perimeter of a1 is \" + a1.findPerimeter());
Object a2;
try {
a2 = a1.clone();
String result = (a1.compareTo(a2) == 0) ? \"a1 and its clone a2 have the same area\"
: \"a1 and its clone a2 have different areas\";
System.out.println(\"Compare a1 and its clone a2:\ \\t \" + result);
System.out.println(\"Hashcode of a1: \" + a1.hashCode());
System.out.println(\"Hashcode of a2: \" + a2.hashCode());
System.out.println(\"Displaying a1: \" + a1);
System.out.println(\"Displaying a2: \" + a2);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
/*****************output***************/
gopal@gopal:~/Desktop/chegg$ javac GeometricObject.java
gopal@gopal:~/Desktop/chegg$ javac Octagon.java
gopal@gopal:~/Desktop/chegg$ javac App.java
gopal@gopal:~/Desktop/chegg$ java App
Area of a1 is 120.71067811865476
Perimeter of a1 is 40.0
Compare a1 and its clone a2:
a1 and its clone a2 have the same area
.
New folderjsjfArrayStack.classpackage jsjf;publicsynchronize.docx
New folder/jsjf/ArrayStack.classpackage jsjf;
publicsynchronizedclass ArrayStack implements StackADT {
privatestaticfinal int DEFAULT_CAPACITY = 100;
private int top;
private Object[] stack;
public void ArrayStack();
public void ArrayStack(int);
public void push(Object);
private void expandCapacity();
public Object pop() throws exceptions.EmptyCollectionException;
public Object peek() throws exceptions.EmptyCollectionException;
public int size();
public boolean isEmpty();
public String toString();
}
New folder/jsjf/ArrayStack.javaNew folder/jsjf/ArrayStack.javapackage jsjf;
import jsjf.exceptions.*;
import java.util.Arrays;
// -------------------------------------------------------
// Author: Yifu Wu
// Date: 03/10/16
// Source Name: ArrayStack<T>
// Due date: 03/10/16
// Description:
/**
* An array implementation of a stack in which the bottom of the
* stack is fixed at index 0.
*
* @author Java Foundations
* @version 4.0
*/
publicclassArrayStack<T>implementsStackADT<T>
{
privatefinalstaticint DEFAULT_CAPACITY =100;
privateint top;
private T[] stack;
/**
* Creates an empty stack using the default capacity.
*/
publicArrayStack()
{
this(DEFAULT_CAPACITY);
}
/**
* Creates an empty stack using the specified capacity.
* @param initialCapacity the initial size of the array
*/
publicArrayStack(int initialCapacity)
{
top =0;
stack =(T[])(newObject[initialCapacity]);
}
/**
* Adds the specified element to the top of this stack, expanding
* the capacity of the array if necessary.
* @param element generic element to be pushed onto stack
*/
publicvoid push(T element)
{
if(size()== stack.length)
expandCapacity();
stack[top]= element;
top++;
}
/**
* Creates a new array to store the contents of this stack with
* twice the capacity of the old one.
*/
privatevoid expandCapacity()
{
//stack = Arrays.copyOf(stack, stack.length * 2);
System.out.println("Expanding stack capacity\n");
T[] temp =(T[])(newObject[2*top]);
for(int i=0; i< top; i++)
temp[i]= stack[i];
stack = temp;
}
/**
* Removes the element at the top of this stack and returns a
* reference to it.
* @return element removed from top of stack
* @throws EmptyCollectionException if stack is empty
*/
public T pop()throwsEmptyCollectionException
{
if(isEmpty())
thrownewEmptyCollectionException("stack");
top--;
T result = stack[top];
stack[top]=null;
return result;
}
/**
* Returns a reference to the element at the top of this stack.
* The element is not removed from the stack.
* @return element on top of stack
* @throws EmptyCollectionException if stack is empty
*/
public T peek()throwsEmptyCollectionException
{
if(isEmpty())
thrownewEmptyCollectionException("stack");
return stack[top-1];
}
/**
* Returns the number of elements in ...
StackInterface An interface for the ADT stack. Do not modif.pdf
StackInterface
/**
An interface for the ADT stack.
Do not modify this file
*/
package PJ2;
public interface StackInterface
{
/** Gets the current number of data in this stack.
@return the integer number of entries currently in the stack*/
public int size();
/** Adds a new data to the top of this stack.
@param aData an object to be added to the stack */
public void push(T aData);
/** Removes and returns this stack\'s top data.
@return either the object at the top of the stack or,
if the stack is empty before the operation, null */
public T pop();
/** Retrieves this stack\'s top data.
@return either the data at the top of the stack or
null if the stack is empty */
public T peek();
/** Detects whether this stack is empty.
@return true if the stack is empty */
public boolean empty();
/** Removes all data from this stack */
public void clear();
} // end StackInterface
SimpleLinkedStack.java
/**
A class of stacks whose entries are stored in a chain of nodes.
Implement all methods in SimpleLinkedStack class using
the inner Node class.
Main Reference : text book or class notes
Do not change or add data fields
Do not add new methods
You may access Node object fields directly, i.e. data and next
*/
package PJ2;
public class SimpleLinkedStack implements StackInterface
{
// Data fields
private Node topNode; // references the first node in the chain
private int count; // number of data in this stack
public SimpleLinkedStack()
{
// add stataments
} // end default constructor
public void push(T newData)
{
// add stataments
} // end push
public T peek()
{
// add stataments
return null;
} // end peek
public T pop()
{
// add stataments
return null;
} // end pop
public boolean empty()
{
// add stataments
return false;
} // end empty
public int size()
{
// add stataments
return -1;
} // end isEmpty
public void clear()
{
// add stataments
} // end clear
public String toString()
{
// add stataments
// note: data class in stack must implement toString() method
// return a list of data in Stack, separate them with \',\'
return \"\";
}
/****************************************************
private inner node class
Do not modify this class!!
you may access data and next directly
***************************************************/
private class Node
{
private T data; // entry in list
private Node next; // link to next node
private Node (T dataPortion)
{
data = dataPortion;
next = null; // set next to NULL
} // end constructor
private Node (T dataPortion, Node nextNode)
{
data = dataPortion;
next = nextNode; // set next to refer to nextNode
} // end constructor
} // end Node
/****************************************************
Do not modify: Stack test
****************************************************/
public static void main (String args[])
{
System.out.println(\"\ \"+
\"*******************************************************\ \"+
\"Sample Expected output:\ \"+
\"\ \"+
\"OK: stack is empty\ \"+
\"Push 3 data: 10, 30, 50\ \"+
\"Print stack [50,30,10,]\ \"+
\"OK: sta.
java write a program to evaluate the postfix expressionthe program.pdf
java write a program to evaluate the postfix expression
the program should ask users for input and show the postfix epression and then the result.
and to have a try and catch exception since we have an empty stack
Solution
Postfix.java
import java.util.Scanner;
public class Postfix
{
/**
* Reads and evaluates multiple postfix expressions.
*/
public static void main (String[] args)
{
String expression, again;
int result;
try
{
Scanner in = new Scanner(System.in);
do
{
PostfixEvaluator evaluator = new PostfixEvaluator();
System.out.println (\"Enter a valid postfix expression: \");
expression = in.nextLine();
result = evaluator.evaluate (expression);
System.out.println();
System.out.println (\"That expression equals \" + result);
System.out.print (\"Evaluate another expression [Y/N]? \");
again = in.nextLine();
System.out.println();
}
while (again.equalsIgnoreCase(\"y\"));
}
catch (Exception IOException)
{
System.out.println(\"Input exception reported\");
}
}
}
PostfixEvaluator.java
//import datastructures.ArrayStack;
import java.util.StringTokenizer;
public class PostfixEvaluator
{
/** constant for addition symbol */
private final char ADD = \'+\';
/** constant for subtraction symbol */
private final char SUBTRACT = \'-\';
/** constant for multiplication symbol */
private final char MULTIPLY = \'*\';
/** constant for division symbol */
private final char DIVIDE = \'/\';
/** the stack */
private ArrayStack stack;
/**
* Sets up this evaluator by creating a new stack.
*/
public PostfixEvaluator()
{
stack = new ArrayStack();
}
/**
* Evaluates the specified postfix expression. If an operand is
* encountered, it is pushed onto the stack. If an operator is
* encountered, two operands are popped, the operation is
* evaluated, and the result is pushed onto the stack.
* //param expr String representation of a postfix expression
* //return int value of the given expression
*/
public int evaluate (String expr)
{
int op1, op2, result = 0;
String token;
StringTokenizer tokenizer = new StringTokenizer (expr);
while (tokenizer.hasMoreTokens())
{
token = tokenizer.nextToken();
if (isOperator(token))
{
op2 = (stack.pop()).intValue();
op1 = (stack.pop()).intValue();
result = evalSingleOp (token.charAt(0), op1, op2);
stack.push (new Integer(result));
}
else
stack.push (new Integer(Integer.parseInt(token)));
}
return result;
}
/**
* Determines if the specified token is an operator.
* //param token String representing a single token
* //return boolean true if token is operator
*/
private boolean isOperator (String token)
{
return ( token.equals(\"+\") || token.equals(\"-\") ||
token.equals(\"*\") || token.equals(\"/\") );
}
/**
* Performs integer evaluation on a single expression consisting of
* the specified operator and operands.
* //param operation operation to be performed
* //param op1 the first operand
* //param op2 the second operand
* //return int value of the expression
*/
private int evalSingleOp (char operation, int op1, int op2)
{
int result = 0;
switch .
import java.util.Scanner;public class Factorial { method usi.pdf
import java.util.Scanner;
public class Factorial
{
// method using recursion to find factorial of number
public static int factorial(int input)
{
// factorial of 0 is 1
if (input == 0)
{
return 1;
}
// else recursively call the function
else
{
return input * factorial(input - 1);
}
}
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
int input;
System.out.println(\"Enter a number: \");
input = scan.nextInt();
// store result in answer
int answer = factorial(input);
System.out.println(\"The factorial of \" + input + \" is \" + answer);
}
}
Solution
import java.util.Scanner;
public class Factorial
{
// method using recursion to find factorial of number
public static int factorial(int input)
{
// factorial of 0 is 1
if (input == 0)
{
return 1;
}
// else recursively call the function
else
{
return input * factorial(input - 1);
}
}
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
int input;
System.out.println(\"Enter a number: \");
input = scan.nextInt();
// store result in answer
int answer = factorial(input);
System.out.println(\"The factorial of \" + input + \" is \" + answer);
}
}.
1 The goal is to implement DataStructuresArrayStack accor.pdf
(1) The goal is to implement DataStructures.ArrayStack according to the interface ADTs.StackADT
********************************************
package DataStructures;
import ADTs.StackADT;
import Exceptions.EmptyCollectionException;
import Exceptions.StackOverflowException;
public class ArrayStack<T> implements StackADT<T> {
/** The index of where the top of the stack is */
int top;
/** The array that holds the stack */
T[] buffer;
public ArrayStack() {
}
public ArrayStack(int initialCapacity) {
}
}
*******************************************************
package ADTs;
import Exceptions.EmptyCollectionException;
import Exceptions.StackOverflowException;
/**
* An interface for a Stack
* Specific stack implementations will implement this interface
* For use Data Structures & Algorithms
*
*
* author unknown
*/
public interface StackADT<T> extends CollectionADT<T> {
/**
* Adds the specified element to the top of the stack
*
* @param element element to be pushed onto the stack
*/
public void push(T element) throws StackOverflowException;
/**
* Removes and returns the element that is on top of the stack
*
* @return the element removed from the stack
* @throws EmptyCollectionException
*/
public T pop() throws EmptyCollectionException;
/**
* Returns (without removing) the element that is on top of the stack
*
* @return the element on top of the stack
* @throws EmptyCollectionException
*/
public T peek() throws EmptyCollectionException;
}
*****************************************
package ADTs;
import Exceptions.*;
/**
* An interface for an ordered (NOT SORTED) List
* Elements stay in the order they are put in to the list
* For use in Data Structures & Algorithms
*
*
* @author unknown
*/
public interface ListADT<T> extends CollectionADT<T> {
/**
* Adds the specified element to the list at the front
*
* @param element: the element to be added
*
*/
public void addFirst(T element);
/**
* Adds the specified element to the end of the list
*
* @param element: the element to be added
*/
public void addLast(T element);
/**
* Adds the specified element to the list after the existing element
*
* @param existing: the element that is in the list already
* @param element: the element to be added
* @throws ElementNotFoundException if existing isn't in the list
*/
public void addAfter(T existing, T element) throws ElementNotFoundException,
EmptyCollectionException;
/**
* Removes and returns the specified element
*
* @return the element specified
* @throws EmptyCollectionException
* @throws ElementNotFoundException
*/
public T remove(T element) throws EmptyCollectionException, ElementNotFoundException;
/**
* Removes and returns the first element
*
* @return the first element in the list
* @throws EmptyCollectionException
*/
public T removeFirst() throws EmptyCollectionException;
/**
* Removes and returns the last element
*
* @return the last element in the list
* @throws EmptyCollectionException
*/
public T removeLast() throws EmptyCollectionException;
/**
* Returns (wit.
PrimeRange.java import java.util.Scanner;public class PrimeRan.pdf
PrimeRange.java
import java.util.Scanner;
public class PrimeRange {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
System.out.println(\"Enter low range:\");
int low = scan.nextInt();
System.out.println(\"Enter high range:\");
int high = scan.nextInt();
for(int i=low; i<=high; i++){
if(isPrime(i))
System.out.print(i+\" \");
}
}
public static boolean isPrime(int n){
for (int f = 2; f < n / 2; f++) {
if (n % f == 0) {
return false;
}
}
return true;
}
}
Output:
Enter low range:
10
Enter high range:
30
11 13 17 19 23 29
Solution
PrimeRange.java
import java.util.Scanner;
public class PrimeRange {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
System.out.println(\"Enter low range:\");
int low = scan.nextInt();
System.out.println(\"Enter high range:\");
int high = scan.nextInt();
for(int i=low; i<=high; i++){
if(isPrime(i))
System.out.print(i+\" \");
}
}
public static boolean isPrime(int n){
for (int f = 2; f < n / 2; f++) {
if (n % f == 0) {
return false;
}
}
return true;
}
}
Output:
Enter low range:
10
Enter high range:
30
11 13 17 19 23 29.
Using NetBeansImplement a queue named QueueLL using a Linked List .pdf
Using NetBeans
Implement a queue named QueueLL using a Linked List (same as we did for the stack). This
implementation must be used in all the following problems.
Implement a queue QueueST using a stack (use StackLL).
Test your implementations in the main with examples.
Solution
Answer:-
import java.util.*;
/* Class Node */
class Node
{
protected int data;
protected Node link;
/* Constructor */
public Node()
{
link = null;
data = 0;
}
/* Constructor */
public Node(int d,Node n)
{
data = d;
link = n;
}
/* Function to set link to next Node */
public void setLink(Node n)
{
link = n;
}
/* Function to set data to current Node */
public void setData(int d)
{
data = d;
}
/* Function to get link to next node */
public Node getLink()
{
return link;
}
/* Function to get data from current Node */
public int getData()
{
return data;
}
}
/* Class linkedQueue */
class linkedQueue
{
protected Node front, rear;
public int size;
/* Constructor */
public linkedQueue()
{
front = null;
rear = null;
size = 0;
}
/* Function to check if queue is empty */
public boolean isEmpty()
{
return front == null;
}
/* Function to get the size of the queue */
public int getSize()
{
return size;
}
/* Function to insert an element to the queue */
public void insert(int data)
{
Node nptr = new Node(data, null);
if (rear == null)
{
front = nptr;
rear = nptr;
}
else
{
rear.setLink(nptr);
rear = rear.getLink();
}
size++ ;
}
/* Function to remove front element from the queue */
public int remove()
{
if (isEmpty() )
throw new NoSuchElementException(\"Underflow Exception\");
Node ptr = front;
front = ptr.getLink();
if (front == null)
rear = null;
size-- ;
return ptr.getData();
}
/* Function to check the front element of the queue */
public int peek()
{
if (isEmpty() )
throw new NoSuchElementException(\"Underflow Exception\");
return front.getData();
}
/* Function to display the status of the queue */
public void display()
{
System.out.print(\"\ Queue = \");
if (size == 0)
{
System.out.print(\"Empty\ \");
return ;
}
Node ptr = front;
while (ptr != rear.getLink() )
{
System.out.print(ptr.getData()+\" \");
ptr = ptr.getLink();
}
System.out.println();
}
}
/* Class LinkedQueueImplement */
public class LinkedQueueImplement
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
/* Creating object of class linkedQueue */
linkedQueue lq = new linkedQueue();
/* Perform Queue Operations */
System.out.println(\"Linked Queue Test\ \");
char ch;
do
{
System.out.println(\"\ Queue Operations\");
System.out.println(\"1. insert\");
System.out.println(\"2. remove\");
System.out.println(\"3. peek\");
System.out.println(\"4. check empty\");
System.out.println(\"5. size\");
int choice = scan.nextInt();
switch (choice)
{
case 1 :
System.out.println(\"Enter integer element to insert\");
lq.insert( scan.nextInt() );
break;
case 2 :
try
{
System.out.println(\"Removed Element = \"+ lq.remove());
}
catch (Exception e)
{
System.out.println(\"Error : \" + e.getMessage());
}
break;
case 3 .
BasicPizza.javapublic class BasicPizza { Declaring instance .pdf
BasicPizza.java
public class BasicPizza {
//Declaring instance variables
String type;
String crust;
String ingredients;
double cost;
//Default Constructor
public BasicPizza() {
super();
}
//Parameterized constructor
public BasicPizza(String type) {
super();
this.type = type;
}
//Setters and Getters
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getCrust() {
return crust;
}
public void setCrust(String crust) {
this.crust = crust;
}
public String getIngredients() {
return ingredients;
}
public void setIngredients(String ingredients) {
this.ingredients = ingredients;
}
public double getCost() {
return cost;
}
public void setCost() {
this.cost = 5;
}
//toString() method is used to display the contents of the Object.inside it.
@Override
public String toString() {
return \"BasicPizza [type=\" + type + \", crust=\" + crust + \", ingredients=\"
+ ingredients + \", cost=\" + cost + \"]\";
}
}
________________________________________________________________
LiFiCheese.java
public class LiFiCheese extends BasicPizza{
//Declaring instance variables
private String crust;
private double cost;
private String ingredients;
//Default constructor
public LiFiCheese() {
super(\"Cheese\");
this.cost=5;
}
//Setters and getters
public void setCrust()
{
this.crust=\"thin\";
}
public String getCrust()
{
return crust;
}
public double getCost() {
return cost;
}
public void setCost(double cost) {
}
public String getIngredients() {
return ingredients;
}
public void setIngredients(String ingredients) {
this.ingredients = ingredients;
}
//toString() method is used to display the contents of the Object.inside it.
@Override
public String toString() {
System.out.println(\"You Ordered :\");
System.out.println(getType());
setCrust();
System.out.println(getCrust());
System.out.println(\"Total Cost of :\"+getCost());
return \"\";
}
}
__________________________________________________________________________
LiFiPizza.java
import java.util.Scanner;
public class LiFiPizza extends BasicPizza {
//Declaring instance variables
private String type;
private double cost;
private String crust;
private String ingredients;
//Default constructor
public LiFiPizza()
{
super();
this.type = \"Meat\";
this.cost=5;
}
//Setters and getters
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public double getCost() {
return cost;
}
public void setCost() {
this.cost = this.cost+2;
}
public String getCrust() {
return crust;
}
public void setCrust(String crust) {
if(crust.equals(\"Thin\"))
{
this.crust=\"Thin\";
}
else if(crust.equals(\"Thick\"))
{
this.crust=\"Thick\";
}
}
public String getIngredients() {
return ingredients;
}
public void setIngredients(String ingredients) {
this.ingredients = ingredients;
}
//toString() method is used to display the contents of the Object.inside it.
@Override
public String toString() {
System.out.println(\"You Ordered :\");
System.out.println(getType());
System.ou.
@author public class Person{ String sname, .pdf
/**
* @author
*
*/
public class Person
{
String sname, iname;
int fid, sid;
}
/**
* @author
*
*/
public class Student extends Person
{
String sname;
int sid;
int no_of_credits, tot_grade_pts;
/**
* @param sname
* @param sid
*/
public Student(String sname, int sid)
{
this.sname = sname;
this.sid = sid;
}
/**
* @return
*/
public String get_name()
{
return sname;
}
public int get_sid()
{
return sid;
}
public boolean two_equal(int sid)
{
if ((this.sid) == sid)
return true;
else
return false;
}
public void set_credits(int credits)
{
no_of_credits = credits;
}
public int get_credits()
{
return no_of_credits;
}
public void set_tot_gpts(int gpts)
{
tot_grade_pts = gpts;
}
public int get_tgpts()
{
return tot_grade_pts;
}
public float get_GPA()
{
return ((tot_grade_pts) / (no_of_credits));
}
}
/**
* @author
*
*/
public class Instructor extends Person
{
String iname;
int fid;
String dept;
/**
* @param iname
* @param fid
*/
public Instructor(String iname, int fid)
{
this.iname = iname;
this.fid = fid;
}
/**
* @param dept
*/
void set_dept(String dept)
{
this.dept = dept;
}
/**
* @return
*/
public String get_dept()
{
return dept;
}
}
import java.util.ArrayList;
/**
* @author
*
*/
public class Course
{
String cname, instructor_name;
int creg_code, max_students, no_of_students;
ArrayList reg_students = new ArrayList();
/**
* @param cname
* @param creg_code
* @param max_students
*/
Course(String cname, int creg_code, int max_students)
{
this.cname = cname;
this.creg_code = creg_code;
this.max_students = max_students;
}
/**
* @param instructor_name
*/
void set_instructor(String instructor_name)
{
this.instructor_name = instructor_name;
}
/**
* method to search student id
*
* @param sid
* @return
*/
public boolean search_student(int sid)
{
if (reg_students.contains(sid))
return true;
else
return false;
}
/**
* method to add student id
*
* @param sid
*/
public void add_student(int sid)
{
try {
if ((reg_students.size()) == max_students)
{
throw new MyException();
}
else
reg_students.add(sid);
}
catch (Exception e)
{
System.out.println(\"Course has maximum students\");
}
}
/**
* method to remove student id
*
* @param sid
*/
public void rem_student(int sid)
{
try {
if (reg_students.contains(sid))
reg_students.remove(new Integer(sid));
else
throw new MyException();
} catch (Exception e)
{
System.out.println(\"NO STUDENT FOUND WITH THE GIVEN id\");
}
}
}
/**
* @author
*
*/
public class MyException extends Exception
{
public MyException() {
// TODO Auto-generated constructor stub
super(\" Invalid Data\");
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Registrar
{
/**
* @param args
* @throws NumberFormatException
* @throws IOException
*/
public static void main(String args[]) throws NumberFormatException,
IOException
{
Course c1 = new Course(\"default_course\", 123, 10);
int ch, regcode, max_stu, sid;
String cname, sname;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
do {
System..
import java.util.Scanner;public class Fraction { instan.pdf
import java.util.Scanner;
public class Fraction {
/**
* instance variable
*/
private int numerator;
/**
* instance variable
*/
private int denominator;
/**
* param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
final Fraction f1 = new Fraction();
final Fraction f2 = new Fraction(10, 15);
final Fraction f3 = new Fraction();
Fraction f4 = new Fraction();
Fraction f5;
f3.setNumerator(14);
f3.setDenominator(16);
f1.print();
f2.print();
f3.print();
// f1.get();
// f1.print();
f4.assign(12, 50);
f4.print();
f5 = Fraction.multiply(f2, f4);
f5.print();
System.out.println(\"\ f2: \");
f2.print();
f2.multiply(f4);
System.out.println(\"\ f2: \");
f2.print();
}
/**
* default constructor
* initlizing numerator with 0 and denominator with 1
*/
public Fraction() {
// System.out.println(\"In default construction\");
numerator = 0;
denominator = 1;
}
/**
* param n
* param d
*/
public Fraction(final int n, final int d) {
// System.out.println(\"In Parameter construction\");
numerator = n;
denominator = d;
}
/**
* return numerator
*/
public int getNumerator() {
return numerator;
}
/**
* param numerator
*/
public void setNumerator(final int numerator) {
this.numerator = numerator;
}
/**
* return denominator
*/
public int getDenominator() {
return denominator;
}
/**
* param denominator
*/
public void setDenominator(final int denominator) {
this.denominator = denominator;
}
/**
* print fraction
*/
public void print() {
System.out.print(numerator + \"/\" + denominator + \" \");
}
/**
*
*/
public void get() {
final Scanner kb = new Scanner(System.in);
System.out.print(\"\ Enter numerator: \");
numerator = kb.nextInt();
System.out.print(\"Enter denominator: \");
denominator = kb.nextInt();
kb.close();
}
/**
* param n
* param d
*/
public void assign(final int n, final int d) {
if (d == 0) {
throw new IllegalArgumentException(\"denominator can not be 0\");
}
if (n < 0 || d < 0) {
throw new IllegalArgumentException(\"values must be positive\");
}
numerator = n;
denominator = d;
reduce();
}
/**
* it reduce numerator and denominator by GCD of numerator and denominator
*/
private void reduce() {
int min = numerator;
int gcd;
if (numerator > denominator) {
min = denominator;
}
for (gcd = min; gcd > 1; gcd--) {
if (numerator % gcd == 0 && denominator % gcd == 0) {
break;
}
}
numerator = numerator / gcd;
denominator = denominator / gcd;
}
/**
* param f1
* param f2
* return f
*/
public static Fraction multiply(Fraction f1, Fraction f2) {
Fraction f = new Fraction();
int num;
int den;
num = f1.getNumerator() * f2.getNumerator();
den = f1.getNumerator() * f2.getDenominator();
f.assign(num, den);
f.reduce();
return f;
}
/**
* param f
*/
public void multiply(Fraction f) {
this.numerator = this.numerator * f.getNumerator();
this.denominator = this.denominator * f.getDenominator();
this.reduce();
return;
}
}
Solution
import java.util.Scanner;
public class Fraction {
/**
* instance variable
*/
private int numerator;
/**
* instance variable
*/
priv.
public class Point { Insert your name here private dou.pdf
public class Point {
/* Insert your name here */
private double x;
private double y;
public static final double EPSILON = 1e-5;
public static boolean debug = false;
// TODO Implement Point.Point(double x, double y)
/**
* instantiate a point \"this.x\" refers to the instance variable of the
* object x refers to the parameter same for this.y and y
*/
public Point(double x, double y) {
// System.out.println(\"Point(x,y) not implemented yet\");
this.x = x;
this.y = y;
}
// TODO Implement Point.Point()
/**
* Point() creates the origin by appropriately calling the general Point
* constructor
*/
public Point() {
// System.out.println(\"Point() not implemented yet\");
this.x = 0;
this.y = 0;
}
// TODO Implement Point.getX
/**
* return x
*/
public double getX() {
// System.out.println(\"getX not implemented yet\");
return this.x;
}
// TODO Implement Point.getY
/**
* return y
*/
public double getY() {
// System.out.println(\"getY not implemented yet\");
return this.y;
}
// Given Point.toString
/**
* convert to String
*/
public String toString() {
return \"(\" + x + \",\" + y + \")\";
}
// TODO Implement Point.equals
/**
*
* param p other point return test for equality using epsilon, because we
* are dealing with doubles,so roundoff can occur
*/
public boolean equals(Point p) {
// System.out.println(\"equals not implemented yet\");
if (p.getX() == this.getX() && p.getY() == this.getY())
return true;
else
return false;
}
// Given equals(Object o)
/**
* We need this equals method for ArrayList, because the generic
* ArrayList is really an ArrayList of Object. In the case of equals, the
* signature is public boolean equals(Object o) and the method below
* overrides the Object equals method and the calls the class\'s
* equals(Point) method
*
* see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (obj instanceof Point) {
Point p = (Point) obj;
return equals(p);
}
return false;
}
// TODO Implement Point.euclidDist
/**
*
* param p return Euclidean distance of this point to point p
*/
public double euclidDist(Point p) {
// System.out.println(\"euclidDist not implemented yet\");
double X = this.getY() - p.getY();
double Y = this.getX() - p.getX();
double result = Math.sqrt(X * X + Y * Y);
return result;
}
/**
* param args: no args
*/
public static void main(String[] args) {
// test all methods
if (debug)
System.out.println(\"debug ON\");
else
System.out.println(\"debug OFF\");
System.out.println(\"EPSILON: \" + Point.EPSILON);
Point origin = new Point();
Point p1 = new Point(0.0, 4.0);
Point p2 = new Point(3.0000001, 3.9999999);
Point p3 = new Point(3.0, 4.0);
Point p4 = new Point(0.0, 5.0);
Point p5 = new Point(12.0, 0.0);
System.out.println(\"origin: \" + origin);
System.out.println(\"p1: \" + p1);
System.out.println(\"p2: \" + p2);
System.out.println(\"p3: \" + p3);
System.out.println(\"p4: \" + p4);
System.out.println(\"p5: \" + p5);
if (p2.equals(p3))
System.out.println(p2 + \" equals \" + p3);
else
System.out.println(p2 +.
import java.util.Random;ASSIGNMENT #2 MATRIX ARITHMETIC Cla.pdf
import java.util.Random;
//ASSIGNMENT #2: MATRIX ARITHMETIC
//Class Matrix. File: Matrix.java
public class Matrix {
public static final int MAX = 20;
//Attributes
private int size;
private int[][] table;
/**
* Default constructor
* Initializes the table with size MAX
*/
public Matrix() {
this.table = new int[MAX][MAX];
}
/**
* Parameterized constructor
* Initializes the table with size s
*/
public Matrix(int s) {
this.size = s;
this.table = new int[this.size][this.size];
}
/**
* Returns the size of the matrix
* @return
*/
public int getSize() {
return this.size;
}
/**
* The the number at position (r, c)
* @param r
* @param c
* @return
*/
public int getElement(int r, int c) {
return this.table[r][c];
}
/**
* Set a number at position (r, c)
* @param r
* @param c
* @param value
*/
public void setElement(int r, int c, int value) {
this.table[r][c] = value;
}
/**
* Initializes the matrix with random numbers
* @param low
* @param up
*/
public void init(int low, int up) {
Random rand = new Random();
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
setElement(r, c, rand.nextInt(up) + low);
}
}
}
/**
* Prints the matrix
*/
public void print() {
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
System.out.printf(\" %2s\", getElement(r, c));
}
System.out.printf(\"\ \");
}
}
/**
* Adds this matrix with Matrix a
* @param a
* @return
*/
public Matrix add(Matrix a) {
Matrix result = new Matrix(this.size);
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
int value = this.getElement(r, c) + a.getElement(r, c);
result.setElement(r, c, value);
}
}
return result;
}
/**
* Subtracts this matrix with Matrix a
* @param a
* @return
*/
public Matrix subtract(Matrix a) {
Matrix result = new Matrix(this.size);
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
int value = this.getElement(r, c) - a.getElement(r, c);
result.setElement(r, c, value);
}
}
return result;
}
/**
* Multiplies this matrix with Matrix a
* @param a
* @return
*/
public Matrix multiply(Matrix a) {
Matrix result = new Matrix(this.size);
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
int value = 0;
for (int k = 0 ; k < this.size ; k++) {
value += this.getElement(r, k) * a.getElement(k, c);
}
result.setElement(r, c, value);
}
}
return result;
}
/**
* Multiplies this matrix with a constant whatConst
* @param a
* @return
*/
public Matrix multiplyConst(int whatConst) {
Matrix result = new Matrix(this.size);
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
result.setElement(r, c, getElement(r, c) * whatConst);
}
}
return result;
}
/**
* Transposes this matrix
* @param a
* @return
*/
public Matrix transpose() {
Matrix result = new Matrix(this.size);
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
result.setElement(r, c, this.getElement(c, r));
}
}
return result;
}
/**
*
* @param a
* @return
*/
p.
import java.util.Scanner;public class HornersPolynomial { .pdf
For a first order reaction rate constant , k = ( 2.303 /t )x log ( a / (a-x))
Where
a = initial amount
a-x = amount left after time t = a / 10
t = time = ?
k = rate constant = 3.43x10 -2 d -2
Plug the values we get t = ( 2.303 /k )x log ( a / (a-x))
= ( 2.303 / 3.43x10 -2 )x log ( a / (a/10))
= 67.14 days
Solution
For a first order reaction rate constant , k = ( 2.303 /t )x log ( a / (a-x))
Where
a = initial amount
a-x = amount left after time t = a / 10
t = time = ?
k = rate constant = 3.43x10 -2 d -2
Plug the values we get t = ( 2.303 /k )x log ( a / (a-x))
= ( 2.303 / 3.43x10 -2 )x log ( a / (a/10))
= 67.14 days.
Frequency .java Word frequency counter package frequ.pdf
Frequency .java
/**
* Word frequency counter
*/
package frequency;
import java.util.Iterator;
/**
*
* @author UMD CS
*/
public class Frequency implements Iterable{
private Node first;
private int N;
Frequency(){
N = 0;
first = null;
}
@Override
public Iterator iterator() {
return new ListIterator();
}
/**
*
* List iterator
*
*/
private class ListIterator implements Iterator{
private Node current;
private int index ;
ListIterator(){
current = first;
index = 0;
}
@Override
public boolean hasNext() {
return current != null;
}
public String next() {
if(!hasNext()){
return null;
}
String word = current.key;
int count = current.count;
String r = \"(\"+word + \",\" + Integer.toString(count)+\")\";
current = current.next;
return r;
}
@Override
public void remove() {
}
}
/**
*
* Node class
*
*/
private class Node {
private String key;
private int count;
private Node next;
Node(String item){
key = item;
count = 1;
next = null;
}
@Override
public String toString(){
return \"(\"+key +\",\"+count+\")\";
}
}
/*
* Inserts a word into the linked list. If the word exists, increment the
* count by q.
*/
public void insert(String word){
if(word.equals(\"\")){
return;
}
//TODO
/*
* implement here
*/
}
/**
*
* @param str input string
* This method splits a string into words and pass the words to insert method
*
*/
public void insertWords(String str){
String delims = \"[ .,?!\'\\\"()}{;/<>&=#-:\\\\ _]+\";
String[] words = str.split(delims);
for(String s: words){
s = s.toLowerCase();
insert(s);
}
}
/**
* prints the word frequency list
*/
public void print(){
Node c = first;
while(c != null){
System.out.print(\"(\"+c.key + \",\" + c.count+\")\");
c = c.next;
}
System.out.print(\"\ \");
}
}
--------------------------------------------------------------------------------------------------------------------
------------------------------------------------------
WordFrequency.java
package frequency;
import utils.In;
import utils.Stopwatch;
/**
*
* @author UMD CS
*/
public class WordFrequency {
/**
* @param input source
* @param
* This method receives input resource and return the word frequency string
* DO NOT CHANGE THIS METHOD.
*/
public static String freq(String inputSource, int maxLines){
In in;
// Frequency class can only count the frequency of strings. DO NOT CHANGE THIS.
Frequency freq = new Frequency();
int MAX = 100;
String inputSourceName = inputSource;
try {
in = new In(inputSourceName);
while (!in.isEmpty()) {
String s = in.readLine();
//System.out.println(s);
freq.insertWords(s);
}
}
catch (Exception e) {
e.printStackTrace();
}
StringBuilder strFrequency = new StringBuilder();
int cnt = 0;
for(String s: freq){
strFrequency.append(s);
strFrequency.append(\",\");
cnt++;
if(cnt >= maxLines){break;}
}
return strFrequency.toString();
}
/**
*
*/
public static void main(String[] args) {
In in;
Frequency freq = new Frequency();
int MAX = 100;
// String inputSourceName =
\"http://www.cs.umd.edu/class/summer2015/cmsc132/projects/P3_WordFrequency/test1.html\";
String .
Tested on EclipseBoth class should be in same package.pdf
Tested on Eclipse
Both class should be in same package
/***********UNMember class***********/
import java.util.Scanner;
public class UNMember {
/*data member declaration*/
private String name;
private int NUID;
private String netID;
private String collegeLocation;
Scanner input=new Scanner(System.in);
/*Default constructor*/
public UNMember() {
}
/*Parameterized constructor*/
public UNMember(String name, int nUID, String netID) {
setName(name);
setNUID(nUID);
setNetID(netID);
setCollegeLocation();
}
/*Getter and setter method of data member variable*/
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNUID() {
return NUID;
}
public void setNUID(int nUID) {
NUID = nUID;
}
public String getNetID() {
return netID;
}
public void setNetID(String netID) {
this.netID = netID;
}
public String getCollegeLocation() {
return collegeLocation;
}
public void setCollegeLocation() {
String collegeLocation;
/*Prompt for college location*/
System.out.println(\"Please Enter the college Location\");
collegeLocation=input.nextLine();
this.collegeLocation = collegeLocation;
}
@Override
public String toString() {
return \"Name:\" + name.toUpperCase() + \"\ NUID=\" + NUID + \"\ NetID:\" +
netID.toUpperCase() + \"\ Campus Location:\" + collegeLocation.toUpperCase()
+ \"\ \";
}
}
/************UNStaff class*************/
import java.text.DecimalFormat;
public class UNStaff extends UNMember{
/*Member data variable declaration*/
private String position;
private double wage;
/*Parameterized constructor*/
public UNStaff(String position, double wage,String name,int NUID,String netID) {
super(name,NUID,netID);
setPosition(position);
setWage(wage);
}
/*Getter and Setter method of data member variable*/
public String getPosition() {
return position;
}
public void setPosition(String position) {
if(position.equals(\"\")|| position==null){
this.position=\"NOT SET\";
}else{
this.position = position;
}
}
public double getWage() {
return wage;
}
/*Set wage , if wage less then 9 then we are setting it to -1*/
public void setWage(double wage) {
if(wage<9){
this.wage=-1;
}else{
this.wage = wage;
}
}
/*ToString method*/
@Override
public String toString() {
String result=\"Position:\" + position.toUpperCase() + \"\ \";
if(this.wage==-1){
result+=\"Wage:NOT SET\";
}else{
result+=\"Wage:$\"+new DecimalFormat(\"##.00\").format(this.wage);
}
return super.toString()+result;
}
public static void main(String args[]){
UNStaff staff=new UNStaff(\"secretary\", 50.6, \"David\", 123, \"UN123\");
UNStaff staff1=new UNStaff(\"cleark\", 8, \"Sam\", 129, \"UN129\");
System.out.println(\"**************\");
System.out.println(staff.toString());
System.out.println(\"**************\");
System.out.println(staff1.toString());
}
}
/***************output*************/
Please Enter the college Location
california
Please Enter the college Location
Los Angeles
**************
Name:DAVID
NUID=123
NetID:UN123
Campus Location:CALIFORNIA
Position:SECRETARY
Wage.
using the equation P1V1T1 = P2V2T2 we have .pdf
using the equation P1*V1/T1 = P2*V2/T2 we have
V2=99.6*2.16*285/(305*122.8)= 1.64 l
Solution
using the equation P1*V1/T1 = P2*V2/T2 we have
V2=99.6*2.16*285/(305*122.8)= 1.64 l.
More Related Content
Similar to PickerApp CLass.pdf
1 The goal is to implement DataStructuresArrayStack accor.pdf
(1) The goal is to implement DataStructures.ArrayStack according to the interface ADTs.StackADT
********************************************
package DataStructures;
import ADTs.StackADT;
import Exceptions.EmptyCollectionException;
import Exceptions.StackOverflowException;
public class ArrayStack<T> implements StackADT<T> {
/** The index of where the top of the stack is */
int top;
/** The array that holds the stack */
T[] buffer;
public ArrayStack() {
}
public ArrayStack(int initialCapacity) {
}
}
*******************************************************
package ADTs;
import Exceptions.EmptyCollectionException;
import Exceptions.StackOverflowException;
/**
* An interface for a Stack
* Specific stack implementations will implement this interface
* For use Data Structures & Algorithms
*
*
* author unknown
*/
public interface StackADT<T> extends CollectionADT<T> {
/**
* Adds the specified element to the top of the stack
*
* @param element element to be pushed onto the stack
*/
public void push(T element) throws StackOverflowException;
/**
* Removes and returns the element that is on top of the stack
*
* @return the element removed from the stack
* @throws EmptyCollectionException
*/
public T pop() throws EmptyCollectionException;
/**
* Returns (without removing) the element that is on top of the stack
*
* @return the element on top of the stack
* @throws EmptyCollectionException
*/
public T peek() throws EmptyCollectionException;
}
*****************************************
package ADTs;
import Exceptions.*;
/**
* An interface for an ordered (NOT SORTED) List
* Elements stay in the order they are put in to the list
* For use in Data Structures & Algorithms
*
*
* @author unknown
*/
public interface ListADT<T> extends CollectionADT<T> {
/**
* Adds the specified element to the list at the front
*
* @param element: the element to be added
*
*/
public void addFirst(T element);
/**
* Adds the specified element to the end of the list
*
* @param element: the element to be added
*/
public void addLast(T element);
/**
* Adds the specified element to the list after the existing element
*
* @param existing: the element that is in the list already
* @param element: the element to be added
* @throws ElementNotFoundException if existing isn't in the list
*/
public void addAfter(T existing, T element) throws ElementNotFoundException,
EmptyCollectionException;
/**
* Removes and returns the specified element
*
* @return the element specified
* @throws EmptyCollectionException
* @throws ElementNotFoundException
*/
public T remove(T element) throws EmptyCollectionException, ElementNotFoundException;
/**
* Removes and returns the first element
*
* @return the first element in the list
* @throws EmptyCollectionException
*/
public T removeFirst() throws EmptyCollectionException;
/**
* Removes and returns the last element
*
* @return the last element in the list
* @throws EmptyCollectionException
*/
public T removeLast() throws EmptyCollectionException;
/**
* Returns (wit.
PrimeRange.java import java.util.Scanner;public class PrimeRan.pdf
PrimeRange.java
import java.util.Scanner;
public class PrimeRange {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
System.out.println(\"Enter low range:\");
int low = scan.nextInt();
System.out.println(\"Enter high range:\");
int high = scan.nextInt();
for(int i=low; i<=high; i++){
if(isPrime(i))
System.out.print(i+\" \");
}
}
public static boolean isPrime(int n){
for (int f = 2; f < n / 2; f++) {
if (n % f == 0) {
return false;
}
}
return true;
}
}
Output:
Enter low range:
10
Enter high range:
30
11 13 17 19 23 29
Solution
PrimeRange.java
import java.util.Scanner;
public class PrimeRange {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
System.out.println(\"Enter low range:\");
int low = scan.nextInt();
System.out.println(\"Enter high range:\");
int high = scan.nextInt();
for(int i=low; i<=high; i++){
if(isPrime(i))
System.out.print(i+\" \");
}
}
public static boolean isPrime(int n){
for (int f = 2; f < n / 2; f++) {
if (n % f == 0) {
return false;
}
}
return true;
}
}
Output:
Enter low range:
10
Enter high range:
30
11 13 17 19 23 29.
Using NetBeansImplement a queue named QueueLL using a Linked List .pdf
Using NetBeans
Implement a queue named QueueLL using a Linked List (same as we did for the stack). This
implementation must be used in all the following problems.
Implement a queue QueueST using a stack (use StackLL).
Test your implementations in the main with examples.
Solution
Answer:-
import java.util.*;
/* Class Node */
class Node
{
protected int data;
protected Node link;
/* Constructor */
public Node()
{
link = null;
data = 0;
}
/* Constructor */
public Node(int d,Node n)
{
data = d;
link = n;
}
/* Function to set link to next Node */
public void setLink(Node n)
{
link = n;
}
/* Function to set data to current Node */
public void setData(int d)
{
data = d;
}
/* Function to get link to next node */
public Node getLink()
{
return link;
}
/* Function to get data from current Node */
public int getData()
{
return data;
}
}
/* Class linkedQueue */
class linkedQueue
{
protected Node front, rear;
public int size;
/* Constructor */
public linkedQueue()
{
front = null;
rear = null;
size = 0;
}
/* Function to check if queue is empty */
public boolean isEmpty()
{
return front == null;
}
/* Function to get the size of the queue */
public int getSize()
{
return size;
}
/* Function to insert an element to the queue */
public void insert(int data)
{
Node nptr = new Node(data, null);
if (rear == null)
{
front = nptr;
rear = nptr;
}
else
{
rear.setLink(nptr);
rear = rear.getLink();
}
size++ ;
}
/* Function to remove front element from the queue */
public int remove()
{
if (isEmpty() )
throw new NoSuchElementException(\"Underflow Exception\");
Node ptr = front;
front = ptr.getLink();
if (front == null)
rear = null;
size-- ;
return ptr.getData();
}
/* Function to check the front element of the queue */
public int peek()
{
if (isEmpty() )
throw new NoSuchElementException(\"Underflow Exception\");
return front.getData();
}
/* Function to display the status of the queue */
public void display()
{
System.out.print(\"\ Queue = \");
if (size == 0)
{
System.out.print(\"Empty\ \");
return ;
}
Node ptr = front;
while (ptr != rear.getLink() )
{
System.out.print(ptr.getData()+\" \");
ptr = ptr.getLink();
}
System.out.println();
}
}
/* Class LinkedQueueImplement */
public class LinkedQueueImplement
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
/* Creating object of class linkedQueue */
linkedQueue lq = new linkedQueue();
/* Perform Queue Operations */
System.out.println(\"Linked Queue Test\ \");
char ch;
do
{
System.out.println(\"\ Queue Operations\");
System.out.println(\"1. insert\");
System.out.println(\"2. remove\");
System.out.println(\"3. peek\");
System.out.println(\"4. check empty\");
System.out.println(\"5. size\");
int choice = scan.nextInt();
switch (choice)
{
case 1 :
System.out.println(\"Enter integer element to insert\");
lq.insert( scan.nextInt() );
break;
case 2 :
try
{
System.out.println(\"Removed Element = \"+ lq.remove());
}
catch (Exception e)
{
System.out.println(\"Error : \" + e.getMessage());
}
break;
case 3 .
BasicPizza.javapublic class BasicPizza { Declaring instance .pdf
BasicPizza.java
public class BasicPizza {
//Declaring instance variables
String type;
String crust;
String ingredients;
double cost;
//Default Constructor
public BasicPizza() {
super();
}
//Parameterized constructor
public BasicPizza(String type) {
super();
this.type = type;
}
//Setters and Getters
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getCrust() {
return crust;
}
public void setCrust(String crust) {
this.crust = crust;
}
public String getIngredients() {
return ingredients;
}
public void setIngredients(String ingredients) {
this.ingredients = ingredients;
}
public double getCost() {
return cost;
}
public void setCost() {
this.cost = 5;
}
//toString() method is used to display the contents of the Object.inside it.
@Override
public String toString() {
return \"BasicPizza [type=\" + type + \", crust=\" + crust + \", ingredients=\"
+ ingredients + \", cost=\" + cost + \"]\";
}
}
________________________________________________________________
LiFiCheese.java
public class LiFiCheese extends BasicPizza{
//Declaring instance variables
private String crust;
private double cost;
private String ingredients;
//Default constructor
public LiFiCheese() {
super(\"Cheese\");
this.cost=5;
}
//Setters and getters
public void setCrust()
{
this.crust=\"thin\";
}
public String getCrust()
{
return crust;
}
public double getCost() {
return cost;
}
public void setCost(double cost) {
}
public String getIngredients() {
return ingredients;
}
public void setIngredients(String ingredients) {
this.ingredients = ingredients;
}
//toString() method is used to display the contents of the Object.inside it.
@Override
public String toString() {
System.out.println(\"You Ordered :\");
System.out.println(getType());
setCrust();
System.out.println(getCrust());
System.out.println(\"Total Cost of :\"+getCost());
return \"\";
}
}
__________________________________________________________________________
LiFiPizza.java
import java.util.Scanner;
public class LiFiPizza extends BasicPizza {
//Declaring instance variables
private String type;
private double cost;
private String crust;
private String ingredients;
//Default constructor
public LiFiPizza()
{
super();
this.type = \"Meat\";
this.cost=5;
}
//Setters and getters
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public double getCost() {
return cost;
}
public void setCost() {
this.cost = this.cost+2;
}
public String getCrust() {
return crust;
}
public void setCrust(String crust) {
if(crust.equals(\"Thin\"))
{
this.crust=\"Thin\";
}
else if(crust.equals(\"Thick\"))
{
this.crust=\"Thick\";
}
}
public String getIngredients() {
return ingredients;
}
public void setIngredients(String ingredients) {
this.ingredients = ingredients;
}
//toString() method is used to display the contents of the Object.inside it.
@Override
public String toString() {
System.out.println(\"You Ordered :\");
System.out.println(getType());
System.ou.
@author public class Person{ String sname, .pdf
/**
* @author
*
*/
public class Person
{
String sname, iname;
int fid, sid;
}
/**
* @author
*
*/
public class Student extends Person
{
String sname;
int sid;
int no_of_credits, tot_grade_pts;
/**
* @param sname
* @param sid
*/
public Student(String sname, int sid)
{
this.sname = sname;
this.sid = sid;
}
/**
* @return
*/
public String get_name()
{
return sname;
}
public int get_sid()
{
return sid;
}
public boolean two_equal(int sid)
{
if ((this.sid) == sid)
return true;
else
return false;
}
public void set_credits(int credits)
{
no_of_credits = credits;
}
public int get_credits()
{
return no_of_credits;
}
public void set_tot_gpts(int gpts)
{
tot_grade_pts = gpts;
}
public int get_tgpts()
{
return tot_grade_pts;
}
public float get_GPA()
{
return ((tot_grade_pts) / (no_of_credits));
}
}
/**
* @author
*
*/
public class Instructor extends Person
{
String iname;
int fid;
String dept;
/**
* @param iname
* @param fid
*/
public Instructor(String iname, int fid)
{
this.iname = iname;
this.fid = fid;
}
/**
* @param dept
*/
void set_dept(String dept)
{
this.dept = dept;
}
/**
* @return
*/
public String get_dept()
{
return dept;
}
}
import java.util.ArrayList;
/**
* @author
*
*/
public class Course
{
String cname, instructor_name;
int creg_code, max_students, no_of_students;
ArrayList reg_students = new ArrayList();
/**
* @param cname
* @param creg_code
* @param max_students
*/
Course(String cname, int creg_code, int max_students)
{
this.cname = cname;
this.creg_code = creg_code;
this.max_students = max_students;
}
/**
* @param instructor_name
*/
void set_instructor(String instructor_name)
{
this.instructor_name = instructor_name;
}
/**
* method to search student id
*
* @param sid
* @return
*/
public boolean search_student(int sid)
{
if (reg_students.contains(sid))
return true;
else
return false;
}
/**
* method to add student id
*
* @param sid
*/
public void add_student(int sid)
{
try {
if ((reg_students.size()) == max_students)
{
throw new MyException();
}
else
reg_students.add(sid);
}
catch (Exception e)
{
System.out.println(\"Course has maximum students\");
}
}
/**
* method to remove student id
*
* @param sid
*/
public void rem_student(int sid)
{
try {
if (reg_students.contains(sid))
reg_students.remove(new Integer(sid));
else
throw new MyException();
} catch (Exception e)
{
System.out.println(\"NO STUDENT FOUND WITH THE GIVEN id\");
}
}
}
/**
* @author
*
*/
public class MyException extends Exception
{
public MyException() {
// TODO Auto-generated constructor stub
super(\" Invalid Data\");
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Registrar
{
/**
* @param args
* @throws NumberFormatException
* @throws IOException
*/
public static void main(String args[]) throws NumberFormatException,
IOException
{
Course c1 = new Course(\"default_course\", 123, 10);
int ch, regcode, max_stu, sid;
String cname, sname;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
do {
System..
import java.util.Scanner;public class Fraction { instan.pdf
import java.util.Scanner;
public class Fraction {
/**
* instance variable
*/
private int numerator;
/**
* instance variable
*/
private int denominator;
/**
* param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
final Fraction f1 = new Fraction();
final Fraction f2 = new Fraction(10, 15);
final Fraction f3 = new Fraction();
Fraction f4 = new Fraction();
Fraction f5;
f3.setNumerator(14);
f3.setDenominator(16);
f1.print();
f2.print();
f3.print();
// f1.get();
// f1.print();
f4.assign(12, 50);
f4.print();
f5 = Fraction.multiply(f2, f4);
f5.print();
System.out.println(\"\ f2: \");
f2.print();
f2.multiply(f4);
System.out.println(\"\ f2: \");
f2.print();
}
/**
* default constructor
* initlizing numerator with 0 and denominator with 1
*/
public Fraction() {
// System.out.println(\"In default construction\");
numerator = 0;
denominator = 1;
}
/**
* param n
* param d
*/
public Fraction(final int n, final int d) {
// System.out.println(\"In Parameter construction\");
numerator = n;
denominator = d;
}
/**
* return numerator
*/
public int getNumerator() {
return numerator;
}
/**
* param numerator
*/
public void setNumerator(final int numerator) {
this.numerator = numerator;
}
/**
* return denominator
*/
public int getDenominator() {
return denominator;
}
/**
* param denominator
*/
public void setDenominator(final int denominator) {
this.denominator = denominator;
}
/**
* print fraction
*/
public void print() {
System.out.print(numerator + \"/\" + denominator + \" \");
}
/**
*
*/
public void get() {
final Scanner kb = new Scanner(System.in);
System.out.print(\"\ Enter numerator: \");
numerator = kb.nextInt();
System.out.print(\"Enter denominator: \");
denominator = kb.nextInt();
kb.close();
}
/**
* param n
* param d
*/
public void assign(final int n, final int d) {
if (d == 0) {
throw new IllegalArgumentException(\"denominator can not be 0\");
}
if (n < 0 || d < 0) {
throw new IllegalArgumentException(\"values must be positive\");
}
numerator = n;
denominator = d;
reduce();
}
/**
* it reduce numerator and denominator by GCD of numerator and denominator
*/
private void reduce() {
int min = numerator;
int gcd;
if (numerator > denominator) {
min = denominator;
}
for (gcd = min; gcd > 1; gcd--) {
if (numerator % gcd == 0 && denominator % gcd == 0) {
break;
}
}
numerator = numerator / gcd;
denominator = denominator / gcd;
}
/**
* param f1
* param f2
* return f
*/
public static Fraction multiply(Fraction f1, Fraction f2) {
Fraction f = new Fraction();
int num;
int den;
num = f1.getNumerator() * f2.getNumerator();
den = f1.getNumerator() * f2.getDenominator();
f.assign(num, den);
f.reduce();
return f;
}
/**
* param f
*/
public void multiply(Fraction f) {
this.numerator = this.numerator * f.getNumerator();
this.denominator = this.denominator * f.getDenominator();
this.reduce();
return;
}
}
Solution
import java.util.Scanner;
public class Fraction {
/**
* instance variable
*/
private int numerator;
/**
* instance variable
*/
priv.
public class Point { Insert your name here private dou.pdf
public class Point {
/* Insert your name here */
private double x;
private double y;
public static final double EPSILON = 1e-5;
public static boolean debug = false;
// TODO Implement Point.Point(double x, double y)
/**
* instantiate a point \"this.x\" refers to the instance variable of the
* object x refers to the parameter same for this.y and y
*/
public Point(double x, double y) {
// System.out.println(\"Point(x,y) not implemented yet\");
this.x = x;
this.y = y;
}
// TODO Implement Point.Point()
/**
* Point() creates the origin by appropriately calling the general Point
* constructor
*/
public Point() {
// System.out.println(\"Point() not implemented yet\");
this.x = 0;
this.y = 0;
}
// TODO Implement Point.getX
/**
* return x
*/
public double getX() {
// System.out.println(\"getX not implemented yet\");
return this.x;
}
// TODO Implement Point.getY
/**
* return y
*/
public double getY() {
// System.out.println(\"getY not implemented yet\");
return this.y;
}
// Given Point.toString
/**
* convert to String
*/
public String toString() {
return \"(\" + x + \",\" + y + \")\";
}
// TODO Implement Point.equals
/**
*
* param p other point return test for equality using epsilon, because we
* are dealing with doubles,so roundoff can occur
*/
public boolean equals(Point p) {
// System.out.println(\"equals not implemented yet\");
if (p.getX() == this.getX() && p.getY() == this.getY())
return true;
else
return false;
}
// Given equals(Object o)
/**
* We need this equals method for ArrayList, because the generic
* ArrayList is really an ArrayList of Object. In the case of equals, the
* signature is public boolean equals(Object o) and the method below
* overrides the Object equals method and the calls the class\'s
* equals(Point) method
*
* see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (obj instanceof Point) {
Point p = (Point) obj;
return equals(p);
}
return false;
}
// TODO Implement Point.euclidDist
/**
*
* param p return Euclidean distance of this point to point p
*/
public double euclidDist(Point p) {
// System.out.println(\"euclidDist not implemented yet\");
double X = this.getY() - p.getY();
double Y = this.getX() - p.getX();
double result = Math.sqrt(X * X + Y * Y);
return result;
}
/**
* param args: no args
*/
public static void main(String[] args) {
// test all methods
if (debug)
System.out.println(\"debug ON\");
else
System.out.println(\"debug OFF\");
System.out.println(\"EPSILON: \" + Point.EPSILON);
Point origin = new Point();
Point p1 = new Point(0.0, 4.0);
Point p2 = new Point(3.0000001, 3.9999999);
Point p3 = new Point(3.0, 4.0);
Point p4 = new Point(0.0, 5.0);
Point p5 = new Point(12.0, 0.0);
System.out.println(\"origin: \" + origin);
System.out.println(\"p1: \" + p1);
System.out.println(\"p2: \" + p2);
System.out.println(\"p3: \" + p3);
System.out.println(\"p4: \" + p4);
System.out.println(\"p5: \" + p5);
if (p2.equals(p3))
System.out.println(p2 + \" equals \" + p3);
else
System.out.println(p2 +.
import java.util.Random;ASSIGNMENT #2 MATRIX ARITHMETIC Cla.pdf
import java.util.Random;
//ASSIGNMENT #2: MATRIX ARITHMETIC
//Class Matrix. File: Matrix.java
public class Matrix {
public static final int MAX = 20;
//Attributes
private int size;
private int[][] table;
/**
* Default constructor
* Initializes the table with size MAX
*/
public Matrix() {
this.table = new int[MAX][MAX];
}
/**
* Parameterized constructor
* Initializes the table with size s
*/
public Matrix(int s) {
this.size = s;
this.table = new int[this.size][this.size];
}
/**
* Returns the size of the matrix
* @return
*/
public int getSize() {
return this.size;
}
/**
* The the number at position (r, c)
* @param r
* @param c
* @return
*/
public int getElement(int r, int c) {
return this.table[r][c];
}
/**
* Set a number at position (r, c)
* @param r
* @param c
* @param value
*/
public void setElement(int r, int c, int value) {
this.table[r][c] = value;
}
/**
* Initializes the matrix with random numbers
* @param low
* @param up
*/
public void init(int low, int up) {
Random rand = new Random();
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
setElement(r, c, rand.nextInt(up) + low);
}
}
}
/**
* Prints the matrix
*/
public void print() {
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
System.out.printf(\" %2s\", getElement(r, c));
}
System.out.printf(\"\ \");
}
}
/**
* Adds this matrix with Matrix a
* @param a
* @return
*/
public Matrix add(Matrix a) {
Matrix result = new Matrix(this.size);
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
int value = this.getElement(r, c) + a.getElement(r, c);
result.setElement(r, c, value);
}
}
return result;
}
/**
* Subtracts this matrix with Matrix a
* @param a
* @return
*/
public Matrix subtract(Matrix a) {
Matrix result = new Matrix(this.size);
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
int value = this.getElement(r, c) - a.getElement(r, c);
result.setElement(r, c, value);
}
}
return result;
}
/**
* Multiplies this matrix with Matrix a
* @param a
* @return
*/
public Matrix multiply(Matrix a) {
Matrix result = new Matrix(this.size);
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
int value = 0;
for (int k = 0 ; k < this.size ; k++) {
value += this.getElement(r, k) * a.getElement(k, c);
}
result.setElement(r, c, value);
}
}
return result;
}
/**
* Multiplies this matrix with a constant whatConst
* @param a
* @return
*/
public Matrix multiplyConst(int whatConst) {
Matrix result = new Matrix(this.size);
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
result.setElement(r, c, getElement(r, c) * whatConst);
}
}
return result;
}
/**
* Transposes this matrix
* @param a
* @return
*/
public Matrix transpose() {
Matrix result = new Matrix(this.size);
for (int r = 0 ; r < this.size ; r++) {
for (int c = 0 ; c < this.size ; c++) {
result.setElement(r, c, this.getElement(c, r));
}
}
return result;
}
/**
*
* @param a
* @return
*/
p.
import java.util.Scanner;public class HornersPolynomial { .pdf
For a first order reaction rate constant , k = ( 2.303 /t )x log ( a / (a-x))
Where
a = initial amount
a-x = amount left after time t = a / 10
t = time = ?
k = rate constant = 3.43x10 -2 d -2
Plug the values we get t = ( 2.303 /k )x log ( a / (a-x))
= ( 2.303 / 3.43x10 -2 )x log ( a / (a/10))
= 67.14 days
Solution
For a first order reaction rate constant , k = ( 2.303 /t )x log ( a / (a-x))
Where
a = initial amount
a-x = amount left after time t = a / 10
t = time = ?
k = rate constant = 3.43x10 -2 d -2
Plug the values we get t = ( 2.303 /k )x log ( a / (a-x))
= ( 2.303 / 3.43x10 -2 )x log ( a / (a/10))
= 67.14 days.
Frequency .java Word frequency counter package frequ.pdf
Frequency .java
/**
* Word frequency counter
*/
package frequency;
import java.util.Iterator;
/**
*
* @author UMD CS
*/
public class Frequency implements Iterable{
private Node first;
private int N;
Frequency(){
N = 0;
first = null;
}
@Override
public Iterator iterator() {
return new ListIterator();
}
/**
*
* List iterator
*
*/
private class ListIterator implements Iterator{
private Node current;
private int index ;
ListIterator(){
current = first;
index = 0;
}
@Override
public boolean hasNext() {
return current != null;
}
public String next() {
if(!hasNext()){
return null;
}
String word = current.key;
int count = current.count;
String r = \"(\"+word + \",\" + Integer.toString(count)+\")\";
current = current.next;
return r;
}
@Override
public void remove() {
}
}
/**
*
* Node class
*
*/
private class Node {
private String key;
private int count;
private Node next;
Node(String item){
key = item;
count = 1;
next = null;
}
@Override
public String toString(){
return \"(\"+key +\",\"+count+\")\";
}
}
/*
* Inserts a word into the linked list. If the word exists, increment the
* count by q.
*/
public void insert(String word){
if(word.equals(\"\")){
return;
}
//TODO
/*
* implement here
*/
}
/**
*
* @param str input string
* This method splits a string into words and pass the words to insert method
*
*/
public void insertWords(String str){
String delims = \"[ .,?!\'\\\"()}{;/<>&=#-:\\\\ _]+\";
String[] words = str.split(delims);
for(String s: words){
s = s.toLowerCase();
insert(s);
}
}
/**
* prints the word frequency list
*/
public void print(){
Node c = first;
while(c != null){
System.out.print(\"(\"+c.key + \",\" + c.count+\")\");
c = c.next;
}
System.out.print(\"\ \");
}
}
--------------------------------------------------------------------------------------------------------------------
------------------------------------------------------
WordFrequency.java
package frequency;
import utils.In;
import utils.Stopwatch;
/**
*
* @author UMD CS
*/
public class WordFrequency {
/**
* @param input source
* @param
* This method receives input resource and return the word frequency string
* DO NOT CHANGE THIS METHOD.
*/
public static String freq(String inputSource, int maxLines){
In in;
// Frequency class can only count the frequency of strings. DO NOT CHANGE THIS.
Frequency freq = new Frequency();
int MAX = 100;
String inputSourceName = inputSource;
try {
in = new In(inputSourceName);
while (!in.isEmpty()) {
String s = in.readLine();
//System.out.println(s);
freq.insertWords(s);
}
}
catch (Exception e) {
e.printStackTrace();
}
StringBuilder strFrequency = new StringBuilder();
int cnt = 0;
for(String s: freq){
strFrequency.append(s);
strFrequency.append(\",\");
cnt++;
if(cnt >= maxLines){break;}
}
return strFrequency.toString();
}
/**
*
*/
public static void main(String[] args) {
In in;
Frequency freq = new Frequency();
int MAX = 100;
// String inputSourceName =
\"http://www.cs.umd.edu/class/summer2015/cmsc132/projects/P3_WordFrequency/test1.html\";
String .
Tested on EclipseBoth class should be in same package.pdf
Tested on Eclipse
Both class should be in same package
/***********UNMember class***********/
import java.util.Scanner;
public class UNMember {
/*data member declaration*/
private String name;
private int NUID;
private String netID;
private String collegeLocation;
Scanner input=new Scanner(System.in);
/*Default constructor*/
public UNMember() {
}
/*Parameterized constructor*/
public UNMember(String name, int nUID, String netID) {
setName(name);
setNUID(nUID);
setNetID(netID);
setCollegeLocation();
}
/*Getter and setter method of data member variable*/
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNUID() {
return NUID;
}
public void setNUID(int nUID) {
NUID = nUID;
}
public String getNetID() {
return netID;
}
public void setNetID(String netID) {
this.netID = netID;
}
public String getCollegeLocation() {
return collegeLocation;
}
public void setCollegeLocation() {
String collegeLocation;
/*Prompt for college location*/
System.out.println(\"Please Enter the college Location\");
collegeLocation=input.nextLine();
this.collegeLocation = collegeLocation;
}
@Override
public String toString() {
return \"Name:\" + name.toUpperCase() + \"\ NUID=\" + NUID + \"\ NetID:\" +
netID.toUpperCase() + \"\ Campus Location:\" + collegeLocation.toUpperCase()
+ \"\ \";
}
}
/************UNStaff class*************/
import java.text.DecimalFormat;
public class UNStaff extends UNMember{
/*Member data variable declaration*/
private String position;
private double wage;
/*Parameterized constructor*/
public UNStaff(String position, double wage,String name,int NUID,String netID) {
super(name,NUID,netID);
setPosition(position);
setWage(wage);
}
/*Getter and Setter method of data member variable*/
public String getPosition() {
return position;
}
public void setPosition(String position) {
if(position.equals(\"\")|| position==null){
this.position=\"NOT SET\";
}else{
this.position = position;
}
}
public double getWage() {
return wage;
}
/*Set wage , if wage less then 9 then we are setting it to -1*/
public void setWage(double wage) {
if(wage<9){
this.wage=-1;
}else{
this.wage = wage;
}
}
/*ToString method*/
@Override
public String toString() {
String result=\"Position:\" + position.toUpperCase() + \"\ \";
if(this.wage==-1){
result+=\"Wage:NOT SET\";
}else{
result+=\"Wage:$\"+new DecimalFormat(\"##.00\").format(this.wage);
}
return super.toString()+result;
}
public static void main(String args[]){
UNStaff staff=new UNStaff(\"secretary\", 50.6, \"David\", 123, \"UN123\");
UNStaff staff1=new UNStaff(\"cleark\", 8, \"Sam\", 129, \"UN129\");
System.out.println(\"**************\");
System.out.println(staff.toString());
System.out.println(\"**************\");
System.out.println(staff1.toString());
}
}
/***************output*************/
Please Enter the college Location
california
Please Enter the college Location
Los Angeles
**************
Name:DAVID
NUID=123
NetID:UN123
Campus Location:CALIFORNIA
Position:SECRETARY
Wage.
Similar to PickerApp CLass.pdf (20)
1 The goal is to implement DataStructuresArrayStack accor.pdf
1 The goal is to implement DataStructuresArrayStack accor.pdf
PrimeRange.java import java.util.Scanner;public class PrimeRan.pdf
PrimeRange.java import java.util.Scanner;public class PrimeRan.pdf
Using NetBeansImplement a queue named QueueLL using a Linked List .pdf
Using NetBeansImplement a queue named QueueLL using a Linked List .pdf
BasicPizza.javapublic class BasicPizza { Declaring instance .pdf
BasicPizza.javapublic class BasicPizza { Declaring instance .pdf
import java.util.Scanner;public class Fraction { instan.pdf
import java.util.Scanner;public class Fraction { instan.pdf
public class Point { Insert your name here private dou.pdf
public class Point { Insert your name here private dou.pdf
import java.util.Random;ASSIGNMENT #2 MATRIX ARITHMETIC Cla.pdf
import java.util.Random;ASSIGNMENT #2 MATRIX ARITHMETIC Cla.pdf
import java.util.Scanner;public class HornersPolynomial { .pdf
import java.util.Scanner;public class HornersPolynomial { .pdf
Frequency .java Word frequency counter package frequ.pdf
Frequency .java Word frequency counter package frequ.pdf
Tested on EclipseBoth class should be in same package.pdf
Tested on EclipseBoth class should be in same package.pdf
More from ankitcom
using the equation P1V1T1 = P2V2T2 we have .pdf
using the equation P1*V1/T1 = P2*V2/T2 we have
V2=99.6*2.16*285/(305*122.8)= 1.64 l
Solution
using the equation P1*V1/T1 = P2*V2/T2 we have
V2=99.6*2.16*285/(305*122.8)= 1.64 l.
we do not have rights to delete questionsSolutionwe do not hav.pdf
we do not have rights to delete questions
Solution
we do not have rights to delete questions.
The most iteresting or surprising fact about microbiology is the exi.pdf
The most iteresting or surprising fact about microbiology is the existence of microbial cells with
very small size that are able to survive and infect most evolved human beings.
The perception of \'real world\' changes when the facts about the microbiology are known. These
include smallest viruses, bacteria, bacteriophages, protozoans and wide variety of minute,
unicellular organisms exist along with us. These organisms are ubiquitous. Though viruses are
considered as acellular, they contain genetic material and carryout replication and protein
synthesis in presence of host. An infectious protein molecule (prion) is able to cause various
diseases in humans and animals. These facts not only surprise but explore the real world in depth
what we see.
The knowledge about microbiology has changed idea of \'real world\' with the introduction of
microbes. Therefore, the knowledge about microbes was certainly useful to get benefits out of
them and be aware of them to be away from infections.
One strong change in thinking after gaining knowledge about microbes is to be away from
infectious agents and taking necessary precautions to avoid infections. The perception has
changed to be more careful because the number benefits obtained from microbes far less than the
potent and harmful infections they cause.
Solution
The most iteresting or surprising fact about microbiology is the existence of microbial cells with
very small size that are able to survive and infect most evolved human beings.
The perception of \'real world\' changes when the facts about the microbiology are known. These
include smallest viruses, bacteria, bacteriophages, protozoans and wide variety of minute,
unicellular organisms exist along with us. These organisms are ubiquitous. Though viruses are
considered as acellular, they contain genetic material and carryout replication and protein
synthesis in presence of host. An infectious protein molecule (prion) is able to cause various
diseases in humans and animals. These facts not only surprise but explore the real world in depth
what we see.
The knowledge about microbiology has changed idea of \'real world\' with the introduction of
microbes. Therefore, the knowledge about microbes was certainly useful to get benefits out of
them and be aware of them to be away from infections.
One strong change in thinking after gaining knowledge about microbes is to be away from
infectious agents and taking necessary precautions to avoid infections. The perception has
changed to be more careful because the number benefits obtained from microbes far less than the
potent and harmful infections they cause..
The electrophilic aromatic substitution decreases ifelectron with dr.pdf
The electrophilic aromatic substitution decreases ifelectron with drawing groups are present on
the ring.
Hence the order of decreasing reactivity towardselectrophillic aromatic subtsitution is -
anisole > 4 -bromo phenol > phenol > 1-naphthol > acetanilide > diphenyl ether
Solution
The electrophilic aromatic substitution decreases ifelectron with drawing groups are present on
the ring.
Hence the order of decreasing reactivity towardselectrophillic aromatic subtsitution is -
anisole > 4 -bromo phenol > phenol > 1-naphthol > acetanilide > diphenyl ether.
The buffer solution contains the following species in solutionHCH.pdf
The buffer solution contains the following species in solution:
HCHO2(aq), HCO2-(aq), Na+(aq)
When NaOH is added, the OH- ions react with formic acid to give formate ions and water. It is
an acid-base neutralization reaction (weak acid and strong base).
The net equation is given by:
OH-(aq) + HCHO2(aq) => HCO2-(aq) + H2O(l)
Solution
The buffer solution contains the following species in solution:
HCHO2(aq), HCO2-(aq), Na+(aq)
When NaOH is added, the OH- ions react with formic acid to give formate ions and water. It is
an acid-base neutralization reaction (weak acid and strong base).
The net equation is given by:
OH-(aq) + HCHO2(aq) => HCO2-(aq) + H2O(l).
That is Distributive propertySolutionThat is Distributive prop.pdf
That is Distributive property
Solution
That is Distributive property.
System Maintenance System maintenance is a current action,.pdf
System Maintenance
System maintenance is a current action, which cover a spacious array of activities, include
remove program and propose errors, update certification and check data and update client
sustain. For the reason of expediency, maintenance
(1) Hardware maintenance is the test and clean-up of system
(2) In sequence system maintenance is the custom update of master records, such as addition and
delete workforce and clients and shifting glory limits and invention prices
system’s maintenance concept
Probable level of restore
Universal overall restore policy
Managerial responsibilities for protection
Predictable accessibility of wealth
Use of contractor both CONUS and OCONUS
Constitutional and authoritarian maintenance guidance
System development cycle
The development in depth design that bring first plan job into a done with form of
condition. Work includes the condition of interface between the scheme and its intentional
environment and a widespread assessment of the systems logistical, maintenance and support
necessities. The element design and growth is guilty for produce the result, procedure and
material condition
Design and development
Full design
Full synthesis
Growth of engineering and sample model
Modification of development condition
Result, procedure and material condition
Significant design analysis
Development Cycle
Planning
analysis project requirements
Prioritize project requirements
assign possessions
recognize project expansion team
Analyzing
perform preliminary analysis
do full analysis activities:
Learn present system
Decide user necessities
Advice clarification
Design
obtain hardware and software, if required
expand particulars of system
Implementation
expand programs, if essential
Install and analysis new structure
prepare client
exchange to new structure
Support
behavior post-implementation structure review
recognize error and enhancement
examine structure performance
Solution
System Maintenance
System maintenance is a current action, which cover a spacious array of activities, include
remove program and propose errors, update certification and check data and update client
sustain. For the reason of expediency, maintenance
(1) Hardware maintenance is the test and clean-up of system
(2) In sequence system maintenance is the custom update of master records, such as addition and
delete workforce and clients and shifting glory limits and invention prices
system’s maintenance concept
Probable level of restore
Universal overall restore policy
Managerial responsibilities for protection
Predictable accessibility of wealth
Use of contractor both CONUS and OCONUS
Constitutional and authoritarian maintenance guidance
System development cycle
The development in depth design that bring first plan job into a done with form of
condition. Work includes the condition of interface between the scheme and its intentional
environment and a widespread assessment of the systems logistical, maintenance and support
necessities. The elemen.
sol It says that it absorbs 322 J of heat, there.pdf
sol: It says that it absorbs 322 J of heat, therefore the internal energy changed by
322 J
Solution
sol: It says that it absorbs 322 J of heat, therefore the internal energy changed by
322 J.
Reverse transcriptase is an enzyme present in some of the virses whi.pdf
Reverse transcriptase is an enzyme present in some of the virses which has the ability of
synthesizing a complementary DNA using an RNA molecule as a template.This process is called
reverse transcription.This is not possible by normal DNA polymerase because it is only possible
to make RNA from DNA,but not the vice versa,which is only possible by reverse
transcriptase.The retroviruses or RNA viruses contains RNA as their genetic material,so when
they infect a host genome,they use this RNA as a template to make a complementary DNA using
the host\'s transcriptional machinery and thus start replicating.Reverse transcriptase is mainly
present only in some viruses,not humans,but an exception is the telomere portion of a
chromosome in human and other organisms where enzyme telomerase is present which acts as a
reverse transcriptase.
Solution
Reverse transcriptase is an enzyme present in some of the virses which has the ability of
synthesizing a complementary DNA using an RNA molecule as a template.This process is called
reverse transcription.This is not possible by normal DNA polymerase because it is only possible
to make RNA from DNA,but not the vice versa,which is only possible by reverse
transcriptase.The retroviruses or RNA viruses contains RNA as their genetic material,so when
they infect a host genome,they use this RNA as a template to make a complementary DNA using
the host\'s transcriptional machinery and thus start replicating.Reverse transcriptase is mainly
present only in some viruses,not humans,but an exception is the telomere portion of a
chromosome in human and other organisms where enzyme telomerase is present which acts as a
reverse transcriptase..
public class InsufficientFundsException extends Exception{Insuffic.pdf
public class InsufficientFundsException extends Exception{
InsufficientFundsException(double balance)
{
System.out.println(\"insufficient funds .... available balance : \"+balance);
}
}
// Account.java
public class Account throws InsufficientFundsException{
private int acctNo;
private String owner;
private double balance;
public Account(){
acctNo = 00;
owner = \" \";
balance= 0.0;
}
public Account(int ac, String own, double bal){
acctNo = ac;
owner = own;
balance = bal;
}
public void Deposit(double amount){
balance = balance + amount;
}
public void Withdraw (double amount){
try {
if(amount>balance)
{
throw new InsufficientFundsException(balance);
}
else
balance =balance - amount;
}
catch(InsufficientFundsException e)
{
System. out.println(e.printStackTrace());
}
}
public int getAcctNo() {
return acctNo;
}
public void setAcctNo(int ac) {
acctNo = ac;
}
public String getOwner() {
return owner;
}
public void setOwner(String own) {
owner = own;
}
public double getBalance() {
return balance;
}
public void setBalance(double bal) {
balance = bal;
}
public void display(){
System.out.println(\"Account Number = \" + getAcctNo());
System.out.println(\"Account Owner = \" + getOwner());
System.out.println(\"Account Balance = $\" + getBalance());
System.out.println();
}
}
public class TestExceptions{
public static void main(String args []){
Account a1;
a1 = new Account(2222, \"Jimmy Zulu\", 1000);
a1.Deposit(100);
a1.display();
Account a2;
a2 = new Account();
a2.setAcctNo(3333);
a2.setOwner(\"John Mwemba\");
a2.setBalance(500);
a2.Deposit(100);
a2.Withdraw(900);
a2.display();
}
}
Solution
public class InsufficientFundsException extends Exception{
InsufficientFundsException(double balance)
{
System.out.println(\"insufficient funds .... available balance : \"+balance);
}
}
// Account.java
public class Account throws InsufficientFundsException{
private int acctNo;
private String owner;
private double balance;
public Account(){
acctNo = 00;
owner = \" \";
balance= 0.0;
}
public Account(int ac, String own, double bal){
acctNo = ac;
owner = own;
balance = bal;
}
public void Deposit(double amount){
balance = balance + amount;
}
public void Withdraw (double amount){
try {
if(amount>balance)
{
throw new InsufficientFundsException(balance);
}
else
balance =balance - amount;
}
catch(InsufficientFundsException e)
{
System. out.println(e.printStackTrace());
}
}
public int getAcctNo() {
return acctNo;
}
public void setAcctNo(int ac) {
acctNo = ac;
}
public String getOwner() {
return owner;
}
public void setOwner(String own) {
owner = own;
}
public double getBalance() {
return balance;
}
public void setBalance(double bal) {
balance = bal;
}
public void display(){
System.out.println(\"Account Number = \" + getAcctNo());
System.out.println(\"Account Owner = \" + getOwner());
System.out.println(\"Account Balance = $\" + getBalance());
System.out.println();
}
}
public class TestExceptions{
public static void main(String args []){
Account a1;
a1 = new Account(2222, \"Jimmy Zu.
Plug in real numbers for a and b.Since it isnSolutionPlug in.pdf
Plug in real numbers for a and b.
Since it isn
Solution
Plug in real numbers for a and b.
Since it isn.
Retention factor (Rƒ) is the distance travelled b.pdf
Retention factor (Rƒ) is the distance travelled by the sample or analyte divided by
distance travelled by the solvent front in chromatography, so it is ratio of the distance travelled
by the substance to the distance travelled by the solvent. During thin layer chromatography, less
polar compound moves higher up the plate, resulting in a higher Rf value. The more polar
compound has a stronger interaction with the silica and has higher capablity to dispel the mobile
phase from the binding places. So, if the Rf of these substances are same, they have traveled
same distance, so they are chemically identical i.e. either polar or nonpolar depending on where
the spots appeared in your result. So if the spots appeared higher up the plate, these substances
are polar and so on. I hope that helps!
Solution
Retention factor (Rƒ) is the distance travelled by the sample or analyte divided by
distance travelled by the solvent front in chromatography, so it is ratio of the distance travelled
by the substance to the distance travelled by the solvent. During thin layer chromatography, less
polar compound moves higher up the plate, resulting in a higher Rf value. The more polar
compound has a stronger interaction with the silica and has higher capablity to dispel the mobile
phase from the binding places. So, if the Rf of these substances are same, they have traveled
same distance, so they are chemically identical i.e. either polar or nonpolar depending on where
the spots appeared in your result. So if the spots appeared higher up the plate, these substances
are polar and so on. I hope that helps!.
Java doesnt support multiple inheritance, therefore a class cannot.pdf
Java doesn\'t support multiple inheritance, therefore a class cannot inherit more than one class,
where as a can can implement multiple interfaces.A class can implement multiple interfaces.
Solution
Java doesn\'t support multiple inheritance, therefore a class cannot inherit more than one class,
where as a can can implement multiple interfaces.A class can implement multiple interfaces..
In pc engineering, pc design is that the abstract style and elementa.pdf
In pc engineering, pc design is that the abstract style and elementary operational structure of a
automatic data processing system. it\'s the technical drawings and purposeful description of all
style necessities (especially speeds and interconnections), it\'s means to|a way to} style and
implement varied components of a pc — focusing for the most part on the way by that the central
process unit (CPU) operates internally and the way it accesses addresses in memory.
It are often outlined because the science and art of choosing and interconnecting hardware
elements to make computers that meet purposeful, performance and price goals.
Computer design includes a minimum of 3 main subcategories:[1]
Instruction set design, or ISA, is that the abstract model of a system that\'s seen by a machine
language (or assembly language) technologist, as well as the instruction set, memory address
modes, processor registers, and address and knowledge formats.
Microarchitecture, conjointly referred to as pc organization could be a lower level, an in depth
description of the system that\'s sufficient for fully describing the operation of all components of
the system, and the way they\'re inter-connected and inter-operate so as to implement the ISA.[2]
the dimensions of a computer\'s cache for example, is associate degree structure issue that
typically has nothing to try to to with the ISA.
System style which incorporates all of the opposite hardware elements at intervals a system such
as:
System interconnects like pc buses and switches.
Memory controllers and hierarchies.
CPU off-load mechanisms like direct access.
Issues like multi-processing.
Once each ISA and microarchitecture has been such, the particular system has to be designed
into hardware. This style method is named implementation. Implementation is sometimes a
hardware engineering style method.
Implementation are often any weakened into 3 however not totally separate pieces:
Logic Implementation: style of blocks outlined within the microarchitecture, mainly, at the
register-transfer AND gate levels.
Circuit Implementation: Transistor-level style of basic components (gates, multiplexers, flip-
flops, etc.) in addition as of some larger blocks (ALUs, caches etc.) which will be enforced at
this level, or perhaps at a lower physical level, for performance reasons.
Physical Implementation: Physical circuits ar drawn out, the various circuit elements ar placed
in a very chip floor-plan or on a board and also the wires connecting them ar routed.
For CPUs, the whole implementation method is usually known as mainframe design; it can even
be a family of connected mainframe styles, like reduced instruction set computing and CISC.
Solution
In pc engineering, pc design is that the abstract style and elementary operational structure of a
automatic data processing system. it\'s the technical drawings and purposeful description of all
style necessities (especially speeds and interconnections), it\'s means to|a way to}.
In the year 1900, the maximum number of deaths occurred due to infec.pdf
In the year 1900, the maximum number of deaths occurred due to infectious and communicable
diseases. The top killer was pneumonia or influenza (202.2/100000 deaths), followed by TB
(194.4/100000 deaths) and the third spot taken by gastrointestinal diseases (142.7/100000
deaths). The treatment of these diseases required a general improvement in sanitary conditions,
health and hygiene. The main mode of curing these diseases would be by prescribing the relevant
antibiotics in the case of pneumonia, prescribing the cocktail of drugs to cure TB and usage of
antibiotics as well as maintaining the fluid and salt levels in the body in the case of
gastrointestinal diseases.
Currently, we find that the whole spectrum of diseases affecting humans in the U. S.
A. has undergone a radical change. Due to improvement in health and sanitation, the infectious
diseases are reduced to a small minority in the overall scheme of diseases that affect humans.
They are not as serious as they were in 1900.
In the year 2000, heart disease has emerged as the main killer disease (192.9 /100000
deaths) followed by cancer (185.9 /100000 deaths). This is a drastic increase from the 1900
levels, especially for cancer as only 64 / 100000 deaths were due to cancer in 1900. Overall the
number of deaths has significantly reduced from 1900 levels and the life expectancy of the
population has consequently improved. In this scenario, the above two diseases are even more
important in maintaining the health of the population.
What has to be kept in mind here is that the two diseases above are not infectious
diseases, there is no pathogen that has to be eliminated or killed to save the patient. Rather, these
two are lifestyle diseases. Heart disease is caused by a number of factors, chief of which are our
sedentary lifestyle, lack of exercise, poor diet, consumption of junk food, smoking etc. similarly,
the types of cancers are many. Most of the cancers caused can be related to the presence of a
large number of carcinogens present in our environment.
A person who is suffering from heart disease or cancer has not only to be cured of it,
but once the person is cured, there has to be a life long follow up of the person. With increasing
life expectancy, the care needed for the person and the expenses to be met are all going up
placing a lot of strain on limited resources available with the individual and the government.
The human genome project has revolutionized biology. A complete database of a
person’s DNA make up is now available. For eg. In the case of cancer, scientists have been able
to identify oncogenes present in the human genome. Scientists are able to also understand the
genetic factors behind diseases including heart disease. By looking into the genome of a person,
it is possible to pinpoint the chances of a person developing a particular disease at a particular
stage of his/ her life. The doctor can then propose changes or steps to be taken to minimize the
chances of that par.
home.htmlStarted!DOCTYPE html html la.pdf
************home.html*********Started***
About Me ABOUT ME
Hi there, I\'m Bhavani.
With experience in web, graphic, interior and exterior design, I maintain a healthy balance
between functionality and visual
impact in all my work. I believe every piece of design can be a work of art.
I love my work and enjoy each new project as I get it. Feel free to have a look at my portfolio
and don\'t hesitate to contact me
if you think I can be of service to you.
Thanks for stopping by!
BhavaniHobbies
© Copy Right 2016
************home.html*********Ended****
************hobbies.html*********Started****
Hobbies HOBBIES
Reading Books
My first hobby is reading books. I always try to finish any kind of book with in a week.
My favourite writers reside around the world. Some of my best are below.
1) William Shakespeare
2) Sydney Sheldon
3) J. K. Rowling
4) Leo Tolstoy
I personally love Tolstoy because he is one of the giants of Russian literature.
Watching Movies
My another hobby is watching movies. I watch any movie that belongs to any kind of genre. I
love action and drama
more. My favourite stars are Jonny Depp, Jennifer Lawrence, Hugh JackMan, Will Smith,
Juliana Moore.
My all time favourite movies are:
1) THE TERMINATOR:JUDGEMENT DAY
2) GLADIATOR
3) ALL ROCKY Series
Bands
© Copy Right 2016
************hobbies.html*********Ended****
************bands.html*********Started****
Music bands MUSIC BANDS
Lauren Daigle
Lauren Ashley Daigle (born September 9, 1991) is an American contemporary Christian music
singer from Lafayette, Louisiana.
Daigle is signed to the Centricity Music label. Daigle was awarded the New Artist of the Year at
the 2015 GMA Dove Awards; \"How Can It Be\"
won the Song of the Year for the year.
Find her on Lauren DaigleUnspoken
Unspoken is an American Christian pop rock band. The band is composed of Mike Gomez, Jon
Lowry, Chad Mattson and Ariel Munoz. The band released their debut single \"Who You Are\"
on the record label Centricity Music. Released on June 12, 2012.
The song has charted on numerous Christian song charts, and was the only song from the band\'s
debut EP Get to Me to be featured on their first full-length album.
Find them on UnspokenHome
© Copy Right 2016
************bands.html*********Ended****
Please save those three codes in three separate files as the names given above. use the same
names to make hypher links works that traverse through three pages(home.html,
hobbies.html,bands.html) which are interlinked.
You can add any info in the content of those three pages in tags.
Thank you.
regards,
Bhavani.K
Solution
************home.html*********Started***
About Me ABOUT ME
Hi there, I\'m Bhavani.
With experience in web, graphic, interior and exterior design, I maintain a healthy balance
between functionality and visual
impact in all my work. I believe every piece of design can be a work of art.
I love my work and enjoy each new project as I get it. Feel free to have a look at my portfolio
and don\'t hesitate to contact me
if yo.
Pb3O4 -- PbO + Pb2O3 hence the mole ratio of le.pdf
Pb3O4 --> PbO + Pb2O3 hence the mole ratio of lead (II) to lead (IV) = 1:1
Solution
Pb3O4 --> PbO + Pb2O3 hence the mole ratio of lead (II) to lead (IV) = 1:1.
More from ankitcom (20)
we do not have rights to delete questionsSolutionwe do not hav.pdf
we do not have rights to delete questionsSolutionwe do not hav.pdf
The most iteresting or surprising fact about microbiology is the exi.pdf
The most iteresting or surprising fact about microbiology is the exi.pdf
The electrophilic aromatic substitution decreases ifelectron with dr.pdf
The electrophilic aromatic substitution decreases ifelectron with dr.pdf
The buffer solution contains the following species in solutionHCH.pdf
The buffer solution contains the following species in solutionHCH.pdf
That is Distributive propertySolutionThat is Distributive prop.pdf
That is Distributive propertySolutionThat is Distributive prop.pdf
System Maintenance System maintenance is a current action,.pdf
System Maintenance System maintenance is a current action,.pdf
sol It says that it absorbs 322 J of heat, there.pdf
sol It says that it absorbs 322 J of heat, there.pdf
Reverse transcriptase is an enzyme present in some of the virses whi.pdf
Reverse transcriptase is an enzyme present in some of the virses whi.pdf
public class InsufficientFundsException extends Exception{Insuffic.pdf
public class InsufficientFundsException extends Exception{Insuffic.pdf
Plug in real numbers for a and b.Since it isnSolutionPlug in.pdf
Plug in real numbers for a and b.Since it isnSolutionPlug in.pdf
Retention factor (Rƒ) is the distance travelled b.pdf
Retention factor (Rƒ) is the distance travelled b.pdf
Java doesnt support multiple inheritance, therefore a class cannot.pdf
Java doesnt support multiple inheritance, therefore a class cannot.pdf
In pc engineering, pc design is that the abstract style and elementa.pdf
In pc engineering, pc design is that the abstract style and elementa.pdf
In the year 1900, the maximum number of deaths occurred due to infec.pdf
In the year 1900, the maximum number of deaths occurred due to infec.pdf
Pb3O4 -- PbO + Pb2O3 hence the mole ratio of le.pdf
Pb3O4 -- PbO + Pb2O3 hence the mole ratio of le.pdf
Recently uploaded
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...Dr. Vinod Kumar Kanvaria
Exploiting Artificial Intelligence for Empowering Researchers and Faculty,
International FDP on Fundamentals of Research in Social Sciences
at Integral University, Lucknow, 06.06.2024
By Dr. Vinod Kumar KanvariaPCOS corelations and management through Ayurveda.
This presentation includes basic of PCOS their pathology and treatment and also Ayurveda correlation of PCOS and Ayurvedic line of treatment mentioned in classics.
What is the purpose of studying mathematics.pptx
Students often ask about what the purpose is for their learning. This PowerPoint highlights some really important reasons to study Mathematics.
বাংলাদেশ অর্থনৈতিক সমীক্ষা (Economic Review) ২০২৪ UJS App.pdf
বাংলাদেশের অর্থনৈতিক সমীক্ষা ২০২৪ [Bangladesh Economic Review 2024 Bangla.pdf] কম্পিউটার , ট্যাব ও স্মার্ট ফোন ভার্সন সহ সম্পূর্ণ বাংলা ই-বুক বা pdf বই " সুচিপত্র ...বুকমার্ক মেনু 🔖 ও হাইপার লিংক মেনু 📝👆 যুক্ত ..
আমাদের সবার জন্য খুব খুব গুরুত্বপূর্ণ একটি বই ..বিসিএস, ব্যাংক, ইউনিভার্সিটি ভর্তি ও যে কোন প্রতিযোগিতা মূলক পরীক্ষার জন্য এর খুব ইম্পরট্যান্ট একটি বিষয় ...তাছাড়া বাংলাদেশের সাম্প্রতিক যে কোন ডাটা বা তথ্য এই বইতে পাবেন ...
তাই একজন নাগরিক হিসাবে এই তথ্য গুলো আপনার জানা প্রয়োজন ...।
বিসিএস ও ব্যাংক এর লিখিত পরীক্ষা ...+এছাড়া মাধ্যমিক ও উচ্চমাধ্যমিকের স্টুডেন্টদের জন্য অনেক কাজে আসবে ...
Introduction to AI for Nonprofits with Tapp Network
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama UniversityAkanksha trivedi rama nursing college kanpur.
Natural birth techniques are various type such as/ water birth , alexender method, hypnosis, bradley method, lamaze method etcA Strategic Approach: GenAI in Education
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
Your Skill Boost Masterclass: Strategies for Effective Upskilling
Your Skill Boost Masterclass: Strategies for Effective UpskillingExcellence Foundation for South Sudan
Strategies for Effective Upskilling is a presentation by Chinwendu Peace in a Your Skill Boost Masterclass organisation by the Excellence Foundation for South Sudan on 08th and 09th June 2024 from 1 PM to 3 PM on each day.Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...National Information Standards Organization (NISO)
This presentation was provided by Steph Pollock of The American Psychological Association’s Journals Program, and Damita Snow, of The American Society of Civil Engineers (ASCE), for the initial session of NISO's 2024 Training Series "DEIA in the Scholarly Landscape." Session One: 'Setting Expectations: a DEIA Primer,' was held June 6, 2024.Digital Artifact 1 - 10VCD Environments Unit
Digital Artifact 1 - 10VCD Environments Unit - NGV Pavilion Concept Design
"Protectable subject matters, Protection in biotechnology, Protection of othe...
Protectable subject matters, Protection in biotechnology, Protection of other biological materials, Ownership and period of protection
Recently uploaded (20)
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
বাংলাদেশ অর্থনৈতিক সমীক্ষা (Economic Review) ২০২৪ UJS App.pdf
বাংলাদেশ অর্থনৈতিক সমীক্ষা (Economic Review) ২০২৪ UJS App.pdf
Introduction to AI for Nonprofits with Tapp Network
Introduction to AI for Nonprofits with Tapp Network
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Your Skill Boost Masterclass: Strategies for Effective Upskilling
Your Skill Boost Masterclass: Strategies for Effective Upskilling
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
"Protectable subject matters, Protection in biotechnology, Protection of othe...
"Protectable subject matters, Protection in biotechnology, Protection of othe...
PickerApp CLass.pdf
- 1. //**************************** PickerApp CLass****************************************************** package increment.pick; import java.util.Random; public class PickerApp { private int upperLimit; private int number; private int guessCount; /** * Default constructor */ public PickerApp() { this(50); } /** * Parameterized constructor * param upperLimit */ public PickerApp(int upperLimit) { this.upperLimit = upperLimit; Random random = new Random(); number = random.nextInt(upperLimit - 1) + 1; guessCount = 1; } public int getNumber() { return number; } public int getGuessCount() { return guessCount; } public int getUpperLimit() { return upperLimit; } public void incrementGuessCount() { guessCount = guessCount + 1;
- 2. } } //********************************** PICK CLass**************************************************** package increment.pick; import java.util.Scanner; public class Pick { public static void main(String args[]) { System.out.println("Hello "); System.out.println(); Scanner sc = new Scanner(System.in); PickerApp game = new PickerApp(); System.out.println("I have selected a number between 0 and " + game.getUpperLimit()); System.out.println(); while(true) { System.out.print("Enter your guess: "); //A) a) int guess = 0; try { //C) g) guess = Integer.parseInt(sc.nextLine()); //A) a) } catch(NumberFormatException nfe) { System.out.println("Invalid number"); continue; } //D) i) if((guess <= 0) || (guess >= game.getUpperLimit())) System.out.println("Enter a between 0 and " + game.getUpperLimit() + " both exclusive"); else { if(guess == game.getNumber()) //A) b) If user guesses the correct number break break; else if (guess > (game.getNumber() + 10)) { //B) d) System.out.println("Way too high! "); } else if (guess < game.getNumber()) {
- 3. System.out.println("Your guess is too low. "); } else if (guess > game.getNumber()) { System.out.println("Your guess is too high. "); } } game.incrementGuessCount(); } //B) e) if(game.getGuessCount() <= 3) System.out.println("Great work! You are a mathematical wizard."); else if((game.getGuessCount() > 3) && (game.getGuessCount() <= 7)) System.out.println("Not too bad! You've got some potential."); else if(game.getGuessCount() > 7) System.out.println("What took so you so long? Maybe you shoould take some lessons"); //Close scanner sc.close(); } } SAMPLE OUTPUT: Hello I have selected a number between 0 and 50 Enter your guess: 0 Enter a between 0 and 50 both exclusive Enter your guess: 50 Enter a between 0 and 50 both exclusive Enter your guess: 2 Great work! You are a mathematical wizard. Solution //**************************** PickerApp CLass****************************************************** package increment.pick;
- 4. import java.util.Random; public class PickerApp { private int upperLimit; private int number; private int guessCount; /** * Default constructor */ public PickerApp() { this(50); } /** * Parameterized constructor * param upperLimit */ public PickerApp(int upperLimit) { this.upperLimit = upperLimit; Random random = new Random(); number = random.nextInt(upperLimit - 1) + 1; guessCount = 1; } public int getNumber() { return number; } public int getGuessCount() { return guessCount; } public int getUpperLimit() { return upperLimit; } public void incrementGuessCount() { guessCount = guessCount + 1; } } //********************************** PICK CLass****************************************************
- 5. package increment.pick; import java.util.Scanner; public class Pick { public static void main(String args[]) { System.out.println("Hello "); System.out.println(); Scanner sc = new Scanner(System.in); PickerApp game = new PickerApp(); System.out.println("I have selected a number between 0 and " + game.getUpperLimit()); System.out.println(); while(true) { System.out.print("Enter your guess: "); //A) a) int guess = 0; try { //C) g) guess = Integer.parseInt(sc.nextLine()); //A) a) } catch(NumberFormatException nfe) { System.out.println("Invalid number"); continue; } //D) i) if((guess <= 0) || (guess >= game.getUpperLimit())) System.out.println("Enter a between 0 and " + game.getUpperLimit() + " both exclusive"); else { if(guess == game.getNumber()) //A) b) If user guesses the correct number break break; else if (guess > (game.getNumber() + 10)) { //B) d) System.out.println("Way too high! "); } else if (guess < game.getNumber()) { System.out.println("Your guess is too low. "); } else if (guess > game.getNumber()) { System.out.println("Your guess is too high. "); }
- 6. } game.incrementGuessCount(); } //B) e) if(game.getGuessCount() <= 3) System.out.println("Great work! You are a mathematical wizard."); else if((game.getGuessCount() > 3) && (game.getGuessCount() <= 7)) System.out.println("Not too bad! You've got some potential."); else if(game.getGuessCount() > 7) System.out.println("What took so you so long? Maybe you shoould take some lessons"); //Close scanner sc.close(); } } SAMPLE OUTPUT: Hello I have selected a number between 0 and 50 Enter your guess: 0 Enter a between 0 and 50 both exclusive Enter your guess: 50 Enter a between 0 and 50 both exclusive Enter your guess: 2 Great work! You are a mathematical wizard.