Leetcode with dani

Given a binary array nums, return the maximum number of consecutive 1's in the array if you can flip at most one 0.
Example 1:
Input: nums = [1,0,1,1,0]
Output: 4
Explanation:
- If we flip the first zero, nums becomes [1,1,1,1,0] and we have 4 consecutive ones.
- If we flip the second zero, nums becomes [1,0,1,1,1] and we have 3 consecutive ones.
The max number of consecutive ones is 4.
Example 2:
Input: nums = [1,0,1,1,0,1]
Output: 4
Explanation:
- If we flip the first zero, nums becomes [1,1,1,1,0,1] and we have 4 consecutive ones.
- If we flip the second zero, nums becomes [1,0,1,1,1,1] and we have 4 consecutive ones.
The max number of consecutive ones is 4.
Constraints:
1 <= nums.length <= 10**3
nums[i] is either 0 or 1.

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

"""

/* 
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;}

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_