Canterbury QuestionBank

What is printed when the following program runs?

public class Main {
  public static boolean getTrue() {
    System.out.print("T");
    return true;
  }

  public static boolean getFalse() {
    System.out.print("F");
    return false;
  }

  public static void main(String[] args) {
    getFalse() && getFalse();
  }
}

FF

T

TF

Nothing is printed.

The first operand is false. && requires both operands to be true, so we don't bother evaluating the second.

It is desired to have an output as shown bellow as a consequence of running the following code. What would be the type of st1?

__________ st1 = new __________("Measure twice, cut once");

System.out.println(st1);

System.out.println(st1.toUpperCase());

System.out.println(st1);

Measure twice, cut once

MEASURE TWICE, CUT ONCE

Measure twice, cut once

StringBuffer

StringBuilder

All of the above is possible

What package should be imported for this code to work correctly?

ArrayList <Integer> intValues = new ArrayList<Integer> ();

public void add (){

     for (int i=0; i <50; i++ )

     intValues.add(i);

}

java.lang

java.io

java.math

Nathalin has created an integer array arr containing 5 zeros. Fill in the table:

A = 0x00123abc00, B = 0x00123abc04

A = 0x00123abc04, B = 0x00123abc04

A = 0x00123abc04, B = 0x00123abc08

A = 0, B = 0

A = 0x00123abc00, B = 0x00123abc00

arr[0] has the same addresss as arr does. arr[1] will have arr[0]'s mem address + sizeof(arr[0]), which is 4.

If we know the length of the string used in our program is almost 200, is there any difference between these following definitions in terms of performance?

StringBuilder string1 = new StringBuilder();

StringBuilder string2 = new StringBuilder(50);

StringBuilder string3 = new StringBuilder(100);

No, there is no performance difference.

Yes, the definition of string1 is better.

Yes, the definition of string2 is better.

Consider these lines of code:

txtName.SetFocus

txtName.SelStart = 0

txtName.SelLength = Len(txtName.Text)

txtName is an edit text box which is currently visible.

What is the code expected to do?

Clear the text in txtName.

Copy the text in txtName to the clipboard.

Fill txtName with text pasted from the clipboard.

Remove the highlight from all the text in txtName.

The code sets focus to the text box and by selecting the focus area from start of the text box to its end thereby highlights the contents

Depending on which delimiter is used in the following code, which output will be resulted respectively?

String input = "Keep your friends close and your enemies closer";

Scanner sc_input = new Scanner(input).useDelimiter("_______________");

while (sc_input.hasNext())

      System.out.println(sc_input.next());

sc_input.close();

I.    \\s*close\\s

II.    \\s*close\\s*

III.   \\s*close

I.

Keep your friends

and your enemies closer

II.

Keep your friends

and your enemies closer

III.

Keep your friends

and your enemies

r

I.

Keep your friends

and your enemies closer

II.

Keep your friends

and your enemies

r

III.

Keep your friends

and your enemies

r

I.

Keep your friends

and your enemies closer

II.

Keep your friends

and your enemies closer

III.

Keep your friends

and your enemies

r

Before testing an executable version of your program with data from a test file using DOS redirection, you should remove all calls to fflush from your program. Why is this necessary?

fflush is not part of the ANSI C standard.

fflush is for debugging only. It causes a run time error in an exe file.

fflush is not in any QuickC library.

fflush does not echo output to the screen.

fflush would read and ignore all remaining data in the test file, as it has already flushed the input buffer

To let the Scanner sc = new Scanner(System.in); statement works fine, which package should be imported?

java.io

java.lang

java.Scanner

Suppose we have an arbitrary number of entries that each includes a key and a value. We never need to search the entries while the rule for insertion and removal is first-in-last-out. Which data structure is proper?

one dimensional array

two dimensional array

double linked list

I have a number of different forms in my program, and have help topics explaining how each should be used. When the users presses F1, I want the appropriate help topic to appear depending on which form is currently open. What is the easiest way to achieve this?

Set the HelpContextID property of the Application object to the appropriate ID value.

Set the HelpContext property of a Common Dialog control to the appropriate ID value.

Set the HelpCommand property of a Common Dialog control to the appropriate ID value.

Rewrite the help as a number of different help files, one for each form. Use a different HelpFile property for each form.

The HelpContextID property is used to link a user interface element (such as a control, form, or menu) to a related topic in a Help file. The HelpContextID property must be a Long that matches the Context ID of a topic in a WinHelp (.hlp) or HTML Help (.chm) file.

source http://msdn.microsoft.com/en-us/library/aa261329%28v=vs.60%29.aspx

To make the following code work without any error, one of the given solutions is not right. Which one is it?

class D {

      int Diameter;

      public D(int d){

            Diameter = d;

      }

}

public class E {

      public static void main(String arg[]){

            D diam = new D();

      }

}

To omit the input argument of the constructor.

To define diam by passing an int value to constructor.

To define a null constructor.

Suppose you are writing a method in a new class. You are also writing unit test cases to demonstrate that this method works correctly. You know you have written enough test cases to demonstrate the method works as desired when?

You have written at least one test case that uses the method.

You have written at least one test case for every input value that can be given to the method.

You have written at least one test case for every output value that can be produced by the method.

You have written at least one test case for every input/output value combination that can be given to/produced by the method.

For most interesting methods, there are too many possible input values and/or output values for you to check them all.  However, checking just one input our output is insufficient for methods that do anything sophisticated.  As a result, it is often helpful to think of the different cases or "equivalence classes" of input/output values where the methods behaves similarly, and ensure you test each such group separately.  Often, writing multiple tests for each group--so that you can double-check the method's behavior "at the boundary" of the group--is especially helpful.

Is there any error in this code?

String [] firstNames = {"Neda", "Dorsa"};

int [] ages = {10, 14};

if (ages[0]>ages[1])

            if (firstNames[0]> firstNames [1])

                      System.out.print(firstNames[0] + "has the priority");

             else System.out.print("They both have the same priority");

else System.out.print(firstNames[1] + "has the priority");

Yes, wrong operator has been used for int type.

Yes, array is out of bound.

This code has no Error.

Consider the incomplete code segment below. The segment is supposed to initialize a 4 x 4 matrix as shown in this image:

final int SIZE = _________;            // line 0
 int matrix[][] = new int[SIZE][SIZE];  // line 1
 for (int i = 0; i < SIZE; i++)         // line 2
 {
    for (int j = 0; j < SIZE; j++)     // line 3
    {
        if ( _________________ )       // line 4
        {
            matrix[i][j] = 4;          // line 5
        }
        else if ( _______________ )    // line 6
        {
            matrix[i][j] = 1;          // line 7
        }
        else
        {
            matrix[i][j] = 0;          // line 8
        }
    }
 }

Select statement from the choices below that is the best choice to fill in the blank on line 0 of this code segment so that it behaves as desired.

3

5

16

None of these

The constant SIZE is used to define the width and height of the array (matrix), which is 4x4.

Given this class diagram, what best describes what happens with the code fragment above?

The code compiles and executes fine

Code fails at compile time, error in line 2

Code fails at execution time, error in line 2

Code fails at execution time, error in line 5

The code will not compile due to the error in line 5: gary's parkCar method takes a parameter of type SportsCar, but fineCar's declared type is Car.  Even though fineCar's actual type is SportsCar, the compiler will not let a variable declared as a superclass of the parameter's type be used in the method.

Line 2 has no problems, as having the actual type be a subclass of the declared type is legitimate.

Consider the incomplete code segment below. The segment is supposed to initialize a 4 x 4 matrix as shown in this image:

final int SIZE = _________;            // line 0
int matrix[][] = new int[SIZE][SIZE];  // line 1
for (int i = 0; i < SIZE; i++)         // line 2
{
    for (int j = 0; j < SIZE; j++)     // line 3
    {
        if ( _________________ )       // line 4
        {
            matrix[i][j] = 4;          // line 5
        }
        else if ( _______________ )    // line 6
        {
            matrix[i][j] = 1;          // line 7
        }
        else
        {
            matrix[i][j] = 0;          // line 8
        }
    }
}

Select statement from the choices below that is the best choice to fill in the blank on line 4 of this code segment so that it behaves as desired.

None of these

Line 4 controls where the "4" values are placed in the two-dimensional array.  They should be placed at all locations where i and j differ by 1.

Let's call the index at which an element is placed in an otherwise empty hashtable index h. With open addressing, a key-value pair may collide with another and be placed in a different location according to some defined scheme. Where may a key-value pair be placed?

at a list stored at index h

at index h or after

at index h or before

With open addressing, some sort of probing algorithm is used to resolve collisions. Probing involves stepping along from the collision index to a subsequent element whose distance is determined by some step size. This probing visits all elements of the array, if need be.

We have defined two JButton in a class and are going to handle the events by implementing ActionListener. As we know, this interface has a method called actionPerformed that we have to override it in our class. What would be the best way (i.e. object oriented approach) to listen to the events regarding both the buttons?

Override actionPerformed method twice for both the buttons.

Override actionPerformed method once, get the source of event in this method and then handle the events.

Create two separate classes, each should implements ActionListener interface. Then register each button with each classes.

Grace has written a method to pop from a stack; fill in the pre-condition.

struct node* pop(struct node **head)

{
    // pops the stack pointed to by head; does nothing to alter that node
    // PRE:
    // POST: head now points to what was the second element of the list
    struct node* to_pop = *head;
    *head = (*head)->next;
    return to_pop;
}

head != NULL

**head != NULL

to_pop != NULL

*head != NULL is the best answer of A-C as it has the closest level of detail to what is used in the code

Which of the following statements about binary search algorithms is FALSE?

The data must be sorted.

There must be a mechanism to access elements in the middle of the data structure. 

Binary search is inefficient when performed on a linked list.

Binary search takes (log n) time, worst case.

Suppose you are using a library implementation of a LinkedList.  You have only the compiled binary version of the code, but not the source code.  You want to know if the runtime complexity of the size() method is O(1).  (i.e. you want to know if the library stores the size, or if it counts each node every time size() is invoked).

Which approach(es) would tell you if the size() method is O(1)?

Insert one element and time how long the size method takes; compare this to how long the size method takes if you had inserted 100 elements. O(1) means they should be about equal.

Insert 10 billion elements and time how long the size method takes; compare this to how long the size method takes if you had inserted 100 billion elements. O(1) means they should be about equal.

B and C both work

All 3 will work

A won't work because most of what you are timing is the JVM starting up and shutting down.  In fact, just checking the time elapsed may require as many machine instructions as checking the size of a linked list of size 1.

C is also unlikely to work.  Suppose each element is a single int, which is 4 bytes (this is a lower-bound on things you can put in a collection). A billion elements is 4 billion bytes. A gigabyte is a little more than a billion bytes, so this likely fills most of your RAM (about 4GB for many laptops and desktops in 2013). 10 billion elements is about 37 GB, which will fill the memory of all but the biggest machines available. You will be timing the garbage collector and memory allocator algorithms, not the size() method.

What is returned by ’A’ < ’A Linkletter’?

False

'A'

an error

none of the above

This is a lexicographic (i.e. alphabetic) comparison, but the first String 'A' is a substring of the second String.  We fall back on the "nothing before something" principle, and return True, because when sorting Strings, nothing comes before something.  This is why the word 'a' comes before 'aardvark' in the dictionary, as well as why 'ant' comes before 'anteater' and 'the' comes before 'these' or 'then'.

Growing the array used to implement a heap so that it may hold more elements is

O(1)

O(log N)

O(N log N)

O(N²)

The order of elements in the array doesn't change any. They only need to be copied over in their original sequence, making this an O(N) operation.

Suppose you are writing software for a helpdesk. Each request is entered into the system as it arrives.

Which of the following abstract datatypes would be the best choice to store these requests? Be prepared to justify your answer. 

A Stack

A Queue

An OrderedList

A Dictionary

B and D are the two best choices. B allows you to handle the requests in the order received; D allows you the flexibility to override that order when needed, by giving certain requests a higher priority.

E is less good because although you could let a priority be the index into the Dictionary, Dictionaries aren't guaranteed to return items of the same priority in the order they were added to the Dictionary.

A is wrong, because it would guarantee that the most recent requests are always handled first. 

An argument could be made for C  -- elements could be added to the list in order of priority, following any other elements with the same priority. The needed operations will likely be less efficient than they would be with a Queue or PriorityQueue, however. 

After the assignment statement

   String word = "entropy";

what is returned by

   word.substring(2, 4);

"ntro"

"nt"

"trop"

an error

The Java String method word.substring (2, 4) returns the substring of word starting at the third character (array index 2) and ending with the fourth character (array index 4-1). 

You must store a large amount of data, and both searching and inserting new elements must be as fast as possible. What's the simplest data structure that meets your needs?

Ordered array

Linked list

Binary search tree

Self-balancing tree

Hashtables provide O(1) insertion and searching, provided collisions aren't too numerous.

Which data structure does java use when evaluates a mathematical expression in a program?

A tree

A linked list

An array

Suppose we have a Queue implemented with a circular array. The capacity is 10 and the size is 5.

Which are not legal values for front and rear?

front: 0

rear:  5

front: 7

rear:  2

front: 9

rear:  4

all of the above

There would only be 4 items in this queue, not 5.  This is easier to illustrate with a picture.  But you can sort of see the pattern by looking at the absolute value of the difference betwen all of the pairings.  B is the only one that differs by 4; the others all differ by 5.

You know exactly how much data you need to store, but there's not much of it. You do need to be able to search the collection quickly. What is the simplest data structure that best suits for your needs?

Unordered array

Linked list

Hashtable

Binary search tree

The memory needs are known, making an array a fine choice. Sorted arrays can be searched quickly with binary search.

What would be the output?

public class test {

    static int testCount;

    public test(){

        testCount ++;

    }

    public static void main(String [] Args){

        test t1 = new test();

        System.out.println(t1.testCount);

        test t2 = new test();

        System.out.println(t1.testCount + " "+ t2.testCount);

        test t3 = new test();

        System.out.println(t1.testCount+ " "+ t2.testCount+ " "+ t3.testCount);

   }

}

0

0 0

0 0 0

1

1 1

1 1 1

This is an error. testCount has never been initialized.

I have a data control, dtData, and several text boxes which are bound to it. The program user edits some of the text in one of the boxes, but makes a mistake and presses the Cancel button to undo the changes. What code should the Cancel button invoke?

dtData.Recordset.Update

dtData.Recordset.Delete

dtData.UpdateRecord

dtData.Clear

This method applies the cancel event procedure to restore the display content of the text boxes associated with the Data control without affecting the underlying recordset.

How many active object references and reachable objects will be produced by this code?

String first = new String("Dorsa");

String second = new String("Mahsa");

String third = second;

second = null;

3, 2

3, 3

2, 3

Programs implementing the "Examine All" programming pattern typically run in time:

O(n²)

O(n³)

O(n!)

O(n log₂ n)

Examine all algorithm need, in the worst case, to individually "process" each element or value in the input once.  Hence examine all algorithms exhibit a linear run time.  Examples of examine all algorithms include Find Largest, Count Odd, or, Is Sorted.

Which of the following are not legal Java identifiers?

fiveGuys

5Guys

five_guys

five guys

E is also illegal.

Which of the following choices will NOT produce the same result as the following condition?

if ( mark == 'A' && GPA > 3.5)

    System.out.println("First Class");

else if ( mark == 'A' && GPA <= 3.5)

    System.out.println("Second Class");

else if ( mark != 'A' && GPA > 3.5)

    System.out.println("Third Class");

else if ( mark != 'A' && GPA <= 3.5)

    System.out.println("Fourth Class");

if ( mark != 'A')

    if (GPA > 3.5)

        System.out.println("Third Class");

    else

        System.out.println("Fourth Class");

    else if (GPA > 3.5)

        System.out.println("First Class");

    else

        System.out.println("Second Class");

if ( GPA > 3.5)

     if (mark == 'A')

        System.out.println("First Class");

    else

        System.out.println("Third Class");

    else if (mark == 'A')

        System.out.println("Second Class");

    else

        System.out.println("Fourth Class");

if ( mark == 'A')

     if (GPA > 3.5)

        System.out.println("First Class");

    else

        System.out.println("Second Class");

    else if (GPA > 3.5)

        System.out.println("Third Class");

    else

        System.out.println("Fourth Class");

Chengcheng has an array that he would like to sort, and implements the following sorting
method in C. Which sorting algorithm is this? (code is adapted from http://en.wikibooks.org/wiki/Algorithm_implementation)

void sort_array(int a[], int length)

{
    // sorts the array a[], of length "length"
    int i, j, value;
    for(i = 1; i < length; i++)
    {
        value = a[i];
        for (j = i - 1; j >= 0 && a[j] > value; j--)
        {
            a[j + 1] = a[j];
        }
        a[j + 1] = value;
    }
}

Selection Sort

Bubble sort

Mergesort

The code is working from one end of the array to the other, sorting as it goes.

Which definition is not allowed?

firstLevel first = new firstLevel();

secondLevel second = new secondLevel();

firstLevel third = new secondLevel();

secondLevel fourth = new firstLevel();

first

second

third

William has the hash function: hash function h(k) = (sum of the digits) % 10. He wants to hash 33, 60, 24, 42 and 6.

Which collision resolution method should he chose in his implementation, if he wants to ensure that adding 80 happens in O(1) time?

Linear probing

Rth probing, R = 2

Both Rth probing (R=2) and linear probing will hash values to the 8 position -- only quadratic probing will leave that position open.

Yuchi and Rui are working on a problem: to create an array whose elements are the sum of the row and
column indices. (For example, arr[2][3] = 5, as does arr[3][2].) They’re both working off the same server
using the same compiler settings.

// Yuchi’s Code
#DEFINE N 500
---- (other code skipped) ----
int arr[N][N]; int i; int j;
for(i = 0; i < N; i++)
{
   for(j = 0; j < N; j++)
   {
       arr[i][j] = i + j;
   }
}

// Rui’s Code
#DEFINE N 500
---- (other code skipped) ----
int arr[N][N]; int i; int j;
for(i = 0; i < N; i++)
{
    for(j = 0; j < N; j++)
    {
        arr[j][i] = i + j;
    }
}

Whose code will be faster?

Rui's code

The two are identical

Yuchi's code will be slightly faster as C uses row-major order array storage.

The following method, called maxRow(), is intended to take one parameter: a List where the elements are Lists of Integer objects. You can think of this parameter as a matrix--a list of rows, where each row is a list of "cells" (plain integers). The method sums up the integers in each row (each inner list), and returns the index (row number) of the row with the largest row sum. Choose the best choice to fill in the blank on Line 5 so that this method works as intended:

public static int maxRow(List<List<Integer>> matrix)
{
    int maxVec = -1;                                // Line 1
    int maxSum = Integer.MIN_VALUE;                 // Line 2

    for (int row = 0; row < __________; row++)      // Line 3
    {
        int sum = 0;                                // Line 4
        for (int col = 0; col < __________; col++)  // Line 5
        {
            sum = sum + __________;                 // Line 6
        }
        if (___________)                            // Line 7
        {
            maxSum = __________;                    // Line 8
            maxVec = __________;                    // Line 9
        }
    }
    return maxVec;                                  // Line 10
}

The blank on line 5 controls the upper limit of the col counter.  It should represent the total number of columns in the current row, which can be retrieved with the expression matrix.get(row).size().

The scope of a variable in Java is:

The thing that allows it to see other variables;

The other variables that it can interact with

One of its instance variables

None of the above

The scope of a variable is the part of the program in which that variable can be referred to by its name.  A private instance variable in a class definition, for example, can only be referred to within that class definition.

What does a binary tree not have in common with a doubly-linked list?

If a node A points to a node B, then B will point to A

A given node will be pointed to at most one other node

Only the binary tree is hierarchical; only the linked list will have symmetric pointers.

After the following syntactically correct code is executed, where will Karel be standing and which direction will the robot be facing? How many beepers will karel be carrying? There are beepers at (2,2), (2,3), (2,4), (2,5), (2,6). (Note: a beeper at (2,5) means there is a beeper at the intersection of 2^nd street and 5^th avenue.)

def task ():
  karel = Robot (2,2,East,0);
  while (karel.nextToABeeper()):
    karel.turnLeft()
    karel.move()
    for i in range (2):
      karel.turnLeft()

    karel.move()
    karel.turnLeft()
    if (karel.nextToABeeper()):
      karel.pickBeeper()
      karel.move()

  karel.move()
  karel.turnOff()

Robot is facing East with five beepers and is located at (2,7)

Robot is facing North with five beepers and is located at (8,2)

Robot is facing East with one beeper and is located at (2,2)

Robot is facing North with one beeper and is located at (2,2)

There is a final "move" after the loop terminates, moving the robot over one block east (from (2,7) to (2,8)).

  public BallPanel extends javax.swing.JPanel {
     private Ball[] _balls;
     public BallPanel(){
        _balls = new Ball[20];
        for (int i=0;i<10;i++)
           _balls[i] = new Ball();
     }
     ...
  }

After I have instantiated a BallPanel using the above code, which of the following Java statements would work (if executed in some method of BallPanel)?  Assume Ball has a public getColor() method.

Both A and C work

Both B and C work

A doesn't work, since the possible range of a 20 element array index is 0 to 19 inclusive.

B works, even though _balls[15] was never assigned a value -- its value is set to null when the array is instantiated, and B would set _balls[0] to null

C doesn't work: since only _balls[0] to _balls[9] were assigned values, _balls[10]'s value is null, and we cannot call methods on a null instance.

So the answer is B.

Which of the following is an equivalent boolean expression for:

 NOT(A AND B)

(NOT A) AND (NOT B)

A OR B

(NOT A) AND  B

NOT(A OR B)

When applying DeMorgan's law, one distributes the NOT over both operands and then one exchanges AND's for OR's, or OR's for AND's

The following method, called maxRow(), is intended to take one parameter: a List where the elements are Lists of Integer objects. You can think of this parameter as a matrix--a list of rows, where each row is a list of "cells" (plain integers). The method sums up the integers in each row (each inner list), and returns the index (row number) of the row with the largest row sum. Choose the best choice to fill in the blank on Line 6 so that this method works as intended:

public static int maxRow(List<List<Integer>> matrix)
{
    int maxVec = -1;                                // Line 1
    int maxSum = Integer.MIN_VALUE;                 // Line 2

    for (int row = 0; row < __________; row++)      // Line 3
    {
        int sum = 0;                                // Line 4
        for (int col = 0; col < __________; col++)  // Line 5
        {
            sum = sum + __________;                 // Line 6
        }
        if (___________)                            // Line 7
        {
            maxSum = __________;                    // Line 8
            maxVec = __________;                    // Line 9
        }
    }
    return maxVec;                                  // Line 10
}

The loop on Line 5 incrementally accumulates the sum of all entries in the current row, which is held in the local variable sum.  The purpose of Line 6 is to add the current column value to this running sum.  The value of the current cell in the matrix is matrix.get(row).get(col).

The lifetime of a parameter in Java is

Really long

From when you define the method until you quit out of Eclipse

As long as the program is running

None of the above

The lifetime of a variable is the duration over which it keeps a value unless you change it.   With a parameter, its value is set when you invoke the method, and it retains that value (or what every you subsequently set it to) until you return.

Rohan has the code int len = strlen("Rohan"). What is the value of len?

0

6

8

While the \0 will be added to the end of the array, it is not included in the length calculation.

Suppose s is an instance of a stack that can store Strings, and I execute the following statements?

1. s.push("Finland");
2. s.push("is");
3. s.push("my");
4. String w = s.peek();
5. String x = s.pop();
6. s.push("home");
7. String y = s.pop();
8. String z = s.pop();

What is the value of z after executing these statements in order?

"Finland"

"my"

"home"

None of the above

After the three pushes the stack contents (from top) is ["my" "is" "Finland" ...]

4. doesn't change the stack. 

the contents of the stack are (after each numbered instruction)

5. ["is" "Finland" ...]

6. ["home" "is" "Finland" ...]

7. ["is" "Finland" ...]

8. sets z to "is", which is popped, leaving the stack as ["Finland" ...]

So B is correct.

   public class Outer extends SomeClass implements SomeInterface{
      ...
      private class Inner extends AnotherClass {
          ????
      }
   }

Suppose I define an inner class, as is abstractly illustrated by the code above.  Assuming that I do not shadow anything (by declaring or defining something in the inner class with the same name as something accessible in the outer class), what in the outer class is accessible to the code in the inner class (at ????, e.g.) ?

All protected methods and protected instance variables of the outer class

All public methods and public instance variables of the outer class

All methods and all public instance variables of the outer class

None of the above is true

The inner class is within the scope of the outer class, which means that all instance variables and public methods (including methods inherited from the outer class's ancestors). are accessible from the inner class.  

Shadowing is a problem, since there is no automatic way to refer to the instance of the outer class.

1.  public BallPanel extends javax.swing.Panel {
2.     private Ball[] _balls;
3.     public BallPanel(int numberOfBalls){
4.        _balls = new Ball[numberOfBalls];
5.        for (int i=0;i<_balls.length;i++)
6.           _balls[i] = new Ball();
7.     }
8.  }

In the above Java code, what is the value of _balls.length immediately after lines 4 and 6 (respectively)?

_balls.length is undefined

When the array is instantiated in line 4, its length is set (to numberOfBalls).  Lines 5 and 6 set the values of the array elements, but do not change the length of the array.

1.  import java.util.ArrayList;
2.  public BallPanel extends javax.swing.JPanel {
3.     private ArrayList <Ball> _moreBalls;
4.     public BallPanel(int numberOfBalls){
5.        _moreBalls = new ArrayList<Ball>();
6.        for (int i=0;i<numberOfBalls;i++)
7.           _moreBalls.add(new Ball());
8.     }
9.  }

What is the value of _moreBalls.size() immediately after lines 4 and 6 (respectively) if we invoke the BallPanel constructor? 

_moreBalls.size() is undefined

A is correct.  When you instantiate an ArrayList (in line 4) its size (the number of elements in the ArrayList) is zero because you haven't added any elements;  lines 5 and 6 add numberOfBalls elements to the ArrayList, so after that the size is numberOfBalls.

Suppose s is an instance of a stack that can store Strings, and I execute the following statements starting with s empty:

1. s.push("Iceland");
2. s.push("is");
3. String w = s.peek();
4. String x = s.pop();
5. s.push("cool");
6. String y = s.pop();
7. boolean z = s.isEmpty();

What is the value of z after executing this sequence of expressions?

None of the above

In the sequence of operations, we pushed 3 things onto the stack, and only popped 2 off (and at no point had we popped more times than we pushed).  So the stack is not empty.

Kun has a method:

struct node{
   struct node *next;
   int val;
}

void delete_root(struct node *root)

{
   free(root);
   root = NULL;
}

What is most likely to happen?

Deletes a copy of root

Deletes root

Segfault

The code frees memory it shouldn't be, and will do a core dump.

One of the key features of Object-oriented programming is encapsulation. 

Because of encapsulation, we generally have _________ instance variables and _____________ methods.

protected, private

public, private

public, public

These have nothing to do with encapsulation.

Encapsulation involves hiding the internal state of an object, in particular not allowing direct access to an object's instance variables.  We use methods to define the interactions other objects can have with an object, so the internal structure and information is not revealed to the outside.

Amr wants to use quicksort to sort the series [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]. What choice of pivot will yield the least efficient code?

The middle element of a sublist

A random element of a sublist

For a ascending sorted list, quicksort partitioning on the smallest element will be O(n^2).

Suppose you have an array of seven int values called test containing the following data:

Trace the execution of the following code:

int x = 0;
int y = 0;
for (int i = 0; i < test.length; i++)
{
    if (test[i] % 2 == 1)
    {
        y += test[i];
    }
    else
    {
        x += test[i];
    }
}

What is the value of x when this loop is done?

2

5

12

32

The loop traverses the array from left to right, and the if statement determines whether the corresponding value is odd or even.  The local variable x is used to accumulate the sum of the even numbers in the array, so x = 8 + 6 + 0 + 4 + 2 = 20.

Suppose you have an array of seven int values called test containing the following data:

Trace the execution of the following code:

int x = 0;
int y = 0;
for (int i = 0; i < test.length; i++)
{
    if (test[i] % 4 == 0)
    {
        x++;
        y += test[i];
    }
}

What is the value of x when this loop is done?

3

7

35

40

The loop traverses the array from left to right, and the if statement determines whether the corresponding value is evenly divisible by 4.  The local variable x is used to count the number of values found, so x is 4.

Suppose you have an array of seven int values called test containing the following data:

Trace the execution of the following code:

int x = 0;
int y = 0;
for (int i = 0; i < test.length; i++)
{
    if (test[i] % 4 == 0)
    {
        x++;
        y += test[i];
    }
}

What is the value of x when this loop is done?

3

4

7

35

The loop traverses the array from left to right, and the if statement determines whether the corresponding value is evenly divisible by 4. The local variable y is used to accumulate the sum of the numbers found, so y = 8 + 0 + 12 + 20 = 40.

Suppose you have an array of seven int values called test containing the following data:

Trace the execution of the following code:

int x = 0;
int y = 0;
for (int i = 0; i < test.length; i++)
{
    if (test[i] % 2 == 1)
    {
        y += test[i];
    }
    else
    {
        x += test[i];
    }
}

What is the value of y when this loop is done?

2

5

20

32

The loop traverses the array from left to right, and the if statement determines whether the corresponding value is odd or even.  The local variable y is used to accumulate the sum of the odd numbers in the array, so y = 3 + 9 = 12.

Assume that an object of the following class has just been created:

public class Unknown
{
    private int x;

    public Unknown()
    {
        x = 17;
        method1();
        method2(5);
        method3();
        System.out.println(x);      // Line D
    }

    public void method1()
    {
        --x;
        int x = this.x;
        x++;
        System.out.println(this.x); // Line A
    }

    public void method2(int x)
    {
        x++;
        System.out.println(x);      // Line B
    }

    public void method3()
    {
        --x;
        int x = 2;
        x++;
        System.out.println(x);      // Line C
    }
}

What output is produced by Line A when an instance of this class is created?

2

3

17

18

Line A prints the value of the field called x.  That field is initialized to 17 in the constructor, and then decremented on the first line of method1(), so the value printed is 16.  The increment operation in method1() applies to the local variable within the method, not the field that happens to have the same name.

True or False:

You should always catch checked exceptions!

True

This is definitely False!  Consider this code:

String s="";
try {
  BufferedReader r=new BufferedReader(new FileReader("foo.txt"));
  // read file and concatenate onto s
} catch (IOException e) {
  System.out.println("Can't read file");
}

Why are we catching this exception?  We are not doing anything useful with it.  What happens when there is an exception?  The program prints an error, but continues with an empty String s.  That's probably wrong and it makes like the file contained an empty String, which may be an illegal input.  What if this code is being use by a web service and there is not someone monitoring the printing.  What if it's running where System.out is not being captured?

It would be better if this code just crashed.

Consider the following method:

public int size() {
  XXXXXX
}

Which of the following could replace the XXXXX and be the body of the size() method for a Queue that uses a circular array implementation?

if (front==rear)
   return 0;
return rear-front;

if (front==0 && front==rear) 
   return 0;
if (front>rear) 
   return front-rear;
return rear-front;

if (front>rear) 
   return front-rear;
if (front==rear) 
   return 0;
return rear-front;

if (front==rear)
   return 0;
if (front>rear)
   return front-rear;
if (rear>front)
   return rear-front;

B, C, D all work. 

E would be correct, but it won't compile since it doesn't return a value on all paths.

Assume that an object of the following class has just been created:

public class Unknown
{
    private int x;

    public Unknown()
    {
        x = 17;
        method1();
        method2(5);
        method3();
        System.out.println(x);      // Line D
    }

    public void method1()
    {
        --x;
        int x = this.x;
        x++;
        System.out.println(this.x); // Line A
    }

    public void method2(int x)
    {
        x++;
        System.out.println(x);      // Line B
    }

    public void method3()
    {
        --x;
        int x = 2;
        x++;
        System.out.println(x);      // Line C
    }
}

What output is produced by Line B when an instance of this class is created?

3

5

17

18

Line B prints the value of the parameter called x in method2().  That parameter is given the value 5 when method2() is called from the constructor, and then the parameter itself is incremented on the first line of method2(), so the value printed is 6.

Consider the following implementation of a contains() method for a Queue in Java:

public class Queue<E> {
  private LinkedList<E> list;
  // Assume correct enqueue(),
  // dequeue(), size() methods

  public boolean contains(E e){
    for (int i=0; i<list.size(); i++) {
      if (list.get(i).equals(e)) {
        return true;
      }
    }
    return false;
  }
}

What is the runtime (big-Oh) complexity of this method?

O(1)

O(n)

O(n*log₂n)

O(2ⁿ)

This is sort of a trick question.  The get() method of a LinkedList is O(n), and we are calling this method O(n) times, so we have O(n²).

Assume that an object of the following class has just been created:

public class Unknown
{
    private int x;

    public Unknown()
    {
        x = 17;
        method1();
        method2(5);
        method3();
        System.out.println(x);      // Line D
    }

    public void method1()
    {
        --x;
        int x = this.x;
        x++;
        System.out.println(this.x); // Line A
    }

    public void method2(int x)
    {
        x++;
        System.out.println(x);      // Line B
    }

    public void method3()
    {
        --x;
        int x = 2;
        x++;
        System.out.println(x);      // Line C
    }
}

What output is produced by Line C when an instance of this class is created?

2

15

16

17

Line C prints the value of the local variable called x declared in method3().  That variable is initialized to 2 in its declaration, and then incremented on the following line of method3(), so the value printed is 3.

Suppose you have a List of seven Integer values called test containing the following data:

Trace the execution of the following code (remember that Java will automatically convert between primitive int values and Integer wrapper objects where needed):

int x = 0;
int y = 0;
for (int i = 0; i < test.size(); i++)
{
    if (test.get(i) % 6 == 0)
    {
        x++;
        y += i;
    }
}

What is the value of y when this loop is done?

5

7

14

84

The variable y is updated for each value in the array that is evenly divisible by 6--when y is updated, the position of the value (stored in i) is added to y, not the value itself.  So the final value of y is 0 + 1 + 2 + 4 + 6 = 13.

Suppose you have an array of seven int values called test containing the following data:

Trace the execution of the following code:

int x = 0;
int y = 0;
for (int i = 0; i < test.length; i++)
{
    if (test[i] % 6 == 0)
    {
        x++;
        y += i;
    }
}

What is the value of y when this loop is done?

5

7

14

84

The variable y is updated for each value in the array that is evenly divisible by 6--when y is updated, the position of the value (stored in i) is added to y, not the value itself.  So the final value of y is 0 + 1 + 2 + 4 + 6 = 13.

Suppose you have a List of seven Integer values called test containing the following data:

Trace the execution of the following code (remember that Java will automatically convert between primitive int values and Integer wrapper objects where needed):

int x = 0;
int y = 0;
for (int i = 0; i < test.size(); i++)
{
    if (test.get(i) % 6 == 0)
    {
        x++;
        y += i;
    }
}

What is the value of x when this loop is done?

0

3

4

7

The variable x is incremented for each value in the array that is evenly divisible by 6, so the final value of x after the loop is 5.

Is a O(n log₂ n) algorithm ALWAYS preferable over an O(n²) algorithm?

True

The correct answer is False, since one does not know the coeeficients for the two algorithms, nor the specific value for n.  (e.g. .00001n² vs 99999n log₂ n).  Certainly, no matter what the coefficients are, when n is sufficiently large, the quadratic algorithm will eventually become less efficient.

int a = 1;
int d = 7;
if (b > c)
{
    a = 2;
}
else
{
    d = a * 2;
}

Which of the following code fragments is equivalent to the version above? "Equivalent" means that both fragments would assign the same values to a and d, given the same values for b and c.

int a = 1;
int d = 7;
if (b < c)
{
    d = a * 2;
}
else
{
     a = 2;
}

int a = 1;
int d = 7;
if (b >= c)
{
    a = 2;
}
else
{
    d = a * 2;
} 

int a = 1;
int d = 7;
if (b > c)
{
    d = a * 2;
}
else
{
    a = 2;
}

none are equivalent

The opposite condition of (b > c) is (b <= c).  The correct answer has this opposite if test, and the two actions in the branches of the if statement in opposite positions.

Which command will tell gcc to optimize recursion so that any code that has been executed will not be executed again? (e.g. fibo(3) will only be calculated once.)

gcc fibonacci.c -o

gcc fibonacci.c --optimize

gcc fibonacci.c -g

Optimization level 3 is what is needed to avoid redundant recursive calls.

Malik is using quicksort. He has the list [3, 4, 5, 1, 0] and will be pivoting around the element 3. After partitioning, what will the list look like?

[3, 4, 5, 0, 1]

[3, 1, 0, 4, 5]

[0, 1, 3, 4, 5]

In the implementation of quicksort we used in class, all elements before the pivot are moved before the pivot; all elements after the pivot are moved after it.

What output will the following code fragment produce?

public void fn()
{
    int grade = 91;
    int level = -1;
    if (grade >= 90)
        if (level <= -2)
            System.out.println("A-level");
    else
        System.out.println("B-status");
}

A-level

"A-level"

"B-status"

no output is produced

Despite the indentation, no braces appear around the body of either if statement's branch(es). As a result, the else is associated with the second (inner) if. Since the outer if statement's condition is true, but the inner if statement's condition is false, the output is B-status.

Suppose you want to write a Python function that takes a list as a parameter and returns True if there are no instances of 3 immediately followed by a 4, and False otherwise.

So this list returns True: [ 3 5 4 ]

But this list returns false: [ 1 2 3 4 5 ].

The following code has a bug in it.  Which line contains the bug?

def no34(nums):
  for i in range(len(nums)):               #line1
    if nums[i]==3 and nums[i+1]==4:        #line2
      return False                         #line3
  return True                              #line4

line2

line3

line4

This will go over the edge of the list!  Line1 should be:

Suppose you want to write a Python function that takes a list as a parameter and returns true if there are no instances of 3 immediately followed by a 4, and false otherwise.  So this list returns True:  [ 3 5 4 ]  But this list returns false: [ 1 2 3 4 5 ].

def no34(nums):
  for i in range(len(nums)-1):
    if nums[i]==3 and nums[i+1]==4:
      return False        #line1
    else:
      return True         #line2
  return False            #line3 

What changes, if any, should be made to make this code correct

No changes are necessary; it is correct as written

switch line1 and line2 (i.e return True for line1 and return False for line 2)

switch line1 and line2 (i.e return True for line1 and return False for line 2)

and

delete line2 (take the else statement with it)

switch line2 and line3 (i.e return False for line2 and return True for line3)

The else clause should be removed.  If we don't see a 3-4, we can't conclude anything about the rest of the list.

Consider this code segment:

boolean x = false;
boolean y = true;
boolean z = true;
System.out.println( (!x || y && !z) );

What value is printed?

false

nothing, there is a syntax error

Since x is false, !x is true, forcing the entire expression to be true because of the || operator.  Remember that && has higher precedence than || for grouping.

Determine if Java would evaluate the following boolean expression as true or false, or if there is something (syntactically) wrong with the expression:

true

syntax error

Consider the value of variable y, which appears in the expression twice.  If y is false, the right subexpression must also be false, so the overall expression will be false, because of the semantics of &&. Alternatively, if y is true, the left subexpression must be false because of its inclusion of !y, which also causes the overall expression to be false. 

Consider this code segment:

boolean x = false;
boolean y = true;
boolean z = true;
System.out.println( (x && !y || z) );

What value is printed?

false

nothing, there is a syntax error

Although x is false, and !y is also false, making x && !y evaluate to false, the variable z is true, so the overall expression is true because of the || operator.  Remember that || has lower precedence than && in boolean expressions.

Suppose you have an array of seven int values called test containing the following data:

Trace the execution of the following code:

int x = 0;
int y = 0;
for (int i = 0; i < test.length; i++)
{
    if (test[i] % 6 == 0)
    {
        x++;
        y += i;
    }
}

What is the value of x when this loop is done?

0

3

4

7

The variable x is incremented for each value in the array that is evenly divisible by 6, so the final value of x after the loop is 5.

Assume that an object of the following class has just been created:

public class Unknown
{
    private int x;

    public Unknown()
    {
        x = 17;
        method1();
        method2(5);
        method3();
        System.out.println(x);      // Line D
    }

    public void method1()
    {
        --x;
        int x = this.x;
        x++;
        System.out.println(this.x); // Line A
    }

    public void method2(int x)
    {
        x++;
        System.out.println(x);      // Line B
    }

    public void method3()
    {
        --x;
        int x = 2;
        x++;
        System.out.println(x);      // Line C
    }
}

What output is produced by Line D when an instance of this class is created?

2

3

16

17

Line D prints the value of the field called x.  That field is initialized to 17 in the constructor, and then decremented on the first line of method1(), and decremented again on the first line of method3(), so by the time execution reaches the println() method call at the end of the constructor, the value printed is 15.

Dummy question: all block-model tags

blah

blah

This class has all the block-model tags checked and no others. It should produce a list of all block-model tags with the questions associated with each tag. (Note: the delimiter tags are included in case of errors). 

Consider the following partial and incomplete SpellChecker class that uses an ArrayList to hold a reference list of correctly-spelled words:

public class SpellChecker
{
    private List<String> dictionary;   // spelling storage.    // Line 1

    // assume a constructor exists that correctly instantiates and
    // populates the list (i.e. loads the dictionary for the spellchecker)

    public boolean spelledCorrectly(String word)               // Line 2
    {
        for (int counter = 0; counter < __________; counter++) // Line 3
        {
            if (word.equals(__________))                       // Line 4
            {
                return true;                                   // Line 5
            }
        }
        return false;                                          // Line 6
    }

    public void addWord(String word)                           // Line 7
    {
        if (__________) // check word is NOT already in the dictionary // Line 8
        {
            __________; // add word at end of the dictionary   // Line 9
        }
    }

    // other SpellChecker class methods would follow
}

Choose the best choice to fill in the blank on line 4 so that the code operates correctly.

The loop in spelledCorrectly() checks each word in the list called dictionary for the specified word, using counter to traverse through all positions in the list.  To retrieve a single word at the given position, use the expression dictionary.get(counter).

The following class definitions illustrates which important object-oriented programming concept?

class Animal:
    def __init__(self, name): # Constructor of the class
        self.name = name
    def talk(self): # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

Inheritance

Responsibility driven design

Tight/strong cohesion and loose coupling

None of the above.

This is the classic example of polymorphism.  Consider the following code:

animals = [Cat('Missy'), Dog('Lassie')]

for animal in animals:
    print(animal.name + ': ' + animal.talk())

# prints the following:
# Missy: Meow!
# Lassie: Woof! Woof!

Which of the following is the best definition of an algorithm?

A well-ordered collection of unambiguous and effectively computable operations that when executed produces a result and halts in a reasonably short amount of time.

A collection of unambiguous and effectively computable operations that when executed produces a result and halts in a finite amount of time.

A well-ordered collection of unambiguous and effectively computable operations that when executed produces a result.

A well-ordered collection of unambiguous and effectively computable operations.

Option B provides the best definition.  A key component is that in order to be an algorithm, it must eventually halt.

Consider the code:
strcpy(str1, "abc");

What is the value of str1?

abc

def

defabc

def is concatenated onto the end of abc

Gianluca wants to sort the array array, which has a length of length. He writes the following C code to do this. Which sorting algorithm has he implemented?

void sort_array(int *array, int length)

{
   int max, i, temp;
   while(length > 0)
   {
       max = 0;
       for(i = 1; i < length; i++)
           if(array[i] > array[max])
                max = i;
       temp = array[length-1];
       array[length-1] = array[max];
       array[max] = temp;
       length--;
   }
}

Insertion sort

Bubble sort

Mergesort

Students should take note that this code is looking for the max elements over and over again.

The worst-case time complexity of insertion sort is:

O(1)

O(n)

O(n log n)

none of the above

Consider the case where the data are in reverse order. You will need to compare element 2 with element 1 and swap them; then compare element 3 with elements 1 and 2, shift elements 1 and 2 over, and insert element 3 in the first position, and so on. Each element will be compared with all of the elements before it, resulting in a total of n(n-1)/2 comparisons. 

Bryon has dynamically allocated memory for an array named arr using malloc. Once he’s
done using arr in his program, what single line of code should he write to free the block of
memory that arr points to?

free(*arr);

free(&arr);

dealloc(arr);

dealloc(*arr);

it's free(arr)

Gisele has written a method, tabulate:

double tabulate(double (*fun)(double), double x)

{
    return (*fun)(x);
}

Write a single line of code that will calltabulate and return sin(1.0).

tabulate(sin(1.0);

tabulate(sin(1.0), 1.0);

Only sin need be provided for the first parameter.

Which of the following makes an appropriate pre-condition for this code?

double calculate_percentage(double sum, double n)
{
   // calculates and returns a percentage given a sum and a length (n)
   // <missing pre-condition>
   // POST: none
   return (sum / n) * 100;
}

PRE: sum < 100

PRE: sum != NULL and n != NULL

PRE: none

Want to avoid the divide by 0

Given the above binary tree rooted at Node A, what is the order of nodes visited by a preorder search?

A, B, C, D, E, F, G

D, B, E, A, F, C, G

D, E, B, F, G, C, A

G, F, E, D, C, B, A

A preorder search of a tree is:  visit the root, visit the left subtree, visit the right subtree.

It procedes as

Visit A

Visit left subtree: 

     Visit B (its root)

     Visit its left subtree:

          Visit D

     Visit its right subtree:

          Visit E

Visit right subtree:

    Visit C (its root)

    Visit its left subtree:

        Visit F

    Visit its right subtree:

        Visit G

The order of nodes visited corresponds to answer B

Junyoung runs the program after compiling with gcc print random number.c -Wall:

#include<stdlib.h>

int main()
{
   int x = rand();
   printf("%d\n", x);
}

What is not true about it?

GCC will give a warning since stdio.h was not included

GCC will give a warning since main does not return an int

It will only need four bytes of stack space

Rand was not seeded.

Fill in the incomplete line of code so this recursively prints the contents of the array arr:

void print_array(int *arr, int length)

{
   if(length > 0)
   {
      printf("%d\n", *arr);

      print_array(arr + 1, ____________ );

   }
}

print_array(arr + 1, 0);

print_array(arr + 1, ++length);

print_array(arr + 1, length);

Note the base case requires the length to be decreasing.

Consider the following partial and incomplete SpellChecker class that uses an ArrayList to hold a reference list of correctly-spelled words:

public class SpellChecker
{
    private List<String> dictionary;   // spelling storage.    // Line 1

    // assume a constructor exists that correctly instantiates and
    // populates the list (i.e. loads the dictionary for the spellchecker)

    public boolean spelledCorrectly(String word)               // Line 2
    {
        for (int counter = 0; counter < __________; counter++) // Line 3
        {
            if (word.equals(__________))                       // Line 4
            {
                return true;                                   // Line 5
            }
        }
        return false;                                          // Line 6
    }

    public void addWord(String word)                           // Line 7
    {
        if (__________) // check word is NOT already in the dictionary // Line 8
        {
            __________; // add word at end of the dictionary   // Line 9
        }
    }

    // other SpellChecker class methods would follow
}

Choose the best choice to fill in the blank on line 9 so that the code operates correctly.

Use the add() method to add a new value to the end of a List.

Seray is hashing the values 6, 96, 33, 77 into a hash table of size 10. Which hash function will give her no collisions?

h(k) = k % 10

h(k) = k / 10

h(k) = (k % 10) - (k / 10)

A collides on 9/96; B does not collide; C collides on 6/33; D collides on 33/77.

What does atoi("hello") return?

-1

hello

e

it wil be 0

In a hashtable that uses separate chaining to handle collisions, what, if any, restrictions should be placed on the table size?

Any number is fine, as the linear probing is guaranteed to find an element.

It should be a prime number, to ensure that in probing we will test each node.

It should be an odd number, to ensure that there's always a middle element.

With separate chaining, no probing is done. Each entry in the table is a linked list, and all items with the hash index appear in the list.

The Fibonacci sequence is 0, 1, 1, 2, 3, 5, 8, 13 ... Any term (value) of the sequence that follows the first two terms (0 and 1) is equal to the sum of the preceding two terms. Consider the following incomplete method to compute any term of the Fibonacci sequence:

public static int fibonacci(int term)
{
    int fib1 = 0;          // Line 1
    int fib2 = 1;          // Line 2
    int fibn = 0;          // Line 3

    if (term == 1)         // Line 4
    {
        return fib1;       // Line 5
    }
    if (term == 2)         // Line 6
    {
        return fib2;       // Line 7
    }

    for (__________)       // Line 8: loop to the nth term
    {
        fibn = __________; // Line 9: compute the next term
        fib1 = __________; // Line 10: reset the second preceding term
        fib2 = __________; // Line 11: reset the immediate preceding term
    }
    return fibn;           // Line 12: return the computed term
}


Choose the best answer to fill in the blank on line 9.

As described in the first part of the question, each term in the sequence is the sum of the previous two terms, so fibn = fib1 + fib2.