Quizes Gagnaskipan

When designing a recursive function (that executes correctly) what must be included?

A base case condition and a recursive step

A function is recursive and runs and returns correctly. Which of the following statements made about any such function is true?

All of the other options are true When the parameter values in the current instance of the function meet certain conditions the recursion will stop Called with certain values, it might actually not recur (call itself again) at all Every time it calls itself, it does so with different parameter values than those of the current instance

The following operation would be considered an edge case:

All of the other options are true: -Setting the value at index 9 (lis[9] = x) in a list with 9 items (len(lis) == 9). -Removing an item from an empty list. -Adding an item to an empty list.

An implementation of a dynamic array, once the array is fully used but an additional item must be added, the program must

Allocate memory for a bigger array and copy all items between arrays

Comparing arrays and linked lists, which statement is true?

Data in arrays is stored in contiguous (samliggjandi) memory locations but not linked lists

Analysis of running time generally means

Finding a function that describes how the size or values of input data affect the running time of a program or algorithm.

What does the capacity variable in a dynamic array implementation represent?

How many items, in total, the array can hold, before its next resize is necessary

A function is recursive and runs and returns correctly. Which statement is true?

It has at least one code path without a call to itself

A programmer is asked to make a function that returns the sum of the first n natural numbers. The recursive function is: def bar(n): if n == 1: reuturn n return n + bar(n) We test it on the natural number 6: print(bar(6)) how will it behave?

It will recur endlessly and never return

Which of the following statements about recursive functions is true?

None of the other options are true: Recursion always yields the computationally fastest solution Recursion always yields neater solutions than other methods Some problems can only be solved using recursion

The time complexity for adding a new node at the front (head) of a singly-linked list is:

O(1)

An operation retrieves the value of a single item in an array at a specified location. example: print(ass[5]) What is the worst case time complexity of an efficient implementation?

O(1) - constant time

What is the time complexity of the following operation? n is a positive integer value. def oper(n): s = n while s > 1: s = s / 2

O(log2n)

An operation on a list is measured to complete in an amount of time that can be calculated by the following formula:(3 + 6*n + 2*n^2) msWhat would be the most common way to describe this operations's time complexity in Big Oh notation?

O(n'2)

The time complexity for fetching a value from a singly-linked list at a specified node (item number n in the list) is:

O(n)

What is the time complexity of the following operation?n is a positive integer value.def oper(n): s = 0 for i in range(n): s += 2

O(n)

An operation inserts a single item to the beginning (index 0) of an array. What is the worst case time complexity of an efficient implementation?

O(n) - linear time

An operations removes a single item from an array at a specified location. What is the worst- case time complexity of an efficient implementation?

O(n) - linear time

A data structure has the following operations that add and remove to and from the front and back of the structure, respectively: push_front(value): #time complexity: O(1) push_back(value): #time complexity: O(1) pop_front(): #time complexity: O(1) pop_back(): #time complexity: O(n) Which operations should be used for the most efficient implementation of a queue?

Push_back and pop_front

What does this recursive program do? def foo(a_str, n): if n == 0: return 0 n -= 1 if a_str[n] == 'a': return 1 + foo(a_str, n) return foo(a_str, n)

Returns the number of times of 'a' occurs in the first n letter of a_str

The acronym FIFO (first-in-first-out) is generally used to describe

The behavior of a queue

The acronym LIFO (last-in-first-out) is generally used to describe

The behavior of a stack

The following statement about O(1) (Constant time) and O(n) (Linear time) is true:

The latter is dependant on the input size (or input values) but the former is not.

The following statement about O(n) (Linear time) and O(log2n) (Logarithmic time) is true:

The latter would generally be considered a better time complexity than the former.

The following can be limiting factors on how many iterations a recursive function can do:

The maximum space allowed for storing descriptions of currently active function calls

The following statement about O(n) (Linear time) and O(n2) (Quadratic time) is true:

The running times of both are dependant on the input size (or input values).

A programmer is asked to make a function that calculates n to the power of m. This recursive function: def bar(n, m): return n * bar(n, m-1) what change is needed for it to work?

We need to add a condition: if m == 0 return 1

What is the output of the following program in Python: a = [2,3] b = a b.append(1) print(a)

[2, 3, 1]

A well implemented deque (double-ended queue) can substitute the behavior of

both a stack and a queue

A programmer is asked to make a function that returns the sum of the first n natural numbers. def bar(n): if n == 1: reuturn n return n + bar(n) what change is needed for it to work?

in the recursive call we need to call bar(n-1) instead of bar(1)

A programmer is asked to make a function that calculates n to the power of m. This recursive function: def bar(n, m): return n * bar(n, m-1) We test it on the positive integers 2 and 3: print(bar(2,3)) How will it behave?

it will recur endlessly and never return

When a linked list does not have reserved memory for an item that is to be added, the program must:

just add another item, as there is no capacity limit on a linked list

A data structure has the following operations that add and remove to and from the front and back of the structure, respectively: push_front(value): #time complexity: O(1) push_back(value): #time complexity: O(1) pop_front(): #time complexity: O(1) pop_back(): #time complexity: O(n) Which operations should be used for the most efficient implementation of a stack?

push_front and pop_front

In order to access the next-to-last node (in front of tail) in a singly-linked list the most efficient possible way for a program is to:

walk the entire list from the head (first node), one step at a time (O(n))