Balance the following by the half-reaction method. The reaction occurs in acid. How many water molecules are in the final balanced equation?
Mn+2(aq) + I2(s) --> I-1(aq) + MnO4-1(aq)
| A. |
4 |
|
| B. |
12 |
|
| C. |
8 |
|
| D. |
2 |
In: Chemistry
a) Calculate the maximum MaxDisk value of the function f (x,y) = 9 ln * (x^2+(1+1)y^2+(0.5+0.5)) on the circle disk with the center of origin and radius 4.
b) Also calculate the maximum the value MaxBorder that the function assumes on the border.
In: Math
In: Biology
question: Draw a MPLS diagram with the following requirements: [ 2 + 8 = 10 marks]
1. 10 IPv6 routers: 4 routers in one segment, 3 routers in second segment, 1 router to connect these two segments
2. Explain MPLS operation in above network.
In: Computer Science
1. In the complex reactions that make up cellular respiration, energy is transferred by
A. phosphorylation reactions
B. redox reactions
C. neither 1 or 2
D. both 1 and 2
2. Respiration of carbohydrate substrates provides more energy than proteins substrates because
A. proteins have no C-H bonds
B. proteins cannot be processed by glycolysis
C. proteins compete with NADH reduction reactions
D. proteins release NH3
3. Which of the 4 stages of respiration is anaerobic, and can continue without oxygen?
A. citric acid cycle
B. glycolysis
C. electron transport and oxidative phosphorylation
D. pyruvate processing
4. ATP is a regulatory molecule for the allosteric enzyme phospho-fructose kinase. This regulatory mechanism of the activity of glycolysis is called:
A. interference inhibition
B. competitive inhibition
C. feedback inhibition
D. active site inhibition
5. The NET output of glycolysis of 1 glucose molecule is
A. 4 ATP, 2 NADH
B. 2ATP, 2 FADH2
C. 2 ATP, 2 NADH
D. 2 ATP, 2 FADH2
6. Which of the four stages of respiration does NOT take place in mitochondria
A. pyruvate processing
B. glycolysis
C. Citric acid cycle
D. electron transport and oxidative phosphorylation
7. The citric acid cycle is a set of sequential reactions where 2 carbon atoms from Acetyl CoA (that derives from a glucose molecule) are coupled to a 4 carbon molecule. The carbon atoms from Acetyl CoA are released as CO2. Redox reactions and phosphorylation reactions are used to harvest energy in the form of ATP, NADH and FADH2. The product of these reactions is again a 4 carbon molecule that can be coupled with 2 carbon atoms from another Acetyl CoA to repeat the whole process
A. true, this is a correct description of the citric acid cycle
B. false, the citric acid cycle starts with pyruvate as substrate
C. false, the citric acid cycle employs only redox reactions
D. false, the citric acid cycle does not yield NADH
8. The net total output of energy rich molecules from respiration of a molecule of glucose after the citric acid cycle is
A. 2 ATP, 50 NADH, 4 FADH2
B. 2 ATP, 10 NADH, 2 FADH2
C. 4 ATP, 10 NADH, 2 FADH2
D. 4 ATP, 2 NADH, 10 FADH2
9. In the absence of oxygen, cellular respiration switches to fermentation. Fermentation is a set of alternative reactions to complete glycolysis and produce 2 ATP for a glucose molecule, by making sure that the following reagent is available
A. NAD (oxidized electron carrier)
B. EtOH (alcohol)
C. NADH (reduced electron carrier)
D. Acetyl CoA (substrate for citric acid cycle)
In: Biology
a) Evaluate the limit lim x→0 tan(2x) / x
b) Differentiate y = x^tan(x)
c) Find the equation of the tangent line to 4x^2 + 2xy−y^2 = 4 at the point (1, 2).
d) Differentiate f(x) = arctan(x^2 + 1)
e) Differentiate f(x) = ln(cosh x)
Thank you!
In: Math
The following are three observations collected from treatment 1, five observations collected from treatment 2, and four observations collected from treatment 3. Test the hypothesis that the treatment means are equal at the 0.05 significance level.
| Treatment 1 | Treatment 2 | Treatment 3 |
| 8 | 3 | 3 |
| 11 | 2 | 4 |
| 10 | 1 | 5 |
| 3 | 4 | |
| 2 | ||
(a-1). State the null hypothesis and the alternate hypothesis.
Null hypothesis
H0: μ1 = μ2
H0: μ1 = μ2 = μ3
(a-2). Alternate hypothesis.
H1: Treatment means are all the same
H1: At least one pair of treatment means is not the same
What is the decision rule? (Round your answer to 2 decimal places.)
Compute SST, SSE, and SS total. (Round your answers to 2 decimal places.)
Complete an ANOVA table. (Round F, SS to 2 decimal places and MS to 3 decimal places.)
|
State your decision regarding the null hypothesis.
In: Statistics and Probability
What is the waiting time and Turnaround time of each process for each of the scheduling algorithms? [12 Marks]
|
Job |
Arrival Time |
Burst(msec) |
Priority |
| A |
0 |
6 |
3 (Silver) |
|
B |
1 |
2 |
1 (Diamond) |
|
C |
3 |
5 |
3 (Silver) |
|
D |
5 |
3 |
4 (Bronze) |
|
E |
7 |
2 |
2 (Gold) |
(a) First-Come-First-Served (FCFS) scheduling [2 Marks]
(b) Preemptive PRIORITY scheduling [2 Marks]
(c) Highest Response Ratio Next (HRRN) scheduling [2 Marks]
(d) Round Robin (RR) (quantum = 4) scheduling [2 Marks]
(e) Which of the foregoing scheduling policies provides the lowest waiting time for this set of jobs? What is the waiting time with this policy? (Show your work)
In: Computer Science
How do you find the rate constant here?
| trials | [I] | [H2O2] | [H] | temp (C) | Rate (M/s) |
| 1 | 8.53*10^-3 | 1.03*10^-1 | 0.333 | 21.5 | 5.33*10^-4 |
| 2 | 8.53*10^-3 | 1.03*10^-1 | 0.333 | 15 | 4.3*10^-4 |
| 3 | 8.53*10^-3 | 1.03*10^-1 | 0.333 | 42 | 2.17*10^-3 |
In: Chemistry
Topic: Students will be able to create skills in the use of linked lists, the stack, and the queue abstract data types, by implementing solutions to fundamental data structures and associated problems.
Add the code for the methods where it says to implement. The main class is already done. There is a sample of the output.
1. A double-ended queue, or deque, is a data structure consisting of a list of items on which the following operations are defined:
addToBack(x): insert item x on the back end of the queue
addToFront(x): insert item x on the front end of the queue
getBack(): returns the element on the back end of the queue
getFront(): returns the element on the front end of the queue
removeBack(): remove the back item from the queue
removeFront(): remove the front item from the queue
Write routines to support the deque that take O(1) time per operation. Use a doubly linked list implementation.
|
Node |
|
-int info -Node next -Node prev |
|
+Node() +int getInfo() +Node getNext() +Node getPrev() +void setInfo(int i) +void setNext(Node n) +void setPrev(Node p) |
UML class diagram:
|
Deque |
|
-int count -Node back -Node front |
|
+Deque() +void addToBack(int x) +void addToFront(int x) +DequeItem getBack() +DequeItem getFront() +boolean isEmpty() +boolean removeBack() +boolean removeFront() +String toString() |
|
DequeItem |
|
+boolean valid +int item |
|
+DequeItem() +DequeItem(boolean v, int i) |
|
Main |
|
+static void main(String[] args) +Main() |
testset.txt
IS_EMPTY
ADD_TO_BACK 1
IS_EMPTY
ADD_TO_BACK 2
ADD_TO_BACK 3
GET_BACK
GET_FRONT
ADD_TO_FRONT 4
ADD_TO_FRONT 5
ADD_TO_FRONT 6
ADD_TO_BACK 7
GET_BACK
GET_FRONT
REMOVE_FRONT
REMOVE_BACK
GET_FRONT
GET_BACK
ADD_TO_BACK 8
ADD_TO_BACK 9
ADD_TO_FRONT 10
ADD_TO_BACK 11
ADD_TO_BACK 12
ADD_TO_BACK 0
REMOVE_BACK
REMOVE_BACK
ADD_TO_BACK 0
REMOVE_FRONT
REMOVE_FRONT
REMOVE_FRONT
REMOVE_FRONT
REMOVE_FRONT
REMOVE_FRONT
REMOVE_FRONT
REMOVE_FRONT
REMOVE_FRONT
REMOVE_FRONT
REMOVE_FRONT
Deque.java
public class Deque
{
/**
* Default constructor. Sets this object as an empty deque.
*
*/
public Deque()
{
front = new Node();
back = new Node();
front.setNext(back);
back.setPrev(front);
count = 0;
}
/**
* Adds new element to the back end of the deque. The method takes O(1)
* time.
*
* @param x new element to be added to the deque.
*/
public void addToBack(int x)
{
//TO IMPLEMENT
}
/**
* Adds new element to the front end of the deque. The method takes O(1)
* time.
*
* @param x new element to be added to the deque.
*/
public void addToFront(int x)
{
//TO IMPLEMENT
}
/**
* Retrieves element on the back end of the deque. The method takes O(1)
* time.
*
* @return operation is successful: valid = true and item = element on the
* back end; operation is unsuccessful (i.e. empty deque): valid = false and
* item = dummy value
*/
public DequeItem getBack()
{
return new DequeItem(); //DUMMY CODE; TO IMPLEMENT
}
/**
* Retrieves element on the front end of the deque. The method takes O(1)
* time.
*
* @return operation is successful: valid = true and item = element on the
* front end; operation is unsuccessful (i.e. empty deque): valid = false and
* item = dummy value
*/
public DequeItem getFront()
{
return new DequeItem(); //DUMMY CODE; TO IMPLEMENT
}
/**
* Determines if deque is empty. The method takes O(1) time.
*
* @return true if deque contains no elements, false otherwise.
*/
public boolean isEmpty()
{
return false; //DUMMY CODE; TO IMPLEMENT
}
/**
* Removes element on the back end of the deque. The method takes O(1) time.
*
* @return false if removal cannot be performed (i.e. the deque is empty),
* true otherwise
*/
public boolean removeBack()
{
return false; //DUMMY CODE; TO IMPLEMENT
}
/**
* Removes element on the front end of the deque. The method takes O(1)
* time.
*
* @return false if removal cannot be performed (i.e. the deque is empty),
* true otherwise
*/
public boolean removeFront()
{
return false; //DUMMY CODE; TO IMPLEMENT
}
/**
* Constructs a String description of the deque.
*
* @return String containing the deque elements.
*/
public String toString()
{
String str = "";
Node current = front.getNext();
for (int i = 0; i < count - 1; i++)
{
str += current.getInfo() + ", ";
current = current.getNext();
}
if (count != 0)
return "Deque: [" + str + back.getPrev().getInfo() + "]";
else
return "Deque: []";
}
private int count; //number of elements in the deque
private Node back; //points to the item in the back
private Node front; //points to the item in the front
}
DequeItem.java
public class DequeItem
{
/**
* Default constructor. Sets this object to a invalid deaue item.
*
*/
public DequeItem()
{
valid = false;
item = 0;
}
/**
* Parameterized constructor.
*
* @param v value of the "valid" component of this object
* @param i value of the "item" component of this object
*/
public DequeItem(boolean v, int i)
{
valid = v;
item = i;
}
public boolean valid; //true if "item" is a valid element, false otherwise
public int item; //deque element
}
Main.java
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
/**
* Tester class.
*/
public class Main
{
public static void main(String[] args)
{
new Main();
}
/**
* Tester method.
*/
public Main()
{
Deque deque = new Deque();
File file = new File("assignment 2 test set.txt");
try
{
Scanner in = new Scanner(file);
String operation;
int item = 0;
int entryNumber = 0;
while (in.hasNextLine())
{
entryNumber++;
operation = in.next();
if (operation.equals("ADD_TO_BACK") || operation.equals("ADD_TO_FRONT"))
{
item = in.nextInt();
System.out.println("\n" + operation + " " + item);
}
else
System.out.println("\n" + operation);
DequeItem result;
switch (operation)
{
case "ADD_TO_BACK":
deque.addToBack(item);
System.out.println(deque);
break;
case "ADD_TO_FRONT":
deque.addToFront(item);
System.out.println(deque);
break;
case "GET_BACK":
result = deque.getBack();
if (result.valid)
System.out.println("Back item: " + result.item);
else
System.out.println("Cannot retrieve value, deque is empty!");
break;
case "GET_FRONT":
result = deque.getFront();
if (result.valid)
System.out.println("Front item: " + result.item);
else
System.out.println("Cannot retrieve value, deque is empty!");
break;
case "IS_EMPTY":
System.out.println(deque.isEmpty());
break;
case "REMOVE_BACK":
if (deque.removeBack())
System.out.println(deque);
else
System.out.println("Cannot remove, deque is empty!");
break;
case "REMOVE_FRONT":
if (deque.removeFront())
System.out.println(deque);
else
System.out.println("Cannot remove, deque is empty!");
break;
default:
System.out.println("Operation \"" + operation + "\" unknown at line " + entryNumber);
System.exit(1);
}
}
} catch (FileNotFoundException e)
{
System.out.println("File not found!");
System.exit(1);
}
}
}
Node.java
/**
* Implements the node of a doubly linked list of integers.
*/
public class Node
{
private int info;
private Node next;
private Node prev;
public Node()
{
//TO IMPLEMENT
}
public int getInfo()
{
return -1; //DUMMY CODE; TO IMPLEMENT
}
public Node getNext()
{
return null; //DUMMY CODE; TO IMPLEMENT
}
public Node getPrev()
{
return null; //DUMMY CODE; TO IMPLEMENT
}
public void setInfo(int i)
{
//TO IMPLEMENT
}
public void setNext(Node n)
{
//TO IMPLEMENT
}
public void setPrev(Node p)
{
//TO IMPLEMENT
}
}
Output
run:
IS_EMPTY true
ADD_TO_BACK 1 Deque: [1]
IS_EMPTY false
ADD_TO_BACK 2 Deque: [1, 2]
ADD_TO_BACK 3 Deque: [1, 2, 3]
GET_BACK Back item: 3
GET_FRONT Front item: 1
ADD_TO_FRONT 4 Deque: [4, 1, 2, 3]
ADD_TO_FRONT 5 Deque: [5, 4, 1, 2, 3]
ADD_TO_FRONT 6 Deque: [6, 5, 4, 1, 2, 3]
ADD_TO_BACK 7 Deque: [6, 5, 4, 1, 2, 3, 7]
GET_BACK Back item: 7
GET_FRONT Front item: 6
REMOVE_FRONT Deque: [5, 4, 1, 2, 3, 7]
REMOVE_BACK Deque: [5, 4, 1, 2, 3]
GET_FRONT Front item: 5
GET_BACK Back item: 3
ADD_TO_BACK 8 Deque: [5, 4, 1, 2, 3, 8]
ADD_TO_BACK 9 Deque: [5, 4, 1, 2, 3, 8, 9]
ADD_TO_FRONT 10 Deque: [10, 5, 4, 1, 2, 3, 8, 9]
ADD_TO_BACK 11 Deque: [10, 5, 4, 1, 2, 3, 8, 9, 11]
ADD_TO_BACK 12 Deque: [10, 5, 4, 1, 2, 3, 8, 9, 11, 12]
ADD_TO_BACK 0 Deque: [10, 5, 4, 1, 2, 3, 8, 9, 11, 12, 0]
REMOVE_BACK Deque: [10, 5, 4, 1, 2, 3, 8, 9, 11, 12]
REMOVE_BACK Deque: [10, 5, 4, 1, 2, 3, 8, 9, 11]
ADD_TO_BACK 0 Deque: [10, 5, 4, 1, 2, 3, 8, 9, 11, 0]
REMOVE_FRONT Deque: [5, 4, 1, 2, 3, 8, 9, 11, 0]
REMOVE_FRONT Deque: [4, 1, 2, 3, 8, 9, 11, 0]
REMOVE_FRONT Deque: [1, 2, 3, 8, 9, 11, 0]
REMOVE_FRONT Deque: [2, 3, 8, 9, 11, 0]
REMOVE_FRONT Deque: [3, 8, 9, 11, 0]
REMOVE_FRONT Deque: [8, 9, 11, 0]
REMOVE_FRONT Deque: [9, 11, 0]
REMOVE_FRONT Deque: [11, 0]
REMOVE_FRONT Deque: [0]
REMOVE_FRONT Deque: []
REMOVE_FRONT Cannot remove, deque is empty! BUILD SUCCESSFUL (total time: 0 seconds)
I already included the skeletons for most of the classes. All I need is the code for the few methods where it says implement. I would really appreciate it if this could be done by tonight. I've posted this question three times and have gotten no response.
In: Computer Science