You are given a 0-indexed integer array nums.
Swaps of adjacent elements are able to be performed on nums.
A valid array meets the following conditions:
    The largest element (any of the largest elements if there are multiple) is at the rightmost position in the array.
    The smallest element (any of the smallest elements if there are multiple) is at the leftmost position in the array.
Return the minimum swaps required to make nums a valid array.
 
Example 1:
Input: nums = [3,4,5,5,3,1]
Output: 6
Explanation: Perform the following swaps:
- Swap 1: Swap the 3rd and 4th elements, nums is then [3,4,5,3,5,1].
- Swap 2: Swap the 4th and 5th elements, nums is then [3,4,5,3,1,5].
- Swap 3: Swap the 3rd and 4th elements, nums is then [3,4,5,1,3,5].
- Swap 4: Swap the 2nd and 3rd elements, nums is then [3,4,1,5,3,5].
- Swap 5: Swap the 1st and 2nd elements, nums is then [3,1,4,5,3,5].
- Swap 6: Swap the 0th and 1st elements, nums is then [1,3,4,5,3,5].
It can be shown that 6 swaps is the minimum swaps required to make a valid array.

Example 2:
Input: nums = [9]
Output: 0
Explanation: The array is already valid, so we return 0.

    
          
 
Constraints:
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5

You are given a sorted array nums of size n and an integer target. 
Your task is to find the pair of numbers in the array whose sum is less than or equal to the target and has the largest possible sum.

Return the maximum sum of such a pair. If no valid pair exists, return -1.

Example 1:
Input: nums = [2, 3, 5, 8, 13], target = 10
Output: 10
 l
[2, 3, 5, 8, 13],
          r
[7,8 , 10]
Explanation: The pair (2, 8) has a sum of 10, which is the largest possible sum less than or equal to 10.

Example 2:
Input: nums = [1, 1, 1, 1], target = 1
Output: -1
Explanation: No pair has a sum less than or equal to 1.

Constraints:
1<=n<=10⁵
Nums  is sorted in non-decreasing order.



def targetSum(nums , target):
    left = 0
    max_ = -1
    right = len(nums)-1
    while left < right:
        sum = nums[left] + nums[right]
        if sum == target:
            return sum
        elif sum > target:
            right -=1
        elif sum < target:
            left += 1
            max_ = max(max_,sum)
    return max_

/* 
You have some apples and a basket that can carry up to 5000 units of weight.
Given an integer array weight where weight[i] is the weight of the ith apple, 
return the maximum number of apples you can put in the basket.

Example 1:
Input: weight = [100,200,150,1000]
Output: 4
Explanation: All 4 apples can be carried by the basket since their sum of weights is 1450.
    
Example 2:
Input: weight = [900,950,800,1000,700,800]
Output: 5
Explanation: The sum of weights of the 6 apples exceeds 5000 so we choose any 5 of them.

*/

#include<bits/stdc++.h>
using namespace std;

int maxApples(vector<int> weight, int limit){
    
    sort(weight.begin(), weight.end());
    int count = 0, sum = 0, n = weight.size();
    
    
    for(int i=0; i<n; i++){
        sum+=weight[i];
        if(sum>limit)break;
        count++;  
    }   
    
    return count;
}


int main(){
    vector<int> weight = {100,200,150,1000};
    cout << maxApples(weight, 1450) << endl;

    return 0;}

There are n windows open numbered from 1 to n, we want to simulate using alt + tab to navigate between the windows.
 You are given an array windows which contains the initial order of the windows (the first element is at the top and the last one is at the bottom).
 You are also given an array queries where for each query, the window queries[i] is brought to the top.
 Return the final state of the array windows.
  
 Example 1:
 Input: windows = [1,2,3], queries = [3,3,2]
 Output: [2,3,1]
 Explanation:
 Here is the window array after each query:
Initial order: [1,2,3]
After the first query: [3,1,2]
After the second query: [3,1,2]
After the last query: [2,3,1]
Example 2:
 Input: windows = [1,4,2,3], 
 
 = [4,1,3]
 Output: [3,1,4,2]
 Explanation:
 Here is the window array after each query:
Initial order: [1,4,2,3]
After the first query: [4,1,2,3]
After the second query: [1,4,2,3]
After the last query: [3,1,4,2]
 
 Constraints:
1 <= n == windows.length <= 103
windows is a permutation of [1, n].
1 <= queries.length <= 103
1 <= queries[i] <= n

"""