## Review So Far¶

The first couple weeks have gone by very quickly due to the weird fall quarter start and we thought it would be good to take stock in what we have learned so far in terms of what you need to know for the future culminating assessments.

This document shows an example practice simulated midterm with only the material that you have seen so far. We will come back and look at the rest of simulated exam as we finish more material, but we wanted to just show you what we are expecting you to be responsible for knowing with respect to the exams.

### Problem 4: Collections¶

This will involve writing a program that does some computation with some data structures. While we did introduce most of the data structures we will see on this problem, we do not list a problem here yet since you have not had a section to practice collections programming and we have one more data structure to learn before we can see lots of these problems.

### Problem 5: Stacks and Queues - `collapse`

¶

Write a method `collapse`

that takes a `Stack`

of integers as a parameter and that collapses it by replacing each successive pair of integers with the sum of the pair. For example, suppose a stack stores this sequence of values:

```
bottom [7, 2, 8, 9, 4, 13, 7, 1, 9, 10] top
```

Assume that stack values appear from bottom to top. In other words, 7 is on the bottom, with 2 on top of it, with 8 on top of it, and so on, with 10 at the top of the stack.

The first pair should be collapsed into 9 (7 + 2), the second pair should be collapsed into 17 (8 + 9), the third pair should be collapsed into 17 (4 + 13) and so on to yield:

```
bottom (9, 17, 17, 8, 19) top
```

As before, stack values appear from bottom to top (with 9 on the bottom of the stack, 17 on top of it, etc). If the stack stores an odd number of elements, the final element is not collapsed. For example, the sequence:

```
bottom (1, 2, 3, 4, 5) top
```

would collapse into:

```
bottom (3, 7, 5) top
```

with the 5 at the top of the stack unchanged.

You are to use one `Queue`

as auxiliary storage to solve this problem. You may not use any other auxiliary data structures to solve this problem, although you can have as many simple variables as you like. You also may not solve the problem recursively.

In writing your method, assume that you are using the `Stack`

class and `Queue`

interfaces with the `LinkedList`

implementations discussed in lecture. As a result, values will be stored as Integer objects, not simple ints.

### Problem 6: ArrayIntList Programming - `removeFront`

¶

Write a method `removeFront`

that takes an integer `n`

as a parameter and that removes the first `n`

values from a list of integers. For example, if a variable called `list`

stores this sequence of values:

```
[8, 17, 9, 24, 42, 3, 8]
```

and the following call is made:

```
list.removeFront(4);
```

then it should store the following values after the call:

```
[42, 3, 8]
```

Notice that the first four values in the list have been removed and the other values appear in the same order as in the original list.

You are writing a method for the `ArrayIntList`

class discussed in lecture:

```
public class ArrayIntList {
private int[] elementData; // list of integers
private int size; // current # of elements in the list
<methods>
}
```

`ArrayIntList`

methods to solve this problem. Your method should throw an `IllegalArgumentException`

if the parameter `n`

is less than 0 or greater than the number of elements in the list. Your solution must run in $\mathcal{O}(n)$ time. Info

We’ll talk about that $\mathcal{O}(n)$ notation in two weeks! Don’t worry about that yet!