Output and Dry-Run Questions in Java — ICSE Class 10 Computer Applications

public class Q5
{
    public static void main(String args[])
    {
        int i, s = 0;
        for (i = 1; i <= 5; i++)
        {
            s = s + i * i;
            System.out.println("i = " + i + ", s = " + s);
        }
        System.out.println("Final i = " + i);
        System.out.println("Final s = " + s);
    }
}

Build the table before you write a single line of output. Notice that i is declared outside the loop, so it still exists after the loop ends.

Output

i = 1, s = 1
i = 2, s = 5
i = 3, s = 14
i = 4, s = 30
i = 5, s = 55
Final i = 6
Final s = 55

The last two lines are where the marks hide. i is 6, not 5, because the loop only stops after the update has pushed it past the condition.

int a = 17, b = 5;
System.out.println(a / b);
System.out.println(a % b);
System.out.println(-17 / 5);
System.out.println(-17 % 5);
System.out.println(17 / 5.0);
System.out.println(a / b * b);

Output

3
2
-3
-2
3.4
15

Read the last line again. a / b * b is not 17. Java evaluates left to right for operators of equal precedence, so it computes 17 / 5 first, gets 3, and only then multiplies by 5 to give 15. The two lost units vanished at the division step and never came back.

The negatives follow one simple rule: the remainder takes the sign of the left-hand operand. That is why -17 % 5 is -2 and not 3.

int x = 5;
System.out.println(x++);
System.out.println(x);
System.out.println(++x);
int y = 10;
int z = y++ + ++y;
System.out.println("z = " + z);
System.out.println("y = " + y);

Output

5
6
7
z = 22
y = 12

Take z = y++ + ++y apart slowly. Java reads left to right. y++ contributes the current value 10 and quietly makes y 11. Then ++y makes y 12 first and contributes 12. So z is 10 + 12 = 22, and y finishes at 12. Students who guess “21” have added 10 + 11; students who guess “23” have added 11 + 12.

char c = 'A';
System.out.println(c + 1);
System.out.println((char)(c + 1));
System.out.println((int)'a');
double d = 7.9;
System.out.println((int) d);
System.out.println((int)(d + 0.5));
int n = 10;
System.out.println(n / 4);
System.out.println((double) n / 4);
System.out.println((double)(n / 4));

Output

66
B
97
7
8
2
2.5
2.0

The first two lines are the classic trap. c + 1 promotes 'A' to its Unicode value 65, adds 1, and prints the int 66. Only when you cast the whole sum back to char do you see the letter B.

The last two lines are the same trap wearing different clothes. (double) n / 4 casts n first, so the division is real and gives 2.5. (double)(n / 4) lets the integer division finish first, gets 2, and then dresses it up as 2.0. Same characters, different brackets, different mark.

int ch = 2;
switch (ch)
{
    case 1: System.out.println("One");
    case 2: System.out.println("Two");
    case 3: System.out.println("Three");
            break;
    case 4: System.out.println("Four");
    default: System.out.println("Default");
}
System.out.println("Done");

Output

Two
Three
Done

Control enters at case 2, prints Two, finds no break, falls into case 3, prints Three, and only then meets a break that sends it out of the switch. Four and Default are never reached.

int x = 8, y = 3;
System.out.println(x > y ? x - y : y - x);
int c = 0;
boolean r = (x < y) && (++c > 0);
System.out.println("r = " + r + ", c = " + c);
boolean r2 = (x > y) || (++c > 0);
System.out.println("r2 = " + r2 + ", c = " + c);
System.out.println(!(x == 8) + " " + (x != y));

Output

5
r = false, c = 0
r2 = true, c = 0
false true

Both logical operators are lazy. In (x < y) && (++c > 0) the left side is already false, so the whole expression cannot possibly be true and Java never evaluates the right side — which means ++c never runs and c stays 0. In (x > y) || (++c > 0) the left side is already true, so again the right side is skipped. The question is never really about the boolean; it is about the counter.

for (int i = 1; i <= 4; i++)
{
    for (int j = 1; j <= i; j++)
    {
        System.out.print(j + " ");
    }
    System.out.println();
}

Output

1 
1 2 
1 2 3 
1 2 3 4 

The inner loop is controlled by the outer counter, so row i contains exactly i numbers. The empty System.out.println() after the inner loop is the only reason the rows are separate lines at all — remove it and everything collapses into a single long line.

int n = 4;
int k = 1;
while (k <= n)
{
    System.out.print(k * k + " ");
    k = k + 1;
}
System.out.println();
int m = 0;
do
{
    System.out.print(m + " ");
    m = m + 2;
} while (m < 0);
System.out.println();

Output

1 4 9 16 
0 

The do-while condition m < 0 is false from the very start, yet 0 is still printed. That is the whole point of the construct: the body runs once before the test is ever consulted. If this had been an ordinary while, nothing would have been printed.

int n = 1234, rev = 0, d;
while (n > 0)
{
    d = n % 10;
    rev = rev * 10 + d;
    n = n / 10;
    System.out.println("d = " + d + ", rev = " + rev + ", n = " + n);
}
System.out.println("Answer = " + rev);

Output

d = 4, rev = 4, n = 123
d = 3, rev = 43, n = 12
d = 2, rev = 432, n = 1
d = 1, rev = 4321, n = 0
Answer = 4321

Three statements do all the work, and they always appear in this order: % 10 peels off the last digit, rev * 10 + d pushes it onto the answer, and / 10 shortens the number. Learn the trio as a unit and every digit-extraction question in the paper becomes the same question.

String s = "  Principal Saab  ";
String t = s.trim();
System.out.println(t.length());
System.out.println(t.indexOf('a'));
System.out.println(t.lastIndexOf('a'));
System.out.println(t.substring(4));
System.out.println(t.substring(0, 4));
System.out.println(t.replace('a', 'o'));
System.out.println(t.charAt(10));
System.out.println(t.compareTo("Principal"));
System.out.println(t.equalsIgnoreCase("PRINCIPAL SAAB"));

Output

14
7
12
cipal Saab
Prin
Principol Soob
S
5
true

trim() removes the spaces at both ends but not the one in the middle, so t is Principal Saab with 14 characters. Index 7 is the a in Principal; index 12 is the second a of Saab. compareTo returns 5 because the first nine characters match exactly and the only difference left is length: 14 minus 9.

String a = "SAAB";
String b = "SAAB";
String c = new String("SAAB");
System.out.println(a == b);
System.out.println(a == c);
System.out.println(a.equals(c));
System.out.println(a.compareTo("SAAC"));
String d = "Sa" + "ab";
System.out.println(d.equalsIgnoreCase(a));

Output

true
false
true
-1
true

a and b are two names for one shared object in the string pool, so == reports true. Writing new String("SAAB") forces a brand-new object, so a == c is false even though the letters are identical. equals ignores all of that and compares the characters, which is why it is the method you should always use for strings. compareTo("SAAC") gives −1 because 'B' is 66 and 'C' is 67.

int a[] = {4, 8, 15, 16, 23, 42};
System.out.println(a.length);
System.out.println(a[0] + a[a.length - 1]);
int s = 0;
for (int i = 0; i < a.length; i = i + 2)
{
    s = s + a[i];
}
System.out.println(s);
int m[][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int d = 0;
for (int i = 0; i < 3; i++)
{
    d = d + m[i][i];
}
System.out.println(d);
System.out.println(m[1][2] + m[2][1]);

Output

6
46
42
15
14

The step of i = i + 2 visits indices 0, 2 and 4 only, giving 4 + 15 + 23 = 42. In the matrix, m[i][i] walks the left diagonal: 1 + 5 + 9 = 15. And m[1][2] is 6 while m[2][1] is 8, because the first subscript is the row and the second is the column — swap them and you get a different element.

String w[] = {"mango", "apple", "kiwi"};
for (int i = 0; i < w.length - 1; i++)
{
    for (int j = 0; j < w.length - 1 - i; j++)
    {
        if (w[j].compareTo(w[j + 1]) > 0)
        {
            String t = w[j];
            w[j] = w[j + 1];
            w[j + 1] = t;
        }
    }
}
for (int i = 0; i < w.length; i++)
{
    System.out.print(w[i] + " ");
}
System.out.println();
System.out.println(w[0].length() + w[2].length());

Output

apple kiwi mango 
10

This is bubble sort with compareTo standing in for >. After sorting, w[0] is apple (5 letters) and w[2] is mango (5 letters), so the final line prints 10 — a number, because both operands are int. Had they been strings it would have printed 55.

public class Q13
{
    void show(int a)
    {
        System.out.println("int version: " + a);
    }
    void show(double a)
    {
        System.out.println("double version: " + a);
    }
    void show(int a, int b)
    {
        System.out.println("two ints: " + (a + b));
    }
    public static void main(String args[])
    {
        Q13 ob = new Q13();
        ob.show(5);
        ob.show(5.0);
        ob.show('A');
        ob.show(2, 3);
    }
}

Output

int version: 5
double version: 5.0
int version: 65
two ints: 5

ob.show('A') is the interesting call. There is no show(char), so Java widens char to the nearest type it can find. int is a closer fit than double, so the int version wins and prints the Unicode value 65.

public class Q12
{
    static void change(int n, int b[])
    {
        n = n * 2;
        b[0] = b[0] * 2;
    }
    public static void main(String args[])
    {
        int n = 5;
        int b[] = {5, 6};
        change(n, b);
        System.out.println("n = " + n);
        System.out.println("b[0] = " + b[0]);
    }
}

Output

n = 5
b[0] = 10

Both parameters were doubled inside the method, yet only one change is visible afterwards. A primitive such as int is passed by value: the method gets a private copy and doubling the copy leaves the original untouched. An array is an object, so what is copied is the reference — the address. Both names point at the same set of boxes, so writing into b[0] writes into the caller’s array.

System.out.println(Math.pow(2, 3));
System.out.println(Math.sqrt(144));
System.out.println(Math.round(4.5));
System.out.println(Math.round(-4.5));
System.out.println(Math.round(4.4f));
System.out.println(Math.ceil(-2.3));
System.out.println(Math.floor(-2.3));
System.out.println(Math.abs(-7));
System.out.println(Math.max(3, Math.min(8, 5)));

Output

8.0
12.0
5
-4
4
-2.0
-3.0
7
5

Math.pow and Math.sqrt always return double, so they print 8.0 and 12.0 and never 8 or 12. Math.round(-4.5) is the line that catches everyone: rounding in Java always goes towards positive infinity on a tie, so −4.5 becomes −4, not −5. And ceil means “towards the ceiling” — for a negative number that is the smaller magnitude, −2.0.

System.out.println(Character.isLetterOrDigit('#'));
System.out.println(Character.toUpperCase('p'));
System.out.println(Character.isWhitespace(' '));
System.out.println(Integer.parseInt("25") + 5);
System.out.println("25" + 5);
System.out.println(Double.parseDouble("2.5") * 2);
int a = Integer.valueOf("7");
System.out.println(a + 3);

Output

false
P
true
30
255
5.0
10

Lines four and five are the whole lesson. Integer.parseInt("25") converts the text into the number 25, so + 5 is arithmetic and gives 30. Without the conversion, "25" + 5 is string concatenation and gives 255. The + operator behaves completely differently depending on whether either side is a String.

Integer.valueOf("7") hands back an Integer object, which unboxes automatically into the int variable a. That silent conversion is what the syllabus calls unboxing; going the other way is autoboxing.

public class Q19
{
    public static void main(String args[])
    {
        int total;
        for (int i = 1; i <= 3; i++)
        {
            total = total + i;
        }
        System.out.println(total);
    }
}

What actually happens

Q19.java:8: error: variable total might not have been initialized
            total = total + i;
                    ^
Q19.java:10: error: variable total might not have been initialized
        System.out.println(total);
                           ^
2 errors

Nothing is printed, because nothing runs. A local variable gets no default value in Java — unlike an instance variable, which would quietly start at 0. The fix is one character: int total = 0;.

int a[] = new int[4];
for (int i = 0; i <= 4; i++)
{
    a[i] = i * 10;
}
System.out.println(a[3]);

What actually happens

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4

This program compiles perfectly. The trouble only appears on the fifth pass of the loop, when i is 4 and the array’s last legal index is 3. The single character at fault is the = in i <= 4; it should read i < a.length. Note that a[3] is never printed — the exception ends the program first.