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

"""

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.