Pre-lab 9: Working with stacks and queues

The goal of this lab is to write several small programs that make use of stacks and/or queues.

You will be using Java's Stack class, Queue interface, and LinkedList class. (LinkedList implements Queue).

1. Grouping consistency

You have probably noticed that a text editor like xemacs highlights text between grouping symbols-- () {} [] or < >-- if they match and are properly nested. In the first exercise, you will write a program 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.

This can be done with a simple algorithm that makes one pass through the string and uses a stack.

2. Conversion from infix to RPN

Polish mathematician Jan Lukasiewicz invented a notation for arithmetic where the operator comes before the operands, for example + 5 3 instead of 5 + 3. The advantage of this is that the order of operation is always unambiguous without the need for parentheses (or even precedence rules). For example, 5 * 3 - 9 is written - * 5 3 9, whereas 5 * (3 - 9) is written * 5 - 3 9. In honor of its inventor (or his nationality, at any rate), this is referred to as Polish notation. (It is also called prefix notation, in contrast to normal arithmetic notation which is thus infix.)

Reverse Polish notation is similar except that the operator is put after the operands (so it is also postfix notation). The advantage is that all the operands are then known before the operator is read, if we read the string from left to right. This notation is particularly interesting for our purposes, because a stack can be used to evaluate expressions in RPN. (Your task in the next project will be to write a calculator that evaluates expressions entered in RPN.)

In the second exercise you will write a program which takes a string (of numbers, parentheses, and arithmetic operators--no other characters, even spaces) from the command line assumed to be in infix form and, using a stack, converts it to RPN. For example,

java Exercise2 "((5*27)/(2+(3-8)))"

should print out

5 27 * 2 3 8 - + /

3. Computing capital gains

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.

In this exercise, you will be given the classes Transaction and Transactor. Transaction is a simple value class--it even has public final instance variables instead of getters. It represents a transaction: a number of shares and a price per share. The class Transactor has a public static method nextTransaction() that returns the results of a transaction using a Transaction object.

You will write a program that repeatedly calls Transactor.nextTransaction() until there are no shares left. Then you will compute the capital gain (or loss) from this set of transactions.


Thomas VanDrunen
Last modified: Tue Mar 1 14:20:39 CST 2011