<![CDATA[
Key to CSE143X Midterm, Autumn 2023 handout #17
1. Expression Value
-----------------------------------------------
8 * 2 - 2 * 3 10
87 % 10 + 28 % 5 % 2 8
1 + 2 + "3" + 4 + 5 * 6 "33430"
2 * 2.3 + 5 / 2 + 19 / 4 * 2.0 14.6
436 / 10 / 5 - 9 / 2 * 2.5 / 2 3.0
2. Parameter Mystery. The program produces the following output.
bill wants sue to buzz.
hope wants foo to bill.
bill wants sue to hope.
hope wants bill to sue.
3. Method Call Output Produced
------------------------------------------------
mystery(7); .7
mystery(246); 642.
mystery(195); .195
mystery(1234); 42.13
mystery(29548); 842.95
4. One possible solution appears below.
public void printPattern(int n) {
if (n < 0) {
throw new IllegalArgumentException();
}
if (n > 0) {
if (n == 1) {
System.out.print(".");
} else if (n / 2 % 2 == 0) {
System.out.print("[");
printPattern(n - 2);
System.out.print("]");
} else {
System.out.print("(");
printPattern(n - 2);
System.out.print(")");
}
}
}
5. before after code
-----------------------+-----------------------+-------------------------------
p->[1]->[2] | p->[1]->[2]->[3] | p.next.next = q;
| | q = null;
q->[3] | q |
-----------------------+-----------------------+-------------------------------
p->[1]->[2]->[3] | p->[1]->[3] | q = p.next;
| | p.next = p.next.next;
q | q->[2] | q.next = null;
-----------------------+-----------------------+-------------------------------
p->[1]->[2] | p->[2]->[3] | p.next.next = q;
| | ListNode temp = p.next;
q->[3]->[4] | q->[1]->[4] | p.next = q.next;
| | q = p;
| | p = temp;
| | p.next.next = null;
-----------------------+-----------------------+-------------------------------
p->[1]->[2]->[3] | p->[3]->[1] | ListNode temp = p.next.next;
| | temp.next = p;
| | q.next.next = p.next;
q->[4]->[5] | q->[5]->[2]->[4] | p.next = null;
| | p = temp;
| | q.next.next.next = q;
| | q = q.next;
| | q.next.next.next = null;
-----------------------+-----------------------+-------------------------------
6. Statement Output
------------------------------------------------------------
var1.method2(); compiler error
var2.method2(); Can 2/Can 3
var3.method2(); Can 2/Lamp 3
var4.method2(); Can 2/Clock 3
var5.method2(); compiler error
var6.method2(); Can 2/Clock 3
var1.method3(); compiler error
var2.method3(); Can 3
var3.method3(); Lamp 3
var4.method3(); Clock 3
var5.method3(); compiler error
var6.method3(); Clock 3
((Lamp)var6).method1(); runtime error
((Can)var1).method1(); compiler error
((Can)var1).method2(); Can 2/Bear 3/Can 3
((Bear)var1).method3(); Bear 3/Can 3
((Bear)var6).method1(); Bear 1
((Clock)var1).method1(); runtime error
((Clock)var4).method2(); Can 2/Clock 3
((Bear)var3).method1(); runtime error
7. One possible solution appears below.
public void removeRange(int start, int stop) {
if (start < 0 || stop > size || start > stop) {
throw new IllegalArgumentException();
}
int delta = stop - start;
for (int i = stop; i < size; i++) {
elementData[i - delta] = elementData[i];
}
size -= delta;
}
8. One possible solution appears below.
public static void reverseHalf(Stack<Integer> s) {
Queue<Integer> q = new LinkedList<>();
while (!s.isEmpty()) {
q.add(s.pop());
}
int oldSize = q.size();
for (int i = 0; i < oldSize / 2; i++) {
s.push(q.remove());
}
while (!s.isEmpty()) {
q.add(s.pop());
}
while (!q.isEmpty()) {
s.push(q.remove());
}
}
]]>