The goal of this lab is to write several small programs that make use of stacks and/or queues.
In the following exercises, you may use either the stack and queue code
from class (which you can find at /cslab/class/cs245/stqu)
or Java's
Stack class
and LinkedList class,
which implements that
Queue
interface.
The three exercises below each require you to write a program from scratch in a stand-alone file.
You have probably noticed that a text editor like xemacs highlights
text between grouping symbols-- () {} [] or < >--
if they match and are properly nested.
Write a program Exercise1
which takes a string from the command line and determines
whether or not it is properly nested with respect to these four grouping symbol
pairs.
For example, the line "( a ( {b & 6 } [ 1 t ^] ~ ) )" is
properly nested;
"( a ( {b & 6 ) [ 1 t ^] ~ ) }" is not.
Since some of those grouping symbols have special meaning in
the command line, you will have to include them in quotes when you
run your program, for example
java Exercise1 "( a ( {b & 6 } [ 1 t ^] ~ ) )"
Your program may simply print "yes" or "no" to the screen.
Hint: The Stack class is generic, and you'll probably
want to use the Character wrapper type as its
type parameter.
You learned about reverse Polish notation in the description of the current project. Write a program which takes a string (of numbers, parentheses, and arithmetic operators) from the command line assumed to be in infix form and, using a stack, converts it to RPN. You may assume that the input is fully parenthesized and has no spaces. For example,
java Exercise2 "((5*27)/(2+(3-8)))"
should print out
5 27 * 2 3 8 - + /
When a person makes a profit on a purchase and eventual sale of a stock, he or she must pay taxes on the "capital gain", that is, the profit. (A capital loss can be used as a tax deduction.) However, sometimes a person purchases and sells shares of a stock over several transactions, and the capital gain depends on the interpretation of which shares were bought or sold. For example, suppose a person had the following transactions for stock of a certain company:
The total profit is (2437.50 + 10321.50) - (3000 + 3750 + 3200) = 5509. However, if a year ended after the third transaction (the first sale), then capital gains tax needed to be paid on the gain so far. But where did the 750 shares come from-- the original 1000 or the later 1500?
The standard way to compute capital gains is on a first-come-first-serve basis. Hence the 750 shares comes out of the original 1000 shares, and their original price (their basis) is 2250, and so the capital gain was 187.5. If this person then sold another 750 shares the next year without buying any more, then 250 of those shares would be the remaing shares from the original purchase, and the other 500 would come from the 1500 bought in the second purchase. If sold at $3.50 per share, this would be a capital gain of (750 * 3.50) - (250 * 3 + 500 * 2.5) = 2625 - 2000 = 625.
Copy the following files from the course public directory:
cp /cslab/class/cs245/lab9/Transaction.java . cp /cslab/class/cs245/lab9/Transactor.class .
The class Transactor has a public static method
nextTransaction() that returns the results of a transaction
using a Transaction object.
Write a program that repeatedly calls Transactor.nextTransaction()
until there are no shares left.
(The class is written so that the first transaction is a purchase,
and that after about 25 transactions it will sell all remaining shares.)
Use one or two queues to compute capital gains (or loss).
To turn in: Make a script file that, for each exercise, shows your code and a demonstration of it running. Turn in a hard copy.