Canterbury QuestionBank

Which of the following is most appropriate as the missing post-condition?

void move_north_east(int *x, int *y)

{
    // Moves a robot north-east in our coordinate system
    // by one step north and one step east
    // PRE: x != NULL, y != NULL
    // <missing post-condition>
    (*x)++;
    (*y)++;
}

POST: x != NULL, y != NULL

POST: x is incremented; y is incremented

POST: none

what x to points to is being updated, not x itself

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 10.

Since each term in the sequence is formed by adding together the previous two terms, the local variables fib1 and fib2 are used to store the previous two terms for recall in computing the next value in the sequence.  After computing the next term in the sequence, the loop moves the value of fib2 into fib1, and the value of fibn into fib2, so that the previous two terms are ready for use in the next loop iteration.

Dhruv has some recursive code that contains the base case if(left > right)

Which algorithm is he most likely to be implementing?

heapsort

insertion sort

Fibonacci

Only quicksort is usually implemented with such a base case.

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 11.

Since each term in the sequence is formed by adding together the previous two terms, the local variables fib1 and fib2 are used to store the previous two terms for recall in computing the next value in the sequence.  After computing the next term in the sequence, the loop moves the value of fib2 into fib1, and the value of fibn into fib2, so that the previous two terms are ready for use in the next loop iteration.

Polymorphism is used when different classes we are modeling can do the same thing (i.e. respond to the same method calls), and we don't know which class an object will be at compile time. In Java, this can be implemented using either inheritance or interfaces.

Choose the best reason below for choosing inheritance polymorphism

There is no defined interface that works for all of the classes that I want to allow

The classes are in the same containment hierarchy

It is the kind of polymorphism that I understand the best

If the classes are closely related in the inheritance hierarchy it should be possible to have the shared methods in some common superclass, which is close.

Given the following Java code:

if (x >= 0) {
   System.out.println("1");
} else if (x < 20) {
   System.out.println("2");
} else {
   System.out.println("3");
}
System.out.println("4");

For what integer values of x will 1 be among the values printed?

x < 0

x >= 20

All values of x

None of the above.

The first branch of the conditional statement will print "1" for any x value greater than or equal to 0.

You are looking for a method getSequence(int n, char c) that returns a String of n characters c. Which of the following will not meet your needs?

String getSequence(int n, char c) {
  String s = "";
  for (int i = 0; i < n; ++i) {
    s = s + c;
  }
  return s;
}

String getSequence(int n, char c) {
  String s = "";
  while (n > 0) {
    s += c;
  }
  return s;
}

String getSequence(int n, char c) {
  String s = "";
  for (int i = 1; i <= n; ++i) {
    s += c;
  }
  return s;
}

String getSequence(int n, char c) {
  if (n == 0) {
    return "";
  } else {
    return c + getSequence(n - 1, c);
  }
}

A char multiplied by an int produces an int, not a String. Example C doesn't even compile.

public class RecursiveMath
   ...
   public int fib (int a) {
      if (a < 2)
         return a;
      else
         return fib(a-1) + fib(a-2); 
   }
   ...
}

Given the above definition, what is the result of executing the following?

RecursiveMath bill = new RecursiveMath();
int x = bill.fib(-1);

x is set to undefined

The code does not terminate

The code cannot be executed, because it won't compile

None of the above

Since fib is called with parameter of -1, a gets bound to -1.   Since a < 2, the method returns the value of a, -1.

public class RecursiveMath
   ...
   public int fib (int a) {
      if (a < 2)
         return a;
      else
         return fib(a-1) + fib(a-2); 
   }
...
}

What is the base case for fib in the above definition?

a

fib(a) for a ≥ 2

None of the above

The base case is the version of the problem that can be solved directly, i.e. without a recursive call.

What is the difference between

struct node* linked_list_node = malloc(sizeof(struct node));

linked_list_node->val = 3;
linked_list_node->next = NULL;

and:

struct node linked_list_node;

linked_list_node.val = 3;
linked_list_node.next = NULL;

?

The first needs more memory than the second

The second is globally-accessible in the program; the first is locally accessible

There is no difference

Dynamic alloc goes on heap; static goes on stack.

Consider the code

struct capacitor{

    double capacitance;
};

If given the variable struct capacitor *cap, which of the following will NOT print the address of cap’s capacitance?

printf("%p\n", cap )

printf("%p\n", &((*cap).capacitance) )

printf("%p\n", &(cap->capacitance) )

C and D are equivalent; A is equivalent to them as capacitance is the first thing stored in the struct.

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 3 so that the code operates correctly.

The loop in spelledCorrectly() checks each word in the list called dictionary for the specified word, so the upper limit on the loop counter should be dictionary.size().  Remember that lists provide a size() method to retrieve the number of entries (the length() method is used for strings, and length as a field access is used for arrays).

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 8 so that the code operates correctly.

To check whether a given value is present in a List, use the contains() method.

1. public BallPanel extends javax.swing.JPanel {
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.    public void ballCopy () {
9.       Ball[] temp = new Ball[2 * _balls.length];
10.      for (int j=0; j< _balls.length; j++0)
11.         _temp[j] = _balls[j];
12.      _balls = temp; 
13.   }
13. ...

After executing

BallPanel myPanel = new BallPanel(10);
_myPanel.ballCopy();

Which of the following is true?

The array _balls is unchanged in myPanel

The elements of temp are copies of the elements of _balls in myPanel

None of the above

C is true.  When you call ballCopy, it instantiates an array that is twice as large as _balls, which had length 10, then sets _balls to that new array.

Consider the following method and indicate what value is displayed from the initial call statement from another method:

           System.out.println(Ackermann(2,3));

public int Ackermann(int n, int m) {
     if (n==0)
          return (m+1);
     else if (m==0)
          return (Ackermann(n-1,1));
     else 
          return (Ackermann(n-1,Ackermann(n,m-1)));
}

4

5

7

29

Ackermann's function is one of the earliest hyper-exponential recursive functions.  The key to obtaining the correct answer is in keeping which parameter is which, straight.  Maybe, rename them as "red" and "blue" (instead of n and m) to reduce confusion.

Which of the following algorithms use a divide-and-conquer strategy? (Circle all that apply.)

Insertion sort

Binary search

Linear search

A and C are correct.

1. public BallPanel extends javax.swing.JPanel {
2.    private Ball[] _balls;
3.    private Ball[] _moreBalls;
4.    public BallPanel(int numberOfBalls){
5.       _balls = new Ball[numberOfBalls];
6.       for (int i=0;i<_balls.length;i++)
7.          _balls[i] = new Ball();
8.       _moreBalls = _balls;
9.    }
10.   public Ball[] getBalls(){
11.      return _balls;
12.   }
13.   public Ball[] getMoreBalls(){
14.      return _moreBalls;
15.   }
16.  ...

Which of the following statements is true, after executing the following code

(assuming Ball has a constructor that takes a Color argument).

BallPanel myPanel = new BallPanel(5);
myPanel.getMoreBalls()[0] = new Ball(java.awt.Color.pink);

?

The array _balls in myPanel is unchanged

The array _moreBalls in myPanel is unchanged

The first element of _moreBalls in myPanel is a new Ball constructed using new Ball(java.awt.Color.pink); and is not the same as the first element of _balls in myPanel;


The code will not execute because the second line has a syntax error.

Because of line 9, both _balls and _moreBalls refer to the same array.  Therefore, if I re-assign an element in one array, the change shows up under the other.  Moreover, since it is really only one array the elements are identical, so == will be true in this case.

Consider the following function. What does it return?

public boolean nameTester(String inValue) {
    String oldValue = "mikeyg";
    return (inValue == oldValue);
}

True, regardless of the value of inValue

It depends.  If inValue is assigned the value "mikeyg," then True; otherwise False.

The == (equality operator) for objects (strings are objects in Java) returns True when both operands refer to the same object.  In this case, there are two distinct objects, who might contain the same value ("mikeyg").

Which of the following pairs of statements has two statements that are NOT equivalent?

&arr[0]; and arr;

arr[0]; and *arr;

*(arr + 1); and arr[1];

*(arr + sizeof) != *(arr) + sizeof

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 3 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 three is the upper limit for the row count, controlling how many times the outer loop repeats.  This should correspond to the number of rows in the matrix, or matrix.size().

Which of the following run-times is NOT characteristic of a feasible (or tractable) algorithm?

O(n²)

O(nlog₂ n)

O(n³)

O(log₂ n)

Feasable (or tractable) algorithms are one whose time is expressed as a polynomial in terms of the input set size n.  O(2ⁿ) is exponential in n.

Consider the code

int i, *q, *p;

p = &i;
q = p;
*p = 5;

Which of the following will print out “The value is 5.”?

printf("The value is %d", &i);

printf("The value is %d", p);

printf("The value is %d", *i);

q and p are sharing

Consider the code

int *p, *q, i;

i = 3;
q = p;
q = &i;
printf("The value of p is %d which points to %d.\n", p, *p);

Which of the following would you expect the program to print?

The value of p is 0x3eee198e1e1 which points to 3.

The value of p is 0 which points to 0.

The value of p is -29389112111 which points to 3.

p was never assigned! While p and q are sharing for a while that does not mean they are the same.

Consider the following predicate (boolean) accessor function:

def blockedWithinOneMove(self):
  if (not self.frontIsClear()):
    return (True)
  else:
    self.move()
    if (not self.frontIsClear()):
      return (True)
    else:
      return (False)

What is logically wrong with this predicate accessor function? The error is semantic and not syntactic.

If the robot is blocked, after moving forward, this function incorrectly returns True.

If the robot is not blocked, after moving forward, this function incorrectly returns False.

This function returns True when is should return False, and returns False when it should return True.

The robot moves, but does not change reverse direction.

Accessor functions need to guarantee that the program state does not change.  The robot moves forward to check for a wall, but fails to return to its starting location - which is necessary since this is an accessor method.

What value will this code print out on a 64-bit Linux machine with gcc?

int main
{
    int key = get_key("zflsbi-k#gk!2*8jc5r:/bb&fc:j\x42\x20\x46\x4e");
    printf("%d\n", key);
}

int get_key(char *bar)
{

    // PRE: bar is != NULL
    // POST: key is a happy number!

    int key = 10;

    char c[28];
    memcpy(c, bar, strlen(bar));

    assert(key <= INT_MAX && key > INT_MIN);

    return key;
}

The code will not run; the asserts will trigger

10

1109411406

3831759396

There's a stack buffer overflow due to the memcpy, so the method will return 0x4e462042 (Little Endian); in decimal that is 1313218626.

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

After line 11, what are the values of _balls.length and _moreBalls.size() respectively?

0, 0

10, 10

20, 20

10, 20

_balls.length is set to 20 when the array is instantiated (in line 6) and is independent of the array contents. 

Consider this method skeleton for findDigit():

/**
* Returns the number of times the digit d occurs in the decimal
* representation of n.
* @param n The number to consider (must be non-negative).
* @param d The digit to look for (must be 0-9).
* Returns the number of times d occurs in the printed representation
* of n.
*/
public int findDigit(int n, int d)  // Line 1
{
    int count = 0;                  // Line 2
    if (__________)                 // Line 3
    {
        __________;                 // Line 4
    }
    while (n > 0)                   // Line 5
    {
        if (n % 10 == d)            // Line 6
        {
            count++;                // Line 7
        }
        return 1;                   // Line 8
    }
    return count;                   // Line 9
}

Select the best choice to fill in the blank on line 3 in this method to produce the correct behavior.

The blank on line 3 checks a special case where the loop is never needed--when both the n passed in and the digit being search for are both zero, and the result of the method should be 1.  Therefore, the condition should be n == 0 && d == 0.

Consider this method skeleton for findDigit():

/**
* Returns the number of times the digit d occurs in the decimal
* representation of n.
* @param n The number to consider (must be non-negative).
* @param d The digit to look for (must be 0-9).
* Returns the number of times d occurs in the printed representation
* of n.
*/
public int findDigit(int n, int d)  // Line 1
{
    int count = 0;                  // Line 2
    if (n == 0 && d == 0)           // Line 3
    {
        __________;                 // Line 4
    }
    while (n > 0)                   // Line 5
    {
        if (n % 10 == d)            // Line 6
        {
            count++;                // Line 7
        }
        __________;                 // Line 8
    }
    return count;                   // Line 9
}

Select the best choice to fill in the blank on line 4 in this method to produce the correct behavior.

The test on line 3 checks a special case where the loop is never needed--when both the n passed in and the digit being search for are both zero.  In this situation, the result of the method should be 1.

What algorithm does mystery implement when passed a list of values as its argument?

def helper (listOfValues, start):
    largestSoFar = listOfValues[start]
    largestIndex = start
    current = start+1
    while (current < len(listOfValues)):
        if (listOfValues[current] > largestSoFar):
            largestSoFar = listOfValues[current]
            largestIndex = current
        current = current + 1
    return (largestIndex)

def mystery (listOfValues):
    leftEdge = 0
    while (leftEdge < (len(listOfValues)-1)):
        biggestPosition = helper (listOfValues, leftEdge)
        temp = listOfValues[biggestPosition]
        listOfValues[biggestPosition] = listOfValues[leftEdge]
        listOfValues[leftEdge] = temp

        leftEdge = leftEdge + 1

    return (listOfValues)

List Reverser

Insertion Sort

Quicksort

Bubble Sort

Helper is an implementation of Find Largest.  By repeatedly invoking Find Largest, the mystery algorithm implements selection sort

Consider the following interface definition:

public interface Mover {
   public int getX();
   public int getY();
   public void setLocation(int x, int y);
}

Choose the best answer to describe the following implementation of that interface:

public class CartoonCharacter implements Mover{
   private int x, y;
   public int getX() {return this.x;}
   public int getY() {return this.y;}
}

The class correctly implements the Mover interface because it says implements Mover.

The class does not correctly implement the Mover interface because it includes method bodies for getX and getY.

The class does not correctly implement the Mover interface because it has instance variables. 

Both B and C. 

To implement a Java interface, a class must define all the methods required by the interface (or declare itself abstract).

Note: There is no appropriate topic for this question. Suggestion: TopicSimon-Interface-Java. 

What does the following Python method do?  

Note: lov stands for list of values.

def foo (lov):
    listSize = len(lov)
    current = 1
    flag = True
    while ((current < listSize) and flag):
        if (lov[current] < lov[current-1]):
            flag = False
        current = current + 1
    return (flag)

Implements the sequential search algorithm.

Implements the selection sort algorithm.

Determines if the input list is sorted in descended order

None of the above

Flag is set to true and when two adjacent list items are found to be out of place, with respect to a non-decreasing sorted order, flag is set to false.

Consider the following class definition:

public class Mystery {

private ArrayList<Stuff> myStuff;

public Mystery() {
   myStuff = new ArrayList<Stuff> ();
}

public Stuff foo1 (int id) {
   int i = 42;

   ... code deleted...

   return myStuff[i];
}

public void foo2 (int id) {
   int i = -2;

   ... code deleted...
}

public Stuff foo3 (int id) {
   int i = 0;
   ... code deleted...
   return myStuff[i];
}

} // End of class Mystery

True or False: "i" should be upgraded to an instance variable.

True

False.  Instance variables should only be declared for persistent data.  "i" is a local variable which contains no persistent data.  Even though it is used in ALL the class's methods, that is not justification to make it an instance variable.

Consider the following Java implementation of a Stack:

public class Stack<E> extends LinkedList<E>{
  private int size=0;
  public int size(){
    return size;
  }
  public void push(E e){
    add(e);
    size+=1;
  }
  public E pop() {
    size-=1;
    return removeLast();
  }
}

What does the following code output?

Stack<Integer> q=new Stack<Integer>();
q.push(10);
q.push(20);
q.clear();  // clear() is inherited from LinkedList

System.out.println(q.size());

0

throws a Runtime exception

throws a checked exception (i.e. this code won't compile unless the code is surrounded by a try-catch block, or the method it is located inside declares that it throws the exception)

This is a classic case of using extends improperly.  Remember that inheritance in Java (or any other Object-oriented language) creates an IS-A relationship.  But, a Stack IS NOT a LinkedList, because there are things you can do to a LinkedList that you cannot do to a Stack, such as invoke clear().

Another way to think about this is that inheritance inherits ALL public methods, and allows those methods to be used by the subclass.  For this Stack class, all of those inherited methods, such as clear(), can be called to change the state of the instance, but they don't know to pay attention to the size variable.

The All-Pairs list programming pattern typically runs in time?

O(n)

O(n log₂ n)

O(1)

O(2ⁿ)

The All-Pairs programming pattern typically compares each element in a list to each other element in the list.  Hence the first element is compared against n-1 other values.  The second element is compared against n-2 other values, etc.  Hence one gets a quadratic run time.

C++ uses

call by name

call by reference

call by value

call by value-return

C++ defaults to call by value, but allows for special sytax to force call-reference.

Assume M and N are positive integers.  What does the following code print?

int sum=0;
for (int j=0; j<M; j++) {
   for (int i=0; i<N; i++) {
      sum += 1;
   }
}
System.out.println(sum);

M+N

M^N

0

none of the above

For positive integers M and N, this prints M*N

Consider the following:

public void foo (int x) {

...

}

What is x?

A global variable.

A local variable.

The actual parameter.

An instance variable.

When invoking a method, the invokation contains the actual parameters, while the variables defined in the method signature define the formal parameters.

Java uses:

call by reference

call by name

call by value-return

Java uses call by value.  If the given parameter is an object, which is really a reference, then under call by value, the formal parameter is really just an alias (additional reference) to the actual parameter object.

1. public BallPanel extends javax.swing.JPanel {
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.    public void ballCopy () {
9.       Ball[] temp = new Ball[2 * _balls.length];
10.      for (int j=0; j< _balls.length; j++0)
11.         _temp[j] = _balls[j];
12.     _balls = temp;
13.   }
13. ...

What is the purpose of the ballCopy method?

It allows the user to copy a Ball in a BallPanel

It copies data in the _balls array

It makes 2 copies of the elements in the _balls array

It swaps the data in the _balls array with the data in the temp array

It doubles the length of the _balls array.  It works by 1) instantiating temp, an array twice as large as _balls, 2) copying the data in _balls to the first half of temp, and 3) reassigning _balls to be temp.  Useful if you want to have an array that can grow bigger when it gets full.

Consider this method skeleton for findDigit():

/**
* Returns the number of times the digit d occurs in the decimal
* representation of n.
* @param n The number to consider (must be non-negative).
* @param d The digit to look for (must be 0-9).
* Returns the number of times d occurs in the printed representation
* of n.
*/
public int findDigit(int n, int d)  // Line 1
{
    int count = 0;                  // Line 2
    if (__________)                 // Line 3
    {
        __________;                 // Line 4
    }
    while (n > 0)                   // Line 5
    {
        if (n % 10 == d)            // Line 6
        {
            count++;                // Line 7
        }
        __________;                 // Line 8
    }
    return count;                   // Line 9
}

Select the best choice to fill in the blank on line 8 in this method to produce the correct behavior.

n = n % 10;

n = n - d;

n = n + d;

n = Integer.toString(n).substring(1);

The loop in this method traverses through the digits in the specified number n from right-to-left--from least significant digit to most significant.  Each iteration of the loop examines the rightmost digit that remains by using the modulo operator. To strip off and remove the least significant digit in n to prepare for the next iteration of the loop, use n = n / 10;. 

Consider the following:  When foo is executed, what is printed out?

public void foo () {

     int x = 42;

     int y = 24;

     mystery (x, y);

     System.out.println (x + "  " + y);

}

public void mystery (int var1, int var2) {
     int temp = var1; 
     var1 = var2;
     var2 = temp;
}

24 42

Java is a pass-by-VALUE language.  Hence mystery, does not accomplish the desired swapping of values.

Yuchi has the following 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;
    }
}

When he changes N to 500,000, his code crashes. Why?

There is a memory leak in the code

arr is on the heap; it has run out of heap space

With N that large, there will be at least one integer overflow in the code

arr is stored on the stack as it was statically allocated; the stack has limited space.

Suppose you have a Java array of ints. What is the worst-case time complexity of retrieving a value from a given location in the array?

O(log n)

O(n)

O(n log n)

O(n²)

Retrieving a value from an array can be done in constant time. 

In Java, what word is used to refer to the current object, or to call one constructor from another in the same class?

constructor

The reserved word this is used within a method or constructor to refer to the current object, or in the first statement of a constructor to call a different constructor in the same class.

Using the information in the UML diagram above: Suppose the statement  

appears in the body of the carryCargo method of OilTanker.  Which method does the statement invoke?

The carryCargo method defined in OilTanker

The carryCargo method defined in Truck

None of the above is true

super.carryCargo(), when called from a method in OilTanker, resolves the method starting from the superclass, that is, it treats the instance as if its actual type was Truck.  Since there is no carryCargo method defined in Truck, the one used is the one inherited from Vehicle.

Using the information in the UML diagram above, suppose an Oak prepares for winter like a Tree, but it drops its leaves first. What code should replace ??? in the following code?

public class Oak extends Tree {
   ...
   public void prepareForWinter(){
      this.dropLeaves();
      ???
   }
}

To make an Oak prepare for winter "like a tree" after dropping its leaves,  you can simply have Oak invoke Tree's prepareForWinter method.

Alternative A would work if prepareForWinter were static, but that is not indicated on this diagram (and would be really odd from a modeling perspective).

Consider the following Java method:

public xxx printGreeting() {  // 1
   System.out.println("Hello!"); // 2
} // 3

The xxx in line 1 is best replaced by:

double

float

int

String

E is the correct answer, because the method does not return a value. 

Using the information in the UML diagram above, suppose russell is a Crow, and lives in an Oak. What answer best describes what can  replace ??? in the following code?

public class Crow extends Bird {
   private Tree _myTree;
   ...
   public void battenDown(){
      ...
      _myTree.???
   }
}

or

absorbWater(n); (where n is an int variable or constant)

or

or

Any public method from Oak or anything above it in the inheritance hierarchy (with appropriate parameters)

Since you are invoking a method on a variable whose declared type is Tree, only methods appropriate to Tree can be invoked, that is, those defined in Tree or inherited from an ancestor in the inheritance hierarchy. B gives the methods from Tree that can be invoked, but methods inherited by Tree that can be used as well.  If anything in the inheritance hierarchy had public instance variables, those names could also appear in that line, but it would be bad form to have public instance variables, and wouldn't make any sense without being assigned to something.

Which of the following statements about constructors is NOT true?

All constructors must have the same name as the class they are in.

A class may have a constructor that takes no parameters.

A constructor is called when a program creates an object with the new operator.

A constructor of a subclass can call a constructor of its superclass using the Java reserved word super.

In Java, a constructor does not have a return type, unlike a method.

Given the following Boolean expression:

Which of the following is logically equivalent?

none of these

This question involves applying De Morgan's Law to factor out logical negation from a Boolean expression to find an equivalent expression.

Consider the following code segment:

if (!this.seesNet(LEFT) && this.seesFlower(AHEAD))
{
    this.hop();
    this.pick();
}
else
{
    this.turn(RIGHT);
}

Which of the following alternative versions is logically equivalent to (produce the same behavior as) the original?

if (this.seesNet(LEFT) || this.seesFlower(AHEAD))
{
    this.turn(RIGHT);
}
else
{
    this.pick();
    this.hop();
}

if (!(this.seesNet(LEFT) && !this.seesFlower(AHEAD)))
{
    this.turn(RIGHT);
}
else
{
    this.hop();
    this.pick(); 
}

if (this.seesNet(LEFT) && !this.seesFlower(AHEAD))
{
    this.turn(RIGHT);
    this.turn(RIGHT);
    this.turn(RIGHT);
}
else
{
    this.pick();
    this.hop();
}

The correct alternative has the same actions in both branches of the if statement, but in reversed positions--the true branch has moved to the false branch, and vice versa.  At the same time, the logical condition in the if statement is the opposite of the original condition (by applying De Morgan's Law).  Together, these two conditions produce a behaviorally equivalent block of code.

For any JUnit test class, when is the setUp() method executed?

Only when explicitly invoked

Once before all the test methods are executed

Only after the test class constructor method is executed

None of the above

The setUp() method is used to set up the same starting conditions for all test methods in a test class.  It is automatically executed before each test method, for every test method in the class.

In the Java language, what is the value of this expression?

Because of precedence, the division operator is applied first.  Since it is applied between two int values, the result is also an int, with any fractional part truncated.  The result of the division is therefore 1. Next, the addition is performed, giving the result: 4.2.

Which of the following is not true about an interface in Java?

Defines a type

Must not include method implementations

A class may implement more than one interface

None of these

Interfaces cannot be instantiated and cannot contain method bodies.  As a result, they may not contain constructors.

The # in the above UML diagram for Truck’s instance variable _weight means that:

_weight is measured in pounds

_weight is a private variable

_weight is a number

None of the above

The # sign is used with as a prefix for protected instance variables (or methods) in a UML class diagram.

Using the information in the UML diagram above, suppose I have a method (defined in some other class not on this diagram) with signature:

which methods can be used with parameter mobile in this method?

All of the methods of mobile’s actual class

Only move() and carryCargo()

Only move(), carryCargo(), and holdPeople(int)

Only move()

Only the methods defined in the interface PeopleMover can be used, independent of the actual type -- these are the only methods guaranteed to be present, as all we know about the variable is that it is some class that implements this interface

Suppose you have a sorted list stored in consecutive locations in a Java array. What is the worst-case time complexity of inserting a new element in the list?

O(1)

O(log n)

O(n log n)

O(n²)

In order to make room for a new element in the array, it may be necessary to shift all the other elements. 

Note: There is no skill tag for this type of question. Suggestion: Skill-Analyze-Code

Suppose you have a sorted list of numbers stored in a Java array of ints. What is the worst-case time complexity of searching for a given number in the list using binary search?

O(1)

O(n)

O(n log n)

O(n²)

Binary search in a sorted array can be implemented in O(log n) time

Note: It is likely that the instructor went over this in class. If so, perhaps it should be tagged as Skill-Pure-Knowledge-Recall.

This sorting algorithm roughly orders elements about a pivot element and then sorts the subarray of elements less than the pivot and the subarray of elements greater than the pivot.

selection sort

insertion sort

bubble sort

merge sort

Quick sort puts all elements less than the pivot element before the pivot and all elements greater after the pivot. Then it sorts these two halves.

What effect does the statement Option Explicit in the declaration section have on a Visual Basic module?

The programmer is given the option to save code before the program is run.

Global variables may be declared in the declarations section.

Procedures in the module may be accessed from other modules in the project.

Procedures in the module may NOT be accessed from other modules in the project.

"When Option Explicit appears in a file, you must explicitly declare all variables using the Dim or ReDim statements. If you attempt to use an undeclared variable name, an error occurs at compile time.

Use Option Explicit to avoid incorrectly typing the name of an existing variable or to avoid confusion in code where the scope of the variable is not clear. If you do not use the Option Explicit statement, all undeclared variables are of Object type".

Ref http://msdn.microsoft.com/en-us/library/y9341s4f%28v=vs.80%29.aspx

Consider the following class definition.

import java.util.Scanner; // 1

public class SillyClass2 { // 2
   private int num, totalRed, totalBlack; // 3
   public SillyClass2 () { // 4
      num = 0; // 5
      totalRed = 0; // 6
      totalBlack = 0; // 7
      this.spinWheel(); // 8
      System.out.print("Black: " + totalBlack); // 9
      System.out.println(" and red: " + totalRed); // 10
   } // 11

   public void spinWheel () { // 12
      Scanner kbd = new Scanner(System.in); // 13
      System.out.println("Enter 1 or 0, -1 to quit."); // 14
      num = kbd.nextInt(); // 15
      while (num >= 0) { // 16
         if (num == 0) // 17
            totalRed++; // 18
         else if (num == 1) // 19
            totalBlack++; // 20
         else System.out.println("Try again"); // 21
         System.out.println("Enter 1 or 0, -1 to quit)."); // 22
         num = kbd.nextInt(); // 23
      } // 24
      System.out.println("Thanks for playing."); // 25
   } // 26
} // 27

If line 1 is omitted, which other line(s) of code will cause compile errors?

Lines 9, 10

Lines 14, 21, 22, 25

All of the above

Importing java.util.Scanner allows us to declare, initialize, and use a Scanner object. It is not needed for println statements. 

Consider the following class definition.

import java.util.Scanner; // 1

public class SillyClass2 { // 2
   private int num, totalRed, totalBlack; // 3
   public SillyClass2 () { // 4
      num = 0; // 5
      totalRed = 0; // 6
      totalBlack = 0; // 7
      this.spinWheel(); // 8
      System.out.print("Black: " + totalBlack); // 9
      System.out.println(" and red: " + totalRed); // 10
   } // 11

   public void spinWheel () { // 12
      Scanner kbd = new Scanner(System.in); // 13
      System.out.println("Enter 1 or 0, -1 to quit."); // 14
      num = kbd.nextInt(); // 15
      while (num >= 0) { // 16
         if (num == 0) // 17
            totalRed++; // 18
         else if (num == 1) // 19
            totalBlack++; // 20
         else System.out.println("Try again"); // 21
         System.out.println("Enter 1 or 0, -1 to quit)."); // 22
         num = kbd.nextInt(); // 23
      } // 24
      System.out.println("Thanks for playing."); // 25
   } // 26
} // 27

Which sequence of inputs will cause the body of the while loop not to be executed?

0    -1

1   -1

0    1    -1

0   1   10   -1

The loop test is num >= 0, so if the first number entered is less than 0, the loop will never be executed.

Consider the following class definition:

import java.util.Scanner; // 1

public class SillyClass2 { // 2
   private int num, totalRed, totalBlack; // 3
   public SillyClass2 () { // 4
      num = 0; // 5
      totalRed = 0; // 6
      totalBlack = 0; // 7
      this.spinWheel(); // 8
      System.out.print("Black: " + totalBlack); // 9
      System.out.println(" and red: " + totalRed); // 10
   } // 11

   public void spinWheel () { // 12
      Scanner kbd = new Scanner(System.in); // 13
      System.out.println("Enter 1 or 0, -1 to quit."); // 14
      num = kbd.nextInt(); // 15
      while (num >= 0) { // 16
         if (num == 0) // 17
            totalRed++; // 18
         else if (num == 1) // 19
            totalBlack++; // 20
         else System.out.println("Try again"); // 21
         System.out.println("Enter 1 or 0, -1 to quit)."); // 22
         num = kbd.nextInt(); // 23
      } // 24
      System.out.println("Thanks for playing."); // 25
   } // 26
} // 27

Which sequence of inputs will cause line 18 not to be executed?

0   10  -1

0   1    -1

1   0   10   -1

10   1   0   -1

Answers A and C are wrong, because the first number entered (0) will cause line 18 to be executed. Answer D is wrong because the first number entered (1) will cause the while loop to be executed, and the second time through the loop, the 0 input will cause line 18 to be executed. Answer E is wrong, because the first input (10) will cause the while loop to be executed, and the third input (0) will cause line 18 to be executed. 

Consider the following class definition:

import java.util.Scanner; // 1

public class SillyClass2 { // 2
   private int num, totalRed, totalBlack; // 3
   public SillyClass2 () { // 4
      num = 0; // 5
      totalRed = 0; // 6
      totalBlack = 0; // 7
      this.spinWheel(); // 8
      System.out.print("Black: " + totalBlack); // 9
      System.out.println(" and red: " + totalRed); // 10
   } // 11
   public void spinWheel () { // 12
      Scanner kbd = new Scanner(System.in); // 13
      System.out.println("Enter 1 or 0, -1 to quit."); // 14
      num = kbd.nextInt(); // 15
      while (num >= 0) { // 16
         if (num == 0) // 17
            totalRed++; // 18
         else if (num == 1) // 19
            totalBlack++; // 20
         else System.out.println("Try again"); // 21
         System.out.println("Enter 1 or 0, -1 to quit)."); // 22
         num = kbd.nextInt(); // 23
      } // 24
      System.out.println("Thanks for playing."); // 25
   } // 26
} // 27

Which sequence of inputs will cause line 20 not to be executed?

0   1   10   -1

0   10   1   -1

1   1   10   -1

1   10   1   -1

Line A is correct because it is the only answer with no 1 in the sequence of inputs -- an input of 1 is necessary for line 20 to be executed. 

What does the following Java code print:

int sum=0;
for (int j=0; j<3; j++) {
  for (int i=0; i<4; i++) {
    sum += 1;
  }
}
System.out.println(sum);

3

4

6

8

With nested loops, the entire inner loop runs to completion one time for each iteration of the outer loop.

What does the following Java code print?

int sum=0;
for (int i=1; i<=5; i++) {
  sum += i;
}
System.out.println(sum);

0

5

10

The loop is infinte

i takes on the values 1 through 5, and each value is added to sum.  So the result is 1 + 2 + 3 + 4 + 5, or 15.

Using the information in the UML diagram above, suppose we execute the following Java statements:

     OilTanker oily = new Truck(2500);
     oily.move();

which definition of move will be executed?

The one defined in Truck

The one defined in Vehicle

The one defined in OilTanker

The one defined in PeopleHauler

The declared type of an object has to be the same as or more abstract than the actual type.  It would have been ok to say

since Truck is a superclass of OilTanker, but not vice-versa as in the above code, which will not compile.


The simplified UML diagram above shows the relationships among classes Bird, Crow, and Duck that are implemented in Java.

Suppose Bird has a fly(Location) method, but we want ducks to fly differently.  What is the best way to do this?

Define a method duckFly(Location) and use that for Ducks

Put a conditional statement in Bird's  fly(Location) method that checks for whether the object is a Duck

(eg if (this instanceof Duck) followed by specialized duck flying code)

Make fly(Location) an abstract method in Bird and define a fly(Location) method in Duck

All of the above are equally good answers

All of the above answers sort of work, but B is the best -- it allows Duck (and all of Duck's descendents) to have a different fly method without affecting any other classes.   A would require invoking duckFly on Ducks to get the appropriate behavior, and fly would give the wrong behavior if invoked on Ducks.  C would work, although it doesn't use the built-in method resolution capability of Java and would break down pretty fast if other Bird subclasses fly differently. D would require all subclasses of Bird to define their own fly method (and you could no longer instantiate Bird).

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 6 of this code segment so that it behaves as desired.

None of these

The condition on line 6 controls which locations in the array are set to the value 1.  The 1's in the array should appear along the identity diagonal, where i and j have the same value.

Given the code

int x = 27;
 int y = 12; 

the value of the expression  x <= y < x + y    is:

true

false

1

0

In Java, addition has a higher precedence than the relational operators. So the first step is to plug in the values and compute the results of the addition. Starting with the original expression x <= y < x + y, this yields  27 <= 12 < 39. Relational operators are evaluated from left to right in Java, so the next step is to evaluate 27 <= 12, which is true. So we now have the expression true < 39, which is invalid. 

Which of the following is a list of syntactically legal Java class names?

R2D2, Chameleon, public

R2D2, Chameleon, 23skidoo

r2d2, chameleon, public

none of the above

To compile, Java class names must start with a letter or an underscore, followed by zero or more letters, numbers, or underscores. In addition, a class name must not be one of the Java reserved words, such as public. 

Consider this section of code.

int a = 3, b = 4, c = 5;

x = a * b <= c

The expression contains an arithmetic operator, an assignment operator and a relational operator. Which is which?

Arithmetic Assignment Relational

    =                   *                    <=

Arithmetic Assignment Relational

 *                     <=                  =

Arithmetic Assignment Relational

<=                 *                     =

Arithmetic Assignment Relational

 <=                  =                   *

operators are: multiply, assignment and less than or equal

Consider the following short program:

#include <stdio.h>

void f1(void);

int a;

void main(void)

{

     int b;

     a = b = 1;

     f1();

     printf("%d %d", a, b);

}

void f1(void)

{

     int b = 3;

     a = b;

}

A C program can use the same variable name in a number of places, as shown in this example, but it is always possible to work out to which actual variable a particular instance refers. This is described as

the rules of assignment

 block structuring

the rules of precedence

the data type of a variable

Scope is the largest region of program text in which a name can potentially be used without qualification to refer to an entity; that is, the largest region in which the name potentially is valid. Broadly speaking, scope is the general context used to differentiate the meanings of entity names. The rules for scope combined with those for name resolution enable the compiler to determine whether a reference to an identifier is legal at a given point in a file.

The scope of a declaration and the visibility of an identifier are related but distinct concepts. Scope is the mechanism by which it is possible to limit the visibility of declarations in a program. The visibility of an identifier is the region of program text from which the object associated with the identifier can be legally accessed. Scope can exceed visibility, but visibility cannot exceed scope. Scope exceeds visibility when a duplicate identifier is used in an inner declarative region, thereby hiding the object declared in the outer declarative region. The original identifier cannot be used to access the first object until the scope of the duplicate identifier (the lifetime of the second object) has ended.

Source http://publib.boulder.ibm.com/infocenter/lnxpcomp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8l.doc%2Flanguage%2Fref%2Fzexscope_c.htm

What is the correct way to declare pFile as a file pointer?

FILE pFile*;

*FILE pFile;

*pFile FILE;

pFile *FILE;

FILE *

For C File I/O you need to use a FILE pointer, which will let the program keep track of the file being accessed. (You can think of it as the memory address of the file or the location of the file).

Source http://www.cprogramming.com/tutorial/cfileio.html

For other examples also refer http://stackoverflow.com/questions/589389/what-is-the-correct-way-to-declare-and-use-a-file-pointer-in-c-c

What will be displayed by

static char szName[] = "Peter";

printf("%d", strcmp("Peter", szName));

A negative number such as -1

 A positive number such as 1

 5

Nothing - it gives a syntax error and will not compile.

DescriptionThe C library function int strcmp(const char *str1, const char *str2) compares the string pointed to by str1 to the string pointed to by str2.

DeclarationFollowing is the declaration for strcmp() function.

int strcmp(constchar*str1,constchar*str2)Parametersstr1 -- This is the first string to be compared.

str2 -- This is the second string to be compared.

Return ValueThis function returned values are as follows:

if Return value if < 0 then it indicates str1 is less than str2

if Return value if > 0 then it indicates str2 is less than str1

if Return value if = 0 then it indicates str1 is equal to str2

As the strings "Peter" are equal in this instance the value returned is 0

source: http://www.tutorialspoint.com/c_standard_library/c_function_strcmp.htm

Consider the following short program, which does not meet all institutional coding standards:

void vCodeString(char szText[ ]); /* First line */

#include <stdio.h>

#include <string.h>

#define MAX_LEN 12

int main(void)

{

     char szData[MAX_LEN];

     printf("Enter some text to code: ");

     scanf("%s", szData);

     vCodeString(szData); /* Line 8 */

     printf("Coded string is %s\n", szData);

}

void vCodeString(char szText[ ])

{

     int i = -1;

     while(szText[++i])

     {

          szText[i] += (char)2;

     }

}

Knowing that scanf does not read beyond a space in the input, I try the routine by typing in Hello there when it asks me for some text. What is output after "Coded string is “?

Nothing

Hello

Hello there

Jgnnq vjgtg

The vCodeString function converts the input by incrementing the next two alphabetical letters for each character passed to it from the szData array containing the the "hello" substring after which the scanf function had haled on meeting the delimiting space character

Consider the following short program, which does not meet all institutional coding standards:

void vCodeString(char szText[ ]); /* First line */

#include <stdio.h>

#include <string.h>

#define MAX_LEN 12

int main(void)

{

     char szData[MAX_LEN];

     printf("Enter some text to code: ");

    scanf("%s", szData);

    vCodeString(szData); /* Line 8 */

     printf("Coded string is %s\n", szData);

}

void vCodeString(char szText[ ])

{

     int i = -1;

     while(szText[++i])

     {

            szText[i] += (char)2;

     }

}

Why is there no address operator (&) before szData in the scanf line?:

Parameters are passed to scanf by value, not by reference.

scanf takes only inward parameters so does not need the &

szData is an array so it does not have an address.

Variables of type char cannot use the address operator.

On declaration of a variable a space in memory is reserved for its storage.  Here szData is an array of type char which has already been defined in the program and a memory location has been allocated to it

Consider the following short program, which does not meet all institutional coding standards:

void vCodeString(char szText[ ]); /* First line */

#include <stdio.h>

#include <string.h>

#define MAX_LEN 12

int main(void)

{

     char szData[MAX_LEN];

     printf("Enter some text to code: ");

     scanf("%s", szData);

     vCodeString(szData); /* Line 8 */

     printf("Coded string is %s\n", szData);

}

void vCodeString(char szText[ ])

{

     int i = -1;

     while(szText[++i])

     {

              szText[i] += (char)2;

     }

}

The first line is:

an array declaration

a macro definition

a function call

a function definition

A function prototype or function interface in C, Perl, PHP or C++ is a declaration of a function that omits the function body but does specify the function's return type, name, arity and argument types. While a function definition specifies what a function does, a function prototype can be thought of as specifying its interface. [Source "Function prototype" Wikipedia]. Note the function is called from Main at line 8 and defined at line 11.

What will be printed by this code?

      public static void main(String [] args){

            int number = 6;

            int secondNumber = changeNumber (number);

            System.out.print(number + " " + secondNumber);

      }

      public static int changeNumber(int number){

            number = 12;

            return number;

      }

6  6

12  6

12  12

What will be written in the gaps from top to bottom and left to right respectively to create a correct program.

public static void main(String [] args){

        double n1 = 1.5;

        double n2 = 2;

        ........ returnValue = compute ( n1 , n2);

        System.out.print(returnValue);

}

public static ....... compute (...... a , ...... b){

         return (int) (a+b);

}

double int double double

int int double int

double int double int

"The value when iVal is divided by 10" would be coded as:

iVal % 10

 iVal & 10

 iVal == 10

iVal | 10

Expresses the value of a variable using the division operator and the divisor (here 10)

Which of the following assertions about methods is correct?

The body of a method must contain at least one return statement.

A method must return a value.

A method invocation must contain at least one argument.

None of the above.

(a) and (b) are true of functions, but not of Java methods in general. (c) is incorrect. Methods in general and functions specifically can be written with or without parameters. (d) is correct: methods without a return statement can't be on the right-hand side of an assignment statement, because they don't have a value. And if (d) is correct, (e) must be wrong. 

Given the input "Click & Clack", what is the output of line 16 of the following Java code?

System.out.println("Enter a string: ");
String input = kbd.nextLine();
String a = "";
String letter = "";
int d = 0;
int r = 1;
String englishAlphabet = "abcdefghijklmnopqrstuvwxyz";
for (int i = 0; i < englishAlphabet.length(); i++) {
   letter = englishAlphabet.substring(i,i+1);
   if (input.contains(letter)){
      a = letter + a;
   } else {
      d++;
   }
}
System.out.println("String a is: " + a); //line 16
System.out.println("int d is: " + d); // line 17

ClickClack

kcalkcil

acikl

None of the above.

This code checks all the letters in the lower-case alphabet to see which ones appear in the input, and concatenates them into a string where each letter appears once, in reverse alphabetical order. The resulting string is output in line 16.

What should be done to initialize counter to one in main method?

class C {

      private int counter;

}

public class F {

      public static void main(String arg[]){

      }

}

c.counter = 1;

C c = new C();

c.counter = 1;

Change the definition of counter as follow:

private int counter = 1;

Note: This question ask you t initialize the varibale in main method.

Given the code:

if (x >= 0)
   System.out.println("1");
else if (x < 20)
   System.out.println("2");
else
   System.out.println("3");
System.out.println("4");

for what integer values of x will 3 be among the values printed?

x < 0

x >= 0

x < 20

All values of x

The if-condition is true for all values of x >= 0; the if-else condition is true for all values of x < 0. So that doesn't leave any possible values for the else-clause.

Given the code:

if (x >= 0)
   System.out.println("1");
else if (x < 20)
   System.out.println("2");
else
   System.out.println("3");
System.out.println("4");

for what integer values of x will 4 be among the values printed?

x < 0

x >= 0

x >= 20

None of the above.

The final println statement is outside the conditional, so it is printed whatever the value of x is. 

After the assignments a = true and b = true, what is returned by
(! a || b) && (a || ! b)

?

false

 1

0

An error.

Substituting the assigned values for a and b (both true)  into the original expression

   (! a || b) && (a || ! b)

we get

   (! true || true) && (true || ! true)

In Java, evaluating what's inside the parentheses has higher precedence than any of the other operators here. Inside the parentheses, logical not (!) takes precedence over logical or (||). Evaluating the not's first, we get

   (false || true)  && (true || false) 

Next, evaluate the or's, and we get:

   true && true

which gives us

   true

What is the value of the expression

True

"J R R Tolkien"

An error.

None of the above.

The compareTo method when called on a String object with a String parameter, returns true if the first String is before the second in alphabetical order. Otherwise it returns false. 

The simplified UML diagram above shows the relationships among classes Bird, Crow, and Duck.

Suppose Russell is an instance of Crow and Howard is an instance of Duck.

Which of the following is incorrect?

Howard is an instance of Bird

Russell has the capabilities and attributes of a Bird

Bird is the superclass of Duck

All Bird attributes are shared by Russell and Howard

A useful way to look at classes and instances is to use sets: a class describes a set of instances that share the same attributes and capabilities, and instantiating from a set produces a member of that set.  From this perspective, a class's superclass is a superset of that class, defined by attributes and capabilities that are subsets of those of the class.  So: all instances of a class are instances of all of its class's ancestors, and all instances of a class share the attributes and capabilities of that class.  So all but B are correct; B is incorrect because Crow is not an instance.

What is the value of the expression

false

"J"

an error

none of the above

The compareTo method when called on a String object with a String parameter, returns true if the first String is before the second in alphabetical order. Otherwise it returns false.

The simplified UML diagram above shows the relationships among Java classes Bird, Crow, and Duck.

Suppose Russell is an instance of Crow and Howard is an instance of Duck.

Which of the following is not necessarily true?

Crows and Ducks inherit from Birds

Crow is a subclass of Bird

Bird is a superclass of Duck

Bird is more general than Duck

Howard and Russell are instances of different classes  (Duck and Crow), each of which is a subclass of Bird.  If neither Crow nor Duck define any methods, then Howard and Russell will have the same methods (i.e. capabilities) as Bird.

After the assignment statement
   String word = "entropy";
what is returned by
   word.substring(2);

?

"en"

"entropy"

An error

None of the above

word.substring(n) returns the substring of word that starts at index n and ends at the end of the String.

After the assignment statement
   String word = "entropy";
what is returned by
   word.substring(-1);

"e"

"entropy"

the empty String

none of the above

When this code is executed, it throws a StringIndexOutOfBounds exception. 

Given the input "Click & Clack", what is the output of line 17 of the following Java code?

System.out.println("Enter a string: ");
String input = kbd.nextLine();
String a = "";
String letter = "";
int d = 0;
int r = 1;
String englishAlphabet = "abcdefghijklmnopqrstuvwxyz";
for (int i = 0; i < englishAlphabet.length(); i++) {
   letter = englishAlphabet.substring(i,i+1);
   if (input.contains(letter)){
      a = letter + a;
   } else {
      d++;
   }
}
System.out.println("String a is: " + a); //line 16
System.out.println("int d is: " + d); // line 17

16

18

22

None of the above.

d contains a count of the number of lower-case letters that do *not* appear in the input string. Since there are 5 letters that do appear, the answer is 26-5 or 21. 

Fill in the gap to create a correct program.

public static void main(String [] args){

        final int firstDim = 2;

        final int secondDim = 3;

        read(firstDim, secondDim);

}

public static __________ read (int dim1, int dim2){

        int [][] array = new int[dim1][dim2];

        Scanner sc = new Scanner(System.in);

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

                 for (int j = 0; j < dim2; j++)

                         array[i][j] = sc.nextInt();

       return array;

}

void

int

int []

Suppose you have a Java array of ints. Which of the following operations can be performed in constant (O(1)) time? (Circle all correct answers.)

 Insert a number at a given position.

Print out the numbers in the array

Compute the sum of all the numbers in the array

Sort the numbers in the array

Note: Only one answer can be marked as correct here, but both A and B are correct.

Note 2: We need a new tag  SkillAnalyze-Code for this kind of thing.

C is incorrect because printing out all the numbers takes O(n) time.
D is incorrect because computing the sum of the numbers also takes O(n) time.
E is incorrect because while hashtables come close on average, in the worst case, sorting is not O(1).
A is correct (assuming you don't have to move any of the numbers that are already in the array).
B is correct.

Which response best explains in plain English what this segment of code does?

int a = 10;

int b = 8;

int c = 0;

c = (a + b)/2

Calculates half the sum of two numbers

Swaps the values of a and b

demonstrates the use of the assignment statement

Converts an integer value to double

This answer gives the most generalised explanation for the purpose of the code segment (namely to calculate the average of two numbers)

What is wrong with this code?

interface A{

        abstract double aMethod();

}

interface B{

          abstract int aMethod();

}

class testInterface implements A, B{

}

A class cannot implement more than one interface.

Methods defined in an interface should not be abstract.

aMethod should be overridden in testInterface class.

Which one of the options cannot be a choice to override the aMethod in class testInterface?

interface A{

          abstract Object aMethod();

}

interface B{

         abstract Object aMethod();

}

class testInterface implements A, B{

}

public String aMethod(){ return "";}

public Object aMethod(){ return null;}

public Double aMethod(){ return 0.0;}

What would be the most effective way of adding useGun() method to this structure. Note: useGun() can only be used for any type of fighters.

Add useGun() to GameActors class.

Add useGun() to GameActors class and make this class abstract.

Add useGun() to both GoodFighters and BadFighters class.