contest leetcode 296

class Solution:
    def arrayChange(self, nums: List[int], operations: List[List[int]]) -> List[int]:
        temp={}
        for i in range(len(nums)):
            temp[num[i]]=i
        
        for i in range(len(op)):
            if op[i][0] not in temp:
                temp[op[i][0]]=temp[op[i][1]]
            nums[temp[op[i][0]]]=op[i][1]
            temp[op[i][0]]=temp[op[i][1]]
            return nums
            
                
        
        class Solution {
public:
    vector<int> arrayChange(vector<int>& A, vector<vector<int>>& op) {
    unordered_map<int,int> store;
        
    for(int i=0;i<A.size();i++) store[A[i]]=i;
        
    for(auto i:op){
        A[store[i[0]]]= i[1];           //replace value to its index
        store[i[1]]= store[i[0]];       //update new value with its index
    }
    return A;
}
};


class Solution {
public:
    int minMaxGame(vector<int>& nums) {
       for(int n=size(a);n>1;n-=(n/2))
       {
           for(int i=0;i<n/2;i++)
               nums[i]=(i%2)?max(nums[2*i],nums[2*i+1]):min(nums[2*i],nums[2*i+1]);
       }
        return nums[0];
    }
};
class Solution:
    def minMaxGame(self, nums: List[int]) -> int:
        l=nums
        while(l)>1:
            ismin=True
            temp=[]
            for i in range(0,len(l),2):
                if ismin:
                    temp.append(min(l[i:i+2]))
                else:
                    temp.append(max(l[i:i+2]))
                ismin=not ismin
            l=temp
            return l[0]
                    
        
class Solution {
public:
    int partitionArray(vector<int>& A, int k) {
        sort(A.begin(), A.end());
       
     
        check for subsequences having sum =k ==3
          
            
            [1,2,3,1,1]   [1 1 1 ]
                           [2, 1]
                            [3]
            op--3
            
            2 sum
            
            recursion
           
          
          
        
        
        int res = 1, 
        
        mn = A[0], mx = A[0];
        
        for (int& a: A) {
            mn = min(mn, a); 
            mx = max(mx, a); 
            if (mx - mn > k) {
                res++;
                mn = mx = a;     3
            }
        }
        return res;
    }
};