You are given a sequence of at least three integers, which consists of an increasing subsequence followed by a decreasing subsequence. Using the divide and conquer technique, develop a recursive algorithm that finds the index of the turning point in the sequence (that is, the point where it transitions from an increasing subsequence to a decreasing subsequence). For example, in the sequence [7 8 13 22 43 30 16 10), the integer 43 is the turning point and its index is equal to 4 (assuming the starting index is 0). So, the algorithm should return 4. Your implementation should be written in C++.
The function prototype is as follows: int turning Point
(int turning point intA[], int start, int end);
Note that start and end are indices.
Write out a recurrence relation for the time complexity T(n) and then express in Big-Theta notation.

Create a function (prob3_6) that will do the following: input a positive scalar integer x. if x is odd, multiply it by 3 and add 1. if the given x is even, divide it by 2. repeat this rule on the new value until you get 1, if ever. your program will output how many operations it had to perform to get to 1 and the largest number along the way. for example, start with the number 3: because 3 is odd, we multiply by 3 and add 1 giving us 10. 10 is even so we divide it by 2, giving us 5. 5 is odd so we multiply by 3 and add one, giving us 16. we divide 16 (even) by two giving 8. we divide 8 (even) by two giving 4. we divide 4 (even) by two giving 2. we divide 2 (even) by 2 to give us 1. once we have one, we stop. this example took seven operations to get to one. the largest number we had along the way was 16. every value of n that anyone has ever checked eventually leads to 1, but it is an open mathematical problem (known as the collatz conjectureopens in new tab) whether every value of n eventually leads to 1. your program should include a while loop and an if-statement.