riddle ping pong elevator piston removes probability highest number wins questions

Questions

The probability that a doctor correctly diagnose a particular illness is 0.7. Given that the doctor makes an incorrect diagnosis, the probability that the patient enter a lawsuit is 0.90.

The probability that a doctor correctly diagnose a particular illness is 0.7. Given that the doctor makes an incorrect diagnosis, the probability that the patient enter a lawsuit is 0.90. What is the probability that the doctor makes an incorrect diagnosis and the patients sues?
A town has 2 fire engines operating independently. The probability that a specific engine is available when needed is 0.96.

What is the probability that neither is available when needed?
What is the probability that a fire engine is available when needed?

In: Statistics and Probability

Stack Variations-JAVA-self implemented As discussed in the section, instead of having our stack methods throw exceptions...

Stack Variations-JAVA-self implemented

As discussed in the section, instead of having our stack methods throw exceptions in the case of "erroneous" invocations, we could have the stack methods handle the situation themselves. We define the following three "safe" methods:

-boolean safePush (T element) - pushes element onto the stack; returns true if element successfully pushed, false otherwise.

-boolean safePop () - removes the top element of the stack; returns true if element successfully popped, false otherwise.

- T safeTop() - if the stack is not empty returns the top element of the stack otherwise returns null.

a) Add these operations to the ArrayBoundedStack class.

//----------------------------------------------------------------
// ArrayBoundedStack.java by Dale/Joyce/Weems Chapter 2
//
// Implements StackInterface using an array to hold the
// stack elements.
//
// Two constructors are provided: one that creates an array of a
// default size and one that allows the calling program to
// specify the size.
//----------------------------------------------------------------

package ch02.stacks;

public class ArrayBoundedStack<T> implements StackInterface<T>
{
protected final int DEFCAP = 100; // default capacity
protected T[] elements; // holds stack elements
protected int topIndex = -1; // index of top element in stack

public ArrayBoundedStack()
{
elements = (T[]) new Object[DEFCAP];
}

public ArrayBoundedStack(int maxSize)
{
elements = (T[]) new Object[maxSize];
}

public void push(T element)
// Throws StackOverflowException if this stack is full,
// otherwise places element at the top of this stack.
{
if (isFull())
throw new StackOverflowException("Push attempted on a full stack.");
else
{
topIndex++;
elements[topIndex] = element;
}
}

public void pop()
// Throws StackUnderflowException if this stack is empty,
// otherwise removes top element from this stack.
{
if (isEmpty())
throw new StackUnderflowException("Pop attempted on an empty stack.");
else
{
elements[topIndex] = null;
topIndex--;
}
}

public T top()
// Throws StackUnderflowException if this stack is empty,
// otherwise returns top element of this stack.
{
T topOfStack = null;
if (isEmpty())
throw new StackUnderflowException("Top attempted on an empty stack.");
else
topOfStack = elements[topIndex];
return topOfStack;
}

public boolean isEmpty()
// Returns true if this stack is empty, otherwise returns false.
{
return (topIndex == -1);
}

public boolean isFull()
// Returns true if this stack is full, otherwise returns false.
{
return (topIndex == (elements.length - 1));
}
}

Create a test driver application to demonstrate that the added code works correctly.

b) Add these operations to the ArrayListStack class.

//----------------------------------------------------------------------
// ArrayListStack.java by Dale/Joyce/Weems Chapter 2
//
// Implements an unbounded stack using an ArrayList.
//----------------------------------------------------------------------

package ch02.stacks;

import java.util.ArrayList;

public class ArrayListStack<T> implements StackInterface<T>
{
protected ArrayList<T> elements; // ArrayList that holds stack elements

public ArrayListStack()
{
elements = new ArrayList<T>();
}

public void push(T element)
// Places element at the top of this stack.
{
elements.add(element);
}

public void pop()
// Throws StackUnderflowException if this stack is empty,
// otherwise removes top element from this stack.
{
if (isEmpty())
throw new StackUnderflowException("Pop attempted on an empty stack.");
else
elements.remove(elements.size() - 1);
}

public T top()
// Throws StackUnderflowException if this stack is empty,
// otherwise returns top element of this stack.
{
T topOfStack = null;
if (isEmpty())
throw new StackUnderflowException("Top attempted on an empty stack.");
else
topOfStack = elements.get(elements.size() - 1);
return topOfStack;
}

public boolean isEmpty()
// Returns true if this stack is empty, otherwise returns false.
{
return (elements.size() == 0);
}

public boolean isFull()
// Returns false - an ArrayList stack is never full.
{
return false;
}

}

Create a test driver application to demonstrate that the added code works correctly.

c) Add these operations to the LinkedStack class.

//----------------------------------------------------------------------
// LinkedStack.java by Dale/Joyce/Weems Chapter 2
//
// Implements StackInterface using a linked list to hold the elements.
//-----------------------------------------------------------------------

package ch02.stacks;

import support.LLNode;

public class LinkedStack<T> implements StackInterface<T>
{
protected LLNode<T> top; // reference to the top of this stack

public LinkedStack()
{
top = null;
}

public void push(T element)
// Places element at the top of this stack.
{
LLNode<T> newNode = new LLNode<T>(element);
newNode.setLink(top);
top = newNode;
}

public void pop()
// Throws StackUnderflowException if this stack is empty,
// otherwise removes top element from this stack.
{
if (isEmpty())
throw new StackUnderflowException("Pop attempted on an empty stack.");
else
top = top.getLink();
}

public T top()
// Throws StackUnderflowException if this stack is empty,
// otherwise returns top element of this stack.
{
if (isEmpty())
throw new StackUnderflowException("Top attempted on an empty stack.");
else
return top.getInfo();
}

public boolean isEmpty()
// Returns true if this stack is empty, otherwise returns false.
{
return (top == null);
}

public boolean isFull()
// Returns false - a linked stack is never full
{
return false;
}

}

Create a test driver application to demonstrate that the added code works correctly.

In: Computer Science

Alpha and Beta are divisions within the same company. The managers of both divisions are evaluated...

Alpha and Beta are divisions within the same company. The managers of both divisions are evaluated based on their own division’s return on investment (ROI). Assume the following information relative to the two divisions:

	Case
	1		2		3			4
Alpha Division:
Capacity in units		53,000		302,000		108,000			206,000
Number of units now being sold to outside customers		53,000		302,000		84,000			206,000
Selling price per unit to outside customers	$	97	$	42	$	67		$	45
Variable costs per unit	$	58	$	21	$	41		$	29
Fixed costs per unit (based on capacity)	$	23	$	12	$	24		$	7
Beta Division:
Number of units needed annually		10,300		67,000		18,000			60,000
Purchase price now being paid to an outside supplier	$	89	$	40	$	67	*		—

*Before any purchase discount.

Managers are free to decide if they will participate in any internal transfers. All transfer prices are negotiated.

Required:

1. Refer to case 1 shown above. Alpha Division can avoid $6 per unit in commissions on any sales to Beta Division.

a. What is the lowest acceptable transfer price from the perspective of the Alpha Division?

b. What is the highest acceptable transfer price from the perspective of the Beta Division?

c. What is the range of acceptable transfer prices (if any) between the two divisions? Will the managers probably agree to a transfer?

2. Refer to case 2 shown above. A study indicates that Alpha Division can avoid $4 per unit in shipping costs on any sales to Beta Division.

a. What is the lowest acceptable transfer price from the perspective of the Alpha Division?

b. What is the highest acceptable transfer price from the perspective of the Beta Division?

c. What is the range of acceptable transfer prices (if any) between the two divisions? Would you expect any disagreement between the two divisional managers over what the exact transfer price should be?

d. Assume Alpha Division offers to sell 67,000 units to Beta Division for $39 per unit and that Beta Division refuses this price. What will be the loss in potential profits for the company as a whole?

3. Refer to case 3 shown above. Assume that Beta Division is now receiving an 6% price discount from the outside supplier.

a. What is the lowest acceptable transfer price from the perspective of the Alpha Division?

b. What is the highest acceptable transfer price from the perspective of the Beta Division?

c. What is the range of acceptable transfer prices (if any) between the two divisions? Will the managers probably agree to a transfer?

d. Assume Beta Division offers to purchase 18,000 units from Alpha Division at $57.98 per unit. If Alpha Division accepts this price, would you expect its ROI to increase, decreas

e, or remain unchanged?

4. Refer to case 4 shown above. Assume that Beta Division wants Alpha Division to provide it with 60,000 units of a different product from the one Alpha Division is producing now. The new product would require $25 per unit in variable costs and would require that Alpha Division cut back production of its present product by 30,000 units annually. What is the lowest acceptable transfer price from Alpha Division’s perspective?

In: Accounting

Alpha and Beta are divisions within the same company. The managers of both divisions are evaluated...

Alpha and Beta are divisions within the same company. The managers of both divisions are evaluated based on their own division’s return on investment (ROI). Assume the following information relative to the two divisions:

	Case
	1		2		3			4
Alpha Division:
Capacity in units		51,000		298,000		109,000			195,000
Number of units now being sold to outside customers		51,000		298,000		84,000			195,000
Selling price per unit to outside customers	$	99	$	42	$	70		$	47
Variable costs per unit	$	63	$	19	$	45		$	32
Fixed costs per unit (based on capacity)	$	25	$	10	$	29		$	9
Beta Division:
Number of units needed annually		10,500		75,000		20,000			56,000
Purchase price now being paid to an outside supplier	$	89	$	41	$	70	*		—