A powerful array for an integer x is the shortest sorted array of powers of two that sum up to x. For example, the powerful array for 11 is [1, 2, 8].The array big_nums is created by concatenating the powerful arrays for every positive integer i in ascending order: 1, 2, 3, and so forth. Thus, big_nums starts as [1, 2, 1, 2, 4, 1, 4, 2, 4, 1, 2, 4, 8, ...].You are given a 2D integer matrix queries, where for queries[i] = [fromi, toi, modi] you should calculate (big_nums[fromi] * big_nums[fromi + 1] * ... * big_nums[toi]) % modi.Return an integer array answer such that answer[i] is the answer to the ith query. Example 1:Input: queries = [[1,3,7]]Output: [4]Explanation:There is one query.big_nums[1..3] = [2,1,2]. The product of them is 4. The remainder of 4 under 7 is 4.Example 2:Input: queries = [[2,5,3],[7,7,4]]Output: [2,2]Explanation:There are two queries.First query: big_nums[2..5] = [1,2,4,1]. The product of them is 8. The remainder of 8 under 3 is 2.Second query: big_nums[7] = 2. The remainder of 2 under 4 is 2. Constraints:1 <= queries.length <= 500queries[i].length == 30 <= queries[i][0] <= queries[i][1] <= 10151 <= queries[i][2] <= 105

You are given an array nums consisting of integers. You are also given a 2D array queries, where queries[i] = [posi, xi].For query i, we first set nums[posi] equal to xi, then we calculate the answer to query i which is the maximum sum of a subsequence of nums where no two adjacent elements are selected.Return the sum of the answers to all queries.Since the final answer may be very large, return it modulo 109 + 7.A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements. Example 1:Input: nums = [3,5,9], queries = [[1,-2],[0,-3]]Output: 21Explanation:After the 1st query, nums = [3,-2,9] and the maximum sum of a subsequence with non-adjacent elements is 3 + 9 = 12.After the 2nd query, nums = [-3,-2,9] and the maximum sum of a subsequence with non-adjacent elements is 9.Example 2:Input: nums = [0,-1], queries = [[0,-5]]Output: 0Explanation:After the 1st query, nums = [-5,-1] and the maximum sum of a subsequence with non-adjacent elements is 0 (choosing an empty subsequence). Constraints:1 <= nums.length <= 5 * 104-105 <= nums[i] <= 1051 <= queries.length <= 5 * 104queries[i] == [posi, xi]0 <= posi <= nums.length - 1-105 <= xi <= 105

The time complexity to access an element in a 2D matrix by row-major order is:O(1)O(log n)O(n)O(n^2)

If A is an m x n matrix then AT (Transpose of A) is an n x m matrix, such that rows of A become columns of AT and columns of A become rows of AT.Given a 2D array, you have to implement the given function,int** Transpose(int** matrix, int rowCount, int columnCount);Implement the function to find the transpose of the matrix and return the new matrix as output.Input:matrix:2 46 8Output:2 64 8Explanation: Values 2 and 4 in the first row become the first column in the returned matrix.Similarly, values 6 and 8 in the second row become the second column in the returned matrix.Sample inputmatrix:1 2 3 4 5 6Sample Output1 4 2 5 3 6

Two matrices M1 and M2 are to be stored in arrays A and B respectively. Each array can be stored either in row-major or column-major order in contiguous memory locations. The time complexity of an algorithm to compute M1 × M2 will be*2 pointsbest if A is in row-major, and B is in column- major orderbest if both are in row-major orderbest if both are in column-major orderindependent of the storage scheme

Given an integer array nums, find the subarray with the largest sum, and return its sum.