For the following functions, state whether or not they are tail recursive. Justify your answer. { } if (last <= first) return; bool initial_call if (initial_call) = ! (aux) aux new int[last first + 1]; = - int mid = (first last) / 2; merge_sort (a, first, mid, aux); merge_sort (a, mid+1, last, aux); merge_arrays (a, first, mid, a, mid+1, last, aux, 0, last-first); for (int i first, j = 0; i <= last; ++i, ++j) a[i] = aux[j]; if (initial_call) delete [] aux;

Given the following non-recursive implementation of depth-first search:   A. Complete the implementation of depth-first search by filling in the TODO sections with the appropriate C++ code. Remember to: Print out each node you visit. Visit each node exactly once. B. What is the purpose of stack<string> q? C. What is the purpose of set<string> v?

Lee has discovered what he thinks is a clever recursive strategy for printing the elements in a sequence (string, tuple, or list). He reasons that he can get at the first element in a sequence using the 0 index, and he can obtain a sequence of the rest of the elements by slicing from index 1. This strategy is realized in a function that expects just the sequence as an argument. If the sequence is not empty, the first element in the sequence is printed and then a recursive call is executed. On each recursive call, the sequence argument is sliced using the range 1:. Here is Lee’s function definition: def printAll(seq): if seq: print(seq[0]) printAll(seq[1:]) Write a program that tests this function and add code to trace the argument on each call. Does this function work as expected? If so, are there any hidden costs in running it?

By hand, apply both quicksort to the sequence A,L,G,O,R,I,T,H,M. and draw the tree of recursive calls made.

Write a recursive Racket function "update-if" that takes two functions, f and g, and a list xs as parameters and evaluates to a list. f will be a function that takes one parameter and evaluates true or false. g will be a function that takes one parameter and evaluates to some output. The result of update-if should be a list of items such that if x is in xs and (f x) is true, then (g x) is in the list. The output list's elements should keep the input list's items in the same relative order. For example (update-if even? add1 '(1 2 3 4)) should evaluate to '(3 5) because 2 and 4 make even? true and add1 turns 2 and 4 into 3 and 5.

A sml binarySearch function that recursively implements the binary search algorithm to search a sorted integer list for a specified integer and returns true if it is found, false otherwise.  For example, binarySearch ([100,200,300,400,500], 200) returns true, whereas binarySearch([100,200,300,400,500], 299) returns false. Hint: Write a helper function mid that returns a tuple (index, value) representing the middle value in a list. For example, mid [10, 2, 40, 8, 22] returns (2,40) because the value 40 at index 2 is the middle value in the list. Similarly, mid [10, 20] would return (1, 20). Use mid in conjunction with slice to implement binarySearch.

Write a function in a racket code that takes as input a list of elements and returns a list with elements and their position after. For example, if the input to the function is (list ’a ’b ’c) then it will return (list a 1 b 2 c 3). Make sure to use recursion

Consider the following recursive definition of list reversal. For a list L, rev(L) is defined: rev([]) = []rev(x : L) = rev(L) + [x] Please prove by induction on L that concatenation is left cancellative: L+M = L+N implies M = N. Please prove by induction on L that rev(rev(L)) = L for all lists L. Please prove by induction on L that rev(L + M ) = rev(M ) + rev(L) for all lists L and M . (Can utilize fact that concatenation = associative) Using 1, 2, and 3 to prove that concatenation is right cancellative as well: L + N = M + N implies L = M.

In Kotlin, Write a recursive function called myZip, with an expression body. MyZip takes two Lists and returns a List of Pairs in which each value may be any type (I suggest your start by thinking out how to represent this data type). The pairs consist of corresponding elements in the two lists (the first element of the first list and the first element of the second list, etc). The base case should be that either (or both) of the original lists has length 1, so that, if the lists have different length, the zipping stops when the first list runs out of values.

Write a recursive function in f#, named specialSum, that has the followeing signature: int * int -> int, where sum(m,n) = m + (m +1) + (m+2) + ... + (m + (n-1)) + (m+n) for m >= 0 and n >= 0: (Hint use two clauses with (m,0) and (m,n) A PATTERNS.) start code with let rec specialSum (m,n) match m,n with | m,0 -> | m,n - >