You are given an integer array nums and a non-negative integer k. A sequence of integers seq is called good if there are at most k indices i in the range [0, seq.length - 2] such that seq[i] != seq[i + 1].Return the maximum possible length of a good subsequence of nums. Example 1:Input: nums = [1,2,1,1,3], k = 2Output: 4Explanation:The maximum length subsequence is [1,2,1,1,3].Example 2:Input: nums = [1,2,3,4,5,1], k = 0Output: 2Explanation:The maximum length subsequence is [1,2,3,4,5,1]. Constraints:1 <= nums.length <= 5001 <= nums[i] <= 1090 <= k <= min(nums.length, 25)Python3 1class Solution:2    def maximumLength(self, nums: List[int], k: int) -> int:

You are given an integer array nums.A subsequence sub of nums with length x is called valid if it satisfies:(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.Return the length of the longest valid subsequence of nums.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 = [1,2,3,4]Output: 4Explanation:The longest valid subsequence is [1, 2, 3, 4].Example 2:Input: nums = [1,2,1,1,2,1,2]Output: 6Explanation:The longest valid subsequence is [1, 2, 1, 2, 1, 2].Example 3:Input: nums = [1,3]Output: 2Explanation:The longest valid subsequence is [1, 3]. Constraints:2 <= nums.length <= 2 * 1051 <= nums[i] <= 107

You are given an array 𝐴A of size 𝑁N.Find the largest integer 𝐾K such that there exists a subsequence 𝑆S of length 𝐾K where 𝐾K is divisible by the number of distinct elements in 𝑆S.Input FormatThe first line contains a single integer 𝑇T, denoting the number of test cases.The first line of each test case contains a positive integer 𝑁N, the length of array 𝐴A.The second line contains 𝑁N space-separated integers, 𝐴1,𝐴2,…,𝐴𝑁A 1​ ,A 2​ ,…,A N​ −− denoting the array 𝐴A.Output FormatFor each test case, output the largest valid 𝐾K.Constraints1≤𝑇≤1041≤T≤10 4 1≤𝐴𝑖≤𝑁≤2⋅1051≤A i​ ≤N≤2⋅10 5 The sum of 𝑁N over all test cases won't exceed 2⋅1052⋅10 5 .Sample 1:

Given an array, find the length of the longest subsequence whose elements can be re-arranged in a strictly increasing contiguous order. The difference between 2 adjacent elements in the subsequence, after re-arrangement, should be exactly 1.Input FormatThe first line of input contains T - the number of test cases. It's followed by 2T lines. The first line of each test case contains N - size of the array. The next line contains N integers - the elements of the array.Output FormatFor each test case, print the length of the longest subsequence, separated by a new line.Constraints1 <= T <= 10001 <= N <= 10000-100000 <= ar[i] <= 100000ExampleInput3821 -22 -22 5 -31 -24 5 -231018 -33 31 33 30 -14 32 30 16 1766 3 8 5 2 5Output342ExplanationTest Case 1Subsequence is: -22, -24, -23.Test Case 2Subsequence is: 31, 33, 30, 32.Test Case 3Subsequence is: 6, 5 or 3, 2.

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

longest consecutive elementsYou need to write a function that takes an unsorted array of integers as input and returns the length of the longest consecutive elements sequence in the array. A consecutive elements sequence is a subarray where the elements are adjacent in value, such as [1, 2, 3, 4] or [5, 6, 7, 8]. The order of the elements in the input array does not matter.For example, given the input array [100, 4, 200, 1, 3, 2], the longest consecutive elements sequence is [1, 2, 3, 4], which has a length of 4. Therefore, your function should return 4.In this case, there are no consecutive elements in the array, so the length of the longest consecutive element sequence is 1.Testcase:Input11  // no of elements of array8 10 12 14 1 2 3 4 5 6 7  // array elementsOutput:8