Write a traversal loop for an fsu::Vector object v .

• for (size_t i = 0; i <= size; ++i) { /* whatever */ }

• for (size_t i = 0; i < v.Size(); ++i) { /* whatever */ }

• for (size_t i = 0; i < size; ++i) { /* whatever */ }

• None of the other choices

• for (size_t i = 0; i <= v.Size(); ++i) { /* whatever */ }

To find a pointer max to the largest element in the array a we can use the following generic
algorithm call (there are size elements in a)

• None of the other choices

• max = fsu::g_max_element ( a, a + size );

• max = fsu::g_max_element ( a.Begin() );

• max = fsu::g_max_element (a);

• max = fsu::g_max_element ( a.Begin(), a.End() );

This is an illustration of a vector of characters to be used in answering the question:
element: B D F F F H K Q W Y
index: 0 1 2 3 4 5 6 7 8 9

What is the return value of the call upper_bound('F') ?

• 1

• 2

• 3

• 4

• 5

• D

• F

• H

Declare a vector object widgetVector with elements of type Widget, size 15, and

initial element values equal to ZED.

• fsu::Vector<Widget> widgetVector (15,ZED);

• WidgetVector widgetVector (15,ZED);

• fsu::Vector<Widget>(15,ZED) widgetVector;

• None of the other choices

• fsu::Vector<Widget(15,ZED)> widgetVector;

Select the most appropriate statement for the asymptotic runtime for
the binary_search algorithm with input size n.

• O(log n)

• Θ(log n)

• O(n)

• Θ(n)

To copy the elements from an fsu::Deque<> d to an fsu::Vector<> v we can use the
following generic algorithm call:

• fsu::g_copy (d.Begin(), d.End(), v.Begin(), v.End());

• fsu::g_copy (d.Begin(), d.End(), v.Begin());

• None of the other choices

• fsu::g_copy (d.Begin(), d.End(), v, v + d.Size);

• fsu::g_copy (d.Begin(), d.End(), v);

Select the answer that best describes the asymptotic runtime of the operation
fsu::List::PushBack(t)
Here t is an item of type  fsu::List::ValueType and n is the size of the list.

• O(1)

• Amortized
  O(1)

• O(n)

• Amortized
  O(n)

You are given the declaration
fsu::List<fsu::String> L;
Write a client program fragment that inserts the strings"Help", "I", "May", "You" into L (in this
order) so that
L.Display(std::cout, ' ');
results in the sentence "May I Help You".

• L.PushFront("Help");
  L.PushFront("I");
  L.PushFront("May");
  L.PushFront("You");

• L.PushBack("Help");
  L.PushFront("I");
  L.PushFront("May");
  L.PushBack("You";);

• L.PushFront("Help");
  L.PushBack("I");
  L.PushFront("May");
  L.PushBack("You");

• None of the other
  choices

• L.PushBack("Help");
  L.PushBack("I");
  L.PushBack("May");
  L.PushFront("You");

Using a data stack to evaluate the postfix expression
1 2 3 + 4 5 6 + * + +
what is the best representation of the stack during the evaluation?

Declare an fsu::List object L with elements of type fsu::String.

• fsu::List<fsu::String> L;

• L = fsu::List<fsu::String>;

• None of the other choices

• fsu::List L<fsu::String>;

• L = new fsu::List<fsu::String>;

Select the most appropriate statement of the asymptotic runtime for
the sequential_search algorithm with input size n.

• O(log n)

• Θ(log n)

• O(n)

• Θ(n)

Select the answer that best describes the asymptotic runtime of the operation
   fsu::Deque:: bracket operator [i]
Here i is an item of type size_t and n is the size of the deque.

• O(1)

• Amortized
  O(1)

• O(n)

• Amortized
  O(n)

Select the answer that best describes the asymptotic runtime of the operation
fsu::List::PushBack(t)
Here t is an item of type  fsu::List::ValueType and n is the size of the list.

• O(1)

• Amortized
  O(1)

• O(n)

• Amortized
  O(n)

Select the most appropriate statement of the asymptotic runtime for
the sequential_search algorithm with input size n.

• O(log n)

• Θ(log n)

• O(n)

• Θ(n)

Select the answer that best describes the asymptotic runtime of the operation

   fsu::List:: Destructor
Here n is the size of the list.

• O(1)

• Amortized
  O(1)

• O(n)

• Amortized
  O(n)

Select the answer that best describes the asymptotic runtime of the operation

   fsu::Vector::PushBack(t)
Here t is an item of type  fsu::Vector::ValueType and n is the size of the vector.

• O(1)

• Amortized
  O(1)

• O(n)

• Amortized
  O(n)

Suppose the fsu::Deque<> d has elements in sorted order and we wish to
insert the element x in correct order in d. The following generic algorithm call
returns an iterator to the last correct location to insert x:

• i = fsu::g_upper_bound(d.Begin(), d.End(), x);

• i = fsu::g_upper_bound(d, x);

• None of the other choices

• i = fsu::g_lower_bound(d, x);

Declare a Deque object d with elements of type String.

• fsu::Deque < char > d;

• d = new fsu::Deque< char >;

• fsu::Deque< char , fsu::List < char >>
  d;

• None of the other choices

• d fsu::Deque < char >;