├── D1-String.cpp
├── D10-Array.cpp
├── D11-Array.cpp
├── D12-Array.cpp
├── D13-Array.cpp
├── D14-Array.cpp
├── D15-Array.cpp
├── D16-Array.cpp
├── D17-Array.cpp
├── D18-Array.cpp
├── D19-Array.cpp
├── D2-String.cpp
├── D20-Array.cpp
├── D21-String.cpp
├── D22-String.cpp
├── D23-String.cpp
├── D24-String.cpp
├── D25-String.cpp
├── D26-String.cpp
├── D27-String.cpp
├── D28-String.cpp
├── D29-String.cpp
├── D3-String.cpp
├── D4-Array.cpp
├── D5-Array.cpp
├── D6-Array.cpp
├── D7-Array.cpp
├── D8-Array.cpp
├── D9-Array.cpp
└── README.md


/D1-String.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | // 53. Maximum Subarray
  3 | // Approach 1: Brute Force
  4 | // for(int i=0 ->n){
  5 | // for(int j=0 ->n){
  6 | //     for(int k=i -> j){
  7 | //         sum = sum + arr[k];
  8 | //     }
  9 | // }
 10 | // }
 11 | 
 12 | // for(int i=0 ->n){
 13 | //     sum
 14 | // for(int j=0 ->n){
 15 | //     for(int k=i -> j){
 16 | //         sum = sum + arr[k];
 17 | //     }
 18 | // }
 19 | // }
 20 | 
 21 | 
 22 | 
 23 | class Solution {
 24 | public:
 25 |     int maxSubArray(vector<int>& nums) {
 26 |         int sum = 0;
 27 |         int maxi = nums[0];
 28 | 
 29 | 
 30 |         for(int i=0; i<nums.size(); i++){
 31 |             //Step-1
 32 |             sum = sum + nums[i];
 33 |             //Step-2
 34 |             maxi = max(maxi, sum);
 35 |             //Step-3
 36 |             if(sum<0)
 37 |                 sum=0;
 38 |         }
 39 |         return maxi;
 40 |     }
 41 | };
 42 | 
 43 | 
 44 | 
 45 | // DSA Sheet Sloving String Q-1: Maximum and minimum of an array using minimum number of comparisons
 46 | // Approch-1: set max and min from 1st two element of array
 47 | 
 48 | #include <iostream>
 49 | using namespace std;
 50 | 
 51 | int main() {
 52 |     int n = 0;
 53 |     int arr[n];
 54 |     int max, min;
 55 |     cin>>n;
 56 |     for(int i=0; i<n; i++){
 57 |         cin>>arr[i];
 58 |     }
 59 |     if(n==0){
 60 |         max = arr[0];
 61 |         min = arr[0];
 62 |     }
 63 |     if(n==1){
 64 |         if(arr[0]>arr[1]){
 65 |             max = arr[0];
 66 |             min = arr[1];
 67 |         }
 68 |         else{
 69 |             max = arr[1];
 70 |             min = arr[0];
 71 |         }
 72 |     }
 73 |     else{
 74 |         if(arr[0]>arr[1]){
 75 |             max = arr[0];
 76 |             min = arr[1];
 77 |         }
 78 |         else{
 79 |             max = arr[1];
 80 |             min = arr[0];
 81 |         }
 82 |         for(int i=2; i<n; i++){
 83 |             if(max<arr[i]){
 84 |                 max = arr[i];
 85 |             }
 86 |             if(min>arr[i]){
 87 |                 min = arr[i];
 88 |             }
 89 |         }
 90 |     }
 91 |     cout<<"Max" << max<<endl;
 92 |     cout<<"Min" << min<<endl;
 93 | 
 94 |     return 0;
 95 | }
 96 | 
 97 | 
 98 | // DSA Sheet Sloving String Q-2: Array Reverse
 99 | // Online C++ compiler to run C++ program online
100 | #include <iostream>
101 | using namespace std;
102 | 
103 | int main() {
104 |     
105 |     int n, i, j, temp;
106 |     int arr[n];
107 |     
108 |     cin>>n;
109 |     
110 |     for(int k=0; k<n; k++){
111 |         cin >> arr[k];
112 |     }
113 |     
114 |     
115 |     for(int i=0, j=n-1; i<n/2; i++,j--){
116 |         temp = arr[i];
117 |         arr[j] = arr[i];
118 |         arr[j] = temp;
119 |     }
120 |     
121 |     for(int k=0; k<n; k++){
122 |         cout << arr[k];
123 |     }
124 |     
125 |     
126 |     return 0;
127 | }
128 | 
129 | 
130 | 
131 | 
132 | // #include <iostream>
133 | // using namespace std;
134 | 
135 | // /* run this program using the console pauser or add your own getch, system("pause") or input loop */
136 | 
137 | // void printSum(int arr[][3], int row, int col){
138 | // 	for(int row=0; row<3; row++){
139 | // 		int sum = 0;
140 | // 		for(int col=0; col<3; col++){
141 | // 					sum += arr[row][col];	
142 | // 		}
143 | // 		cout<<sum<<" ";
144 | // 	}
145 | // }
146 | 
147 | // void printcolSum(int arr[][3], int row, int col){
148 | // 	for(int row=0; row<3; row++){
149 | // 		int sum = 0;
150 | // 		for(int col=0; col<3; col++){
151 | // 					sum += arr[col][row];	
152 | // 		}
153 | // 		cout<<sum<<" ";
154 | // 	}
155 | // }
156 | 
157 | 
158 | // bool isPresent(int arr[][4], int target, int row, int col){
159 | // 	for(int row=0; row<3; row++){
160 | // 		for(int col=0; col<4; col++){
161 | 			
162 | // 			if(arr[row][col] == target){
163 | // 				return 1;
164 | // 			}
165 | 			
166 | // 		}
167 | // 	}
168 | // 	return 0;
169 | // }
170 | 
171 | 
172 | // int LargetRowSum(int arr[][3], int row, int col){
173 | // 	int maxi = INT_MIN;
174 | // 	int rowIndex = -1;
175 | // 	for( int row=0; row<3; row++){
176 | // 		int sum = 0;
177 | // 		for(int col=0; col<3; col++){
178 | // 			sum += arr[row][col];
179 | // 		}
180 | // 		if(sum > maxi){
181 | // 			maxi = sum;
182 | // 			rowIndex = row;
183 | // 		}
184 | // 	}
185 | // 	return rowIndex;
186 | // }
187 | 
188 | 
189 | // int main(int argc, char** argv) {
190 | 	
191 | // //	int arr1[3][4] = {{1,11,111,1111}, {2,22,222,2222}, {3,33,333,3333}};
192 | // 	int arr2[3][3];
193 | 	
194 | // 	for(int row=0; row<3; row++){
195 | // 		for(int col=0; col<3; col++){
196 | // 			cin>>arr2[row][col];
197 | // 		}
198 | // 	}
199 | 	
200 | // 	for(int row=0; row<3; row++){
201 | // 		for(int col=0; col<3; col++){
202 | // 			cout<<arr2[row][col]<<" ";
203 | // 		}
204 | // 		cout<<endl;
205 | // 	}
206 | 	
207 | 
208 | // //Sieve of Eratosthenes
209 | 	
210 | // //	class Solution {
211 | // //public:
212 | // //    int countPrimes(int n) {
213 | // //        int count = 0;
214 | // //       vector<bool> prime(n+1, true);
215 | // //       prime[0] = prime[1] = false;
216 | // //
217 | // //       for(int i=2; i<n; i++){
218 | // //           if(prime[i]){
219 | // //               count++;
220 | // //               for(int j=2*i; j<n; j=j+i){
221 | // //                   prime[j] = 0;
222 | // //              }
223 | // //           }
224 | // //       }
225 | // //        return count;
226 | // //    }
227 | // //};
228 | 	
229 | 	
230 | // //	class Solution {
231 | // //    bool isPrime(int n){
232 | // //        if(n<=1){
233 | // //            return false;
234 | // //        }
235 | // //        for(int i=2; i<n; i++){
236 | // //            if(n%i==0){
237 | // //                return false;
238 | // //            }
239 | // //        }
240 | // //        return true;
241 | // //    }
242 | // //public:
243 | // //    int countPrimes(int n) {
244 | // //        int count = 0;
245 | // //        for(int i=2; i<n; i++){
246 | // //            if(isPrime(i)){
247 | // //                count++;
248 | // //            }
249 | // //        }
250 | // //        return count;
251 | // //    }
252 | // //};
253 | 	
254 | 	
255 | // //	int target;
256 | // //	cin>>target;
257 | 	
258 | // //	if(isPresent(arr1, target, 3, 4)){	
259 | // //		cout<<"Element Found";
260 | // //	}	
261 | // //	else{
262 | // //		cout<<"Element Not Found";
263 | // //	}
264 | 
265 | // 	cout<<"Row Wise Sum = ";
266 | // 	printSum(arr2, 3, 3);
267 | // 	cout<<endl;
268 | // //	cout<<"Colum Wise Sum = ";
269 | // //	printcolSum(arr2, 3, 3);
270 | // //	cout<<endl;
271 | 	
272 | // 	cout<<"The Largest Sum is "<<LargetRowSum(arr2, 3,  3);	
273 | 	
274 | // 	return 0;
275 | // }
276 | 
277 | 
278 | // //54. Spiral Matrix
279 | // //class Solution {
280 | // //public:
281 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
282 | // //        int row = matrix.size();
283 | // //        int col = matrix[0].size();
284 | // //        vector<int> ans;
285 | // //        int count = 0;
286 | // //        int total = row*col;
287 | // //        int startingRow = 0;
288 | // //        int startingCol = 0;
289 | // //        int endingRow = row-1;
290 | // //        int endingCol = col-1;
291 | // //
292 | // //        while(count<total){
293 | // //
294 | // //            for(int i=startingCol; count<total && i<=endingCol; i++){
295 | // //                ans.push_back(matrix[startingRow][i]);
296 | // //                count++;
297 | // //            }
298 | // //            startingRow++;
299 | // //
300 | // //            for(int i=startingRow; count<total &&i<=endingRow; i++){
301 | // //                ans.push_back(matrix[i][endingCol]);
302 | // //                count++;
303 | // //            }
304 | // //            endingCol--;
305 | // //
306 | // //            for(int i=endingCol; count<total && i>=startingCol; i--){
307 | // //                ans.push_back(matrix[endingRow][i]);
308 | // //                count++;
309 | // //            }
310 | // //            endingRow--;
311 | // //
312 | // //            for(int i=endingRow; count<total && i>=startingRow; i--){
313 | // //                ans.push_back(matrix[i][startingCol]);
314 | // //                count++;
315 | // //            }
316 | // //            startingCol++;
317 | // //        }
318 | // //        return ans;
319 | // //    }
320 | // //};
321 | // //class Solution {
322 | // //public:
323 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
324 | // //        int n=matrix.size(),m=matrix[0].size();
325 | // //        int left=0,top=0;
326 | // //        int bottom=n-1,right=m-1;
327 | // //        vector<int>ans;
328 | // //        while(left<=right&&top<=bottom)
329 | // //        {
330 | // //            for(int i=left;i<=right;i++)
331 | // //            {
332 | // //                ans.push_back(matrix[top][i]);
333 | // //            }
334 | // //            top++;
335 | // //            for(int i=top;i<=bottom;i++)
336 | // //            {
337 | // //                ans.push_back(matrix[i][right]);
338 | // //            }
339 | // //            right--;
340 | // //            if(top<=bottom)
341 | // //            {
342 | // //                for(int i=right;i>=left;i--)
343 | // //                {
344 | // //                    ans.push_back(matrix[bottom][i]);
345 | // //                }
346 | // //                bottom--;
347 | // //            }
348 | // //            if(left<=right)
349 | // //            {
350 | // //                for(int i=bottom;i>=top;i--)
351 | // //                {
352 | // //                    ans.push_back(matrix[i][left]);
353 | // //                }
354 | // //                left++;
355 | // //            }
356 | // //        }
357 | // //        return ans;
358 | // //    }
359 | // //};
360 | 
361 | // //Rotate Image by 90 degree
362 | // //class Solution {
363 | // //public:
364 | // //    void rotate(vector<vector<int>>& matrix) {
365 | // //        int n = matrix.size();
366 | // //        for(int i=0; i<(n+1)/2;i++){
367 | // //            for(int j=0; j<n/2; j++){
368 | // //                int temp = matrix[n-1-j][i];
369 | // //                matrix[n-1-j][i] = matrix[n-1-i][n-j-1];
370 | // //                matrix[n-1-i][n-j-1] = matrix[j][n-1-i];
371 | // //                matrix[j][n-1-i] = matrix[i][j];
372 | // //                matrix[i][j] = temp;
373 | // //            }
374 | // //        }
375 | // //    }
376 | // //    
377 | // //};
378 | 
379 | 
380 | 
381 | 
382 | 
383 | 
384 | 
385 | 
386 | 
387 | 
388 | 
389 | 
390 | 
391 | // //Print Like a Wave
392 | // //#include <bits/stdc++.h> 
393 | // //vector<int> wavePrint(vector<vector<int>> arr, int nRows, int mCols)
394 | // //{
395 | // //    vector<int> ans;
396 | // //
397 | // //    for(int col=0; col<mCols; col++){
398 | // //        if(col&1){
399 | // //            for(int row=nRows-1; row>=0; row--){
400 | // //                ans.push_back(arr[row][col]);
401 | // //            }
402 | // //        }
403 | // //        else{
404 | // //            for(int row=0; row<nRows; row++){
405 | // //                ans.push_back(arr[row][col]);
406 | // //            }
407 | // //        }
408 | // //    }
409 | // //    return ans;
410 | // //}
411 | 
412 | 
413 | 
414 | 
415 | // // 2d matrix
416 | 
417 | // //class Solution {
418 | // //public:
419 | // //    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
420 | // //        // if(matrix.size()==0 || matrix[0].size()==0){
421 | // //        //     return matrix;
422 | // //        // }
423 | // //        vector<int> ans;
424 | // //        int m = matrix.size();
425 | // //        int n = matrix[0].size();
426 | // //        int row=0, col=0;        
427 | // //        bool up = true;
428 | // //
429 | // //        while(row<m && col<n){
430 | // //            if(up){
431 | // //                while(row>0 && col<n-1){
432 | // //                    ans.push_back(matrix[row][col]);
433 | // //                    row--;
434 | // //                    col++;
435 | // //                }
436 | // //                 ans.push_back(matrix[row][col]);
437 | // //                 if(col==n-1){
438 | // //                     row++;
439 | // //                 }
440 | // //                 else{
441 | // //                     col++;
442 | // //                 }
443 | // //            }
444 | // //            else{
445 | // //                while(col>0 && row<m-1){
446 | // //                 ans.push_back(matrix[row][col]);
447 | // //                 row++;
448 | // //                 col--;   
449 | // //                }
450 | // //                ans.push_back(matrix[row][col]);
451 | // //                if(row==m-1){
452 | // //                    col++;
453 | // //                }
454 | // //                else{
455 | // //                    row++;
456 | // //                }
457 | // //            }
458 | // //            up = !up; // Fix: Toggle the boolean variable 'up'
459 | // //        }
460 | // //        return ans;
461 | // //    }
462 | // //};
463 | 
464 | 
465 | 
466 | 
467 | // // Modular Exponentiation
468 | // //#include <bits/stdc++.h>
469 | // //
470 | // //int modularExponentiation(int x, int n, int m) {
471 | // //	int res = 1;
472 | // //	while(n>0){
473 | // //		if(n&1){
474 | // //			res = (1LL*(res) * (x)%m)%m;
475 | // //		}
476 | // //		x = (1LL * (x)%m * (x)%m) %m;
477 | // //		n = n>>1;
478 | // //	}
479 | // //	return res;
480 | // //}
481 | 


--------------------------------------------------------------------------------
/D10-Array.cpp:
--------------------------------------------------------------------------------
   1 | //152. Maximum Product Subarray
   2 | class Solution {
   3 | public:
   4 |     int maxProduct(vector<int>& nums) {
   5 |         int n = nums.size();
   6 |         int Max = nums[0], a = 1, b = 1;
   7 | 
   8 |         for(int i = 0; i < n; i++){
   9 |             a = (a == 0 ? 1 : a) * nums[i];
  10 |             b = (b == 0 ? 1 : b) * nums[n - 1 - i];
  11 |             
  12 |             Max = max(Max, max(a, b));
  13 |         }
  14 | 
  15 |         return Max;
  16 |     }
  17 | };
  18 | 
  19 | 
  20 | class Solution {
  21 | public:
  22 |     int maxProduct(vector<int>& nums) {
  23 |         int n = nums.size();
  24 |         if (n == 0) return 0;
  25 |         
  26 |         // Use long long to handle large products
  27 |         long long maxProd = nums[0];
  28 |         long long minProd = nums[0];
  29 |         long long result = nums[0];
  30 |         
  31 |         // Traverse the array starting from the second element
  32 |         for (int i = 1; i < n; i++) {
  33 |             // If nums[i] is negative, swap maxProd and minProd
  34 |             if (nums[i] < 0) {
  35 |                 swap(maxProd, minProd);
  36 |             }
  37 |             
  38 |             // Update maxProd and minProd
  39 |             maxProd = max((long long)nums[i], maxProd * nums[i]);
  40 |             minProd = min((long long)nums[i], minProd * nums[i]);
  41 |             
  42 |             // Update the result
  43 |             result = max(result, maxProd);
  44 |         }
  45 |         
  46 |         return (int)result; // Cast back to int before returning
  47 |     }
  48 | };
  49 | 
  50 | 
  51 | 
  52 | 
  53 | 
  54 | //42. Trapping Rain Water
  55 | class Solution {
  56 | public:
  57 |     int trap(vector<int>& height) {
  58 |         int n = height.size();
  59 |         int left[n];
  60 |         int right[n];
  61 |         left[0] = height[0];
  62 | 
  63 |         for(int i=1; i<n; i++){
  64 |             left[i] = max(left[i-1], height[i]);
  65 |         }
  66 |         right[n-1] = height[n-1];
  67 |         
  68 |         for(int i=n-2; i>=0; i--){
  69 |             right[i] = max(right[i+1], height[i]);
  70 |         }
  71 |         int ssum=0;
  72 |         for(int i=0; i<n; i++){
  73 |             ssum += (min(left[i], right[i]) - height[i]);
  74 |         }
  75 |         return ssum;
  76 |     }
  77 | };
  78 | 
  79 | class Solution {
  80 | public:
  81 |     int trap(vector<int>& height) {
  82 |         int min = height[0];
  83 |         vector<int> left;
  84 |         for(int i=0; i<height.size(); i++){
  85 |             min = max(min, height[i]);
  86 |             left.push_back(min);
  87 |         }   
  88 |         int Max = height[height.size()];
  89 |         vector<int> right;
  90 |         for(int i=height.size(); i>-0; i--){
  91 |             Max = max(Max, height[i]);
  92 |             right.push_back(Max);
  93 |         }   
  94 |         vector<int> sumarr;
  95 |         for(int i=0; i<height.size(); i++){
  96 |             int Sum = max(left[i],right[i]);
  97 |             int ans = Sum - height[i];
  98 |             sumarr.push_back(ans);
  99 |         }
 100 |         int ssum = 0;
 101 |         for(int i=0; i<sumarr.size(); i++){
 102 |             ssum += sumarr[i];
 103 |         }
 104 |         return ssum;
 105 |     }
 106 | };
 107 | 
 108 | //215. Kth Largest Element in an Array
 109 | 
 110 | class Solution {
 111 | public:
 112 |     int findKthLargest(vector<int>& nums, int k) {
 113 |         sort(nums.begin(), nums.end());
 114 |         int n = nums.size();
 115 |         return nums[n-k];
 116 |     }
 117 | };
 118 | 
 119 | 
 120 | class Solution {
 121 | public:
 122 |     int findKthLargest(vector<int>& nums, int k) {
 123 |         sort(nums.begin(), nums.end());
 124 |         int max=0;
 125 |         int size = nums.size();
 126 |         if(size==1){
 127 |                 return 1;
 128 |         }
 129 |         int till = size-k;
 130 |         for(int i=0; i<till; i++){
 131 |             if(nums[till]){
 132 |                 max=nums[till];
 133 |             }
 134 |         }
 135 |         return max;
 136 |     }
 137 | };
 138 | 
 139 | 
 140 | 
 141 | // Minimum Number of Pushes to Type Word II 
 142 | class Solution {
 143 | public:
 144 |     int minimumPushes(string word) {
 145 |         int arr[26] = {0}; // Initialize array with zeros
 146 |         
 147 |         for(char ch: word) {
 148 |             arr[ch - 'a']++;
 149 |         }
 150 |         
 151 |         // Convert C-style array to vector for using sort function
 152 |         vector<int> frequencies(arr, arr + 26);
 153 |         sort(frequencies.begin(), frequencies.end());
 154 |         
 155 |         int count = 0;
 156 |         int minKeyPress = 0;
 157 |         
 158 |         for(int i = 25; i >= 0; i--) {
 159 |             if(frequencies[i] == 0) break;
 160 |             int val = frequencies[i] * (count / 8 + 1);
 161 |             minKeyPress += val;
 162 |             count++; 
 163 |         }
 164 |         
 165 |         return minKeyPress;
 166 |     }
 167 | };
 168 | 
 169 | class Solution {
 170 | public:
 171 |     int minimumPushes(string word) {
 172 |         int arr[26];
 173 |         for(char ch: word){
 174 |             arr[ch-'a']++;
 175 |         }
 176 |         sort(arr[].begin(), arr[].end());
 177 | 
 178 |         int count=0;
 179 |         int minkeypress=0;
 180 | 
 181 |         for(int i=25; i>=0; i--){
 182 |             if(arr[i]==0) break;
 183 |             int val = arr[i]*(count/8 + 1);
 184 |             minkeypress += val;
 185 |             count++; 
 186 |         }
 187 |         return minkeypress;
 188 |     }
 189 | };
 190 | 
 191 | 
 192 | #include <unordered_map>
 193 | #include <string>
 194 | 
 195 | class Solution {
 196 | public:
 197 |     int minimumPushes(std::string word) {
 198 |         std::unordered_map<char, int> keyMap = {
 199 |             {'a', 2}, {'b', 3}, {'c', 4}, {'d', 5}, {'e', 6}, {'f', 2}, {'g', 2},
 200 |             {'h', 3}, {'i', 3}, {'j', 4}, {'k', 4}, {'l', 5}, {'m', 5}, {'n', 6},
 201 |             {'o', 6}, {'p', 7}, {'q', 7}, {'r', 7}, {'s', 7}, {'t', 8}, {'u', 8},
 202 |             {'v', 8}, {'w', 9}, {'x', 9}, {'y', 9}, {'z', 9}
 203 |         };
 204 |         
 205 |         int totalPushes = 0;
 206 |         for (char c : word) {
 207 |             totalPushes += keyMap[c];
 208 |         }
 209 |         
 210 |         return totalPushes;
 211 |     }
 212 | };
 213 | 
 214 | 
 215 | class Solution {
 216 | public:
 217 |     int minimumPushes(string word) {
 218 |         int two = 0, three = 0, four=0, five=0, six=0, seven=0, eight=0, nine=0;
 219 |         for( char c: word){
 220 |             if(word[c]=='a' || word[c]=='f' || word[c]=='g'){
 221 |                 two++;
 222 |             }
 223 |             if(word[c]=='b' || word[c]=='h' || word[c]=='i'){
 224 |                 three++;
 225 |             }
 226 |             if(word[c]=='c' || word[c]=='j' || word[c]=='k'){
 227 |                 four++;
 228 |             }
 229 |             if(word[c]=='d' || word[c]=='l' || word[c]=='m'){
 230 |                 five++;
 231 |             }
 232 |             if(word[c]=='e' || word[c]=='n' || word[c]=='o'){
 233 |                 six++;
 234 |             }
 235 |             if(word[c]=='p' || word[c]=='q' || word[c]=='r' || word[c]=='s'){
 236 |                 seven++;
 237 |             }
 238 |             if(word[c]=='t' || word[c]=='u' || word[c]=='v'){
 239 |                 eight++;
 240 |             }
 241 |             if(word[c]=='w' || word[c]=='x' || word[c]=='y' || word[c]=='z'){
 242 |                 nine++;
 243 |             }   
 244 |         }
 245 |         int ans = two+three+four+five+six+seven+eight+nine;
 246 |         return ans;
 247 |     }
 248 | };
 249 | 
 250 | 
 251 | //2053. Kth Distinct String in an Array
 252 | 
 253 | class Solution {
 254 | public:
 255 |     string kthDistinct(vector<string>& arr, int k) {
 256 |         unordered_map<string, int> mp;
 257 |         int i;
 258 | 
 259 |         for(i=0; i<arr.size(); i++){
 260 |             mp[arr[i]]++;
 261 |         }
 262 | 
 263 |         for(i=0; i<arr.size(); i++){
 264 |             if(mp[arr[i]]==1){
 265 |                 k--;
 266 |                 if(k==0)
 267 |                     return arr[i];
 268 |             }
 269 |         }
 270 |         return "";
 271 |     }
 272 | };
 273 | 
 274 | 
 275 | 
 276 | class Solution {
 277 | public:
 278 |     string kthDistinct(vector<string>& arr, int k) {
 279 |         vector<string>& ans;
 280 |         int  j=0, count=0;
 281 |         for(int i=0; i<arr.size(); i++){
 282 |             for(j=i+1; j<arr.size(); j++){
 283 |                 // if(arr[i]==arr[j]){
 284 |                 //     k--;
 285 |                 //     if(k==0){
 286 |                 //         ans = arr[j];
 287 |                 //     }
 288 |                 count++;
 289 |                 }
 290 |                 if(count>0){
 291 |                     ans = arr[i];
 292 |                 }
 293 |             }
 294 |             j=0;
 295 |         }
 296 |         // if(k==0){
 297 |         //     return ans;
 298 |         // }
 299 |         return ans;
 300 |     }
 301 | };
 302 | 
 303 | 
 304 | 
 305 | 
 306 | 
 307 | 
 308 | 
 309 | //1508. Range Sum of Sorted Subarray Sums
 310 | //SOLUTION-1
 311 | class Solution {
 312 | public:
 313 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
 314 |         const unsigned int M = 1000000007;
 315 |         vector<int> sums;
 316 |         
 317 |         // Generate all subarray sums
 318 |         for(int i = 0; i < n; i++) {
 319 |             int current_sum = 0;
 320 |             for(int j = i; j < n; j++) {
 321 |                 current_sum = (current_sum + nums[j]) % M;
 322 |                 sums.push_back(current_sum);
 323 |             }
 324 |         }
 325 | 
 326 |         // Sort the subarray sums
 327 |         sort(sums.begin(), sums.end());
 328 |         
 329 |         // Calculate the sum of elements from `left-1` to `right-1`
 330 |         long long result = 0;
 331 |         for(int i = left - 1; i < right; i++) {
 332 |             result = (result + sums[i]) % M;
 333 |         }
 334 |         
 335 |         return (int)result;
 336 |     }
 337 | };
 338 | 
 339 | 
 340 | //SOLUTION-2
 341 | class Solution {
 342 | public:
 343 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
 344 |         long long sum = 0;
 345 |         const unsigned int M = 1000000007;
 346 |         vector<int> csum;
 347 |         vector<int> sums;
 348 |         for(int i=0; i<n ; i++){
 349 |             sum = (sum+nums[i])%M;
 350 |             csum.push_back(sum);
 351 |         }
 352 | 
 353 |         for(int i=0; i<n; i++){
 354 |             sums.push_back(csum[i]);
 355 |             for(int j=i+1; j<n; j++){
 356 |                 sums.push_back(csum[j]-csum[i]);
 357 |             }
 358 |         }
 359 |         sort(sums.begin(), sums.end());
 360 |         sum=0;
 361 |         for(int i=left-1; i<=right-1; i++){
 362 |             sum += sums[i];
 363 |         }
 364 |         return sum;
 365 |     }
 366 | };
 367 | 
 368 | //33. Search in Rotated Sorted Array
 369 | class Solution {
 370 | public:
 371 |     int search(vector<int>& nums, int target) {
 372 |         int low=0; 
 373 |         int high = nums.size() -1;
 374 | 
 375 |         while( low <= high){
 376 |             int mid = (low + high) / 2;
 377 | 
 378 |             if(nums[mid] == target) return mid;
 379 | 
 380 |             if(nums[low] <= nums[mid]){
 381 |                 if(nums[low] <= target && target <= nums[mid]){
 382 |                     high = mid - 1;
 383 |                 }else{
 384 |                     low = mid + 1;
 385 |                 }
 386 |             }else{
 387 |                 if(nums[mid] <= target && target <= nums[high]){
 388 |                     low = mid + 1;
 389 |                 }else{
 390 |                     high = mid - 1;
 391 |                 }
 392 |             }
 393 |         }
 394 |         return -1;
 395 |     }
 396 | };
 397 | 
 398 | 
 399 | 
 400 | //1, 3, 4, 7, 9, 9 12, 56
 401 | 
 402 | int min = LLONG_MAX;
 403 | 
 404 | for(int i=0; i<n-m-1; i++){  //i+m-1<n -> i<n-m+1
 405 |     int diff = min(arr[i+m-1] - arr[i]);
 406 | }
 407 | return min;
 408 | 
 409 | 
 410 | 
 411 | 
 412 | 
 413 | //contains Duplicate
 414 | class Solution {
 415 | public:
 416 |     bool containsDuplicate(vector<int>& nums) {
 417 |         unordered_set<int >s(nums.begin(), nums.end());
 418 |         return nums.size() != s.size();
 419 |     }
 420 | };
 421 | 
 422 | 
 423 | class Solution {
 424 | public:
 425 |     bool containsDuplicate(vector<int>& nums) {
 426 |         sort(nums.begin(), nums.end());
 427 |         int n = nums.size();
 428 |         for(int i=1; i<n; i++){
 429 |             if(nums[i-1] == nums[i]){
 430 |                 return true;
 431 |             }
 432 |         }
 433 |         return false;
 434 |     }
 435 | };
 436 | 
 437 | 
 438 | //Minimum Swaps to Group All 1's Together
 439 | class Solution {
 440 | public:
 441 |     int minSwaps(vector<int>& nums) {
 442 |         int n = nums.size();
 443 |         int o=0, z=0;
 444 | 
 445 |         for(int i=0; i<n; i++){
 446 |             o += (nums[i]==1);
 447 |             z += (nums[i]==0);
 448 |         }
 449 | 
 450 |         nums.insert(nums.end(), nums.begin(), nums.end());
 451 | 
 452 |         int ans = n;
 453 |         int i=0, j=0, one=0;
 454 | 
 455 |         while(j<2*n){
 456 |             one += (nums[j]==1);
 457 | 
 458 |             if(j-i+1 == o){
 459 |                 ans = min(ans, o-one);
 460 |                 one -= (nums[i]==1);
 461 |                 i++;
 462 |             }
 463 |             j++;
 464 |         }
 465 |         return(ans==n ? 0:ans);
 466 |     }
 467 | };
 468 | 
 469 | //Count Senior number of citizen
 470 | 
 471 | int count = 0;
 472 | 
 473 | for(String s: arr){
 474 |     int a = (s[11]-'O' * 10)+(s[12]-'O');
 475 |     if(a>60){
 476 |         count++;
 477 |     }
 478 |     return count;
 479 | }
 480 | 
 481 | 
 482 | 
 483 | 
 484 | 
 485 | // 53. Maximum Subarray
 486 | // Approach 1: Brute Force
 487 | // for(int i=0 ->n){
 488 | // for(int j=0 ->n){
 489 | //     for(int k=i -> j){
 490 | //         sum = sum + arr[k];
 491 | //     }
 492 | // }
 493 | // }
 494 | 
 495 | // for(int i=0 ->n){
 496 | //     sum
 497 | // for(int j=0 ->n){
 498 | //     for(int k=i -> j){
 499 | //         sum = sum + arr[k];
 500 | //     }
 501 | // }
 502 | // }
 503 | 
 504 | 
 505 | 
 506 | class Solution {
 507 | public:
 508 |     int maxSubArray(vector<int>& nums) {
 509 |         int sum = 0;
 510 |         int maxi = nums[0];
 511 | 
 512 | 
 513 |         for(int i=0; i<nums.size(); i++){
 514 |             //Step-1
 515 |             sum = sum + nums[i];
 516 |             //Step-2
 517 |             maxi = max(maxi, sum);
 518 |             //Step-3
 519 |             if(sum<0)
 520 |                 sum=0;
 521 |         }
 522 |         return maxi;
 523 |     }
 524 | };
 525 | 
 526 | 
 527 | 
 528 | // DSA Sheet Sloving String Q-1: Maximum and minimum of an array using minimum number of comparisons
 529 | // Approch-1: set max and min from 1st two element of array
 530 | 
 531 | #include <iostream>
 532 | using namespace std;
 533 | 
 534 | int main() {
 535 |     int n = 0;
 536 |     int arr[n];
 537 |     int max, min;
 538 |     cin>>n;
 539 |     for(int i=0; i<n; i++){
 540 |         cin>>arr[i];
 541 |     }
 542 |     if(n==0){
 543 |         max = arr[0];
 544 |         min = arr[0];
 545 |     }
 546 |     if(n==1){
 547 |         if(arr[0]>arr[1]){
 548 |             max = arr[0];
 549 |             min = arr[1];
 550 |         }
 551 |         else{
 552 |             max = arr[1];
 553 |             min = arr[0];
 554 |         }
 555 |     }
 556 |     else{
 557 |         if(arr[0]>arr[1]){
 558 |             max = arr[0];
 559 |             min = arr[1];
 560 |         }
 561 |         else{
 562 |             max = arr[1];
 563 |             min = arr[0];
 564 |         }
 565 |         for(int i=2; i<n; i++){
 566 |             if(max<arr[i]){
 567 |                 max = arr[i];
 568 |             }
 569 |             if(min>arr[i]){
 570 |                 min = arr[i];
 571 |             }
 572 |         }
 573 |     }
 574 |     cout<<"Max" << max<<endl;
 575 |     cout<<"Min" << min<<endl;
 576 | 
 577 |     return 0;
 578 | }
 579 | 
 580 | 
 581 | // DSA Sheet Sloving String Q-2: Array Reverse
 582 | // Online C++ compiler to run C++ program online
 583 | #include <iostream>
 584 | using namespace std;
 585 | 
 586 | int main() {
 587 |     
 588 |     int n, i, j, temp;
 589 |     int arr[n];
 590 |     
 591 |     cin>>n;
 592 |     
 593 |     for(int k=0; k<n; k++){
 594 |         cin >> arr[k];
 595 |     }
 596 |     
 597 |     
 598 |     for(int i=0, j=n-1; i<n/2; i++,j--){
 599 |         temp = arr[i];
 600 |         arr[j] = arr[i];
 601 |         arr[j] = temp;
 602 |     }
 603 |     
 604 |     for(int k=0; k<n; k++){
 605 |         cout << arr[k];
 606 |     }
 607 |     
 608 |     
 609 |     return 0;
 610 | }
 611 | 
 612 | 
 613 | 
 614 | 
 615 | // #include <iostream>
 616 | // using namespace std;
 617 | 
 618 | // /* run this program using the console pauser or add your own getch, system("pause") or input loop */
 619 | 
 620 | // void printSum(int arr[][3], int row, int col){
 621 | // 	for(int row=0; row<3; row++){
 622 | // 		int sum = 0;
 623 | // 		for(int col=0; col<3; col++){
 624 | // 					sum += arr[row][col];	
 625 | // 		}
 626 | // 		cout<<sum<<" ";
 627 | // 	}
 628 | // }
 629 | 
 630 | // void printcolSum(int arr[][3], int row, int col){
 631 | // 	for(int row=0; row<3; row++){
 632 | // 		int sum = 0;
 633 | // 		for(int col=0; col<3; col++){
 634 | // 					sum += arr[col][row];	
 635 | // 		}
 636 | // 		cout<<sum<<" ";
 637 | // 	}
 638 | // }
 639 | 
 640 | 
 641 | // bool isPresent(int arr[][4], int target, int row, int col){
 642 | // 	for(int row=0; row<3; row++){
 643 | // 		for(int col=0; col<4; col++){
 644 | 			
 645 | // 			if(arr[row][col] == target){
 646 | // 				return 1;
 647 | // 			}
 648 | 			
 649 | // 		}
 650 | // 	}
 651 | // 	return 0;
 652 | // }
 653 | 
 654 | 
 655 | // int LargetRowSum(int arr[][3], int row, int col){
 656 | // 	int maxi = INT_MIN;
 657 | // 	int rowIndex = -1;
 658 | // 	for( int row=0; row<3; row++){
 659 | // 		int sum = 0;
 660 | // 		for(int col=0; col<3; col++){
 661 | // 			sum += arr[row][col];
 662 | // 		}
 663 | // 		if(sum > maxi){
 664 | // 			maxi = sum;
 665 | // 			rowIndex = row;
 666 | // 		}
 667 | // 	}
 668 | // 	return rowIndex;
 669 | // }
 670 | 
 671 | 
 672 | // int main(int argc, char** argv) {
 673 | 	
 674 | // //	int arr1[3][4] = {{1,11,111,1111}, {2,22,222,2222}, {3,33,333,3333}};
 675 | // 	int arr2[3][3];
 676 | 	
 677 | // 	for(int row=0; row<3; row++){
 678 | // 		for(int col=0; col<3; col++){
 679 | // 			cin>>arr2[row][col];
 680 | // 		}
 681 | // 	}
 682 | 	
 683 | // 	for(int row=0; row<3; row++){
 684 | // 		for(int col=0; col<3; col++){
 685 | // 			cout<<arr2[row][col]<<" ";
 686 | // 		}
 687 | // 		cout<<endl;
 688 | // 	}
 689 | 	
 690 | 
 691 | // //Sieve of Eratosthenes
 692 | 	
 693 | // //	class Solution {
 694 | // //public:
 695 | // //    int countPrimes(int n) {
 696 | // //        int count = 0;
 697 | // //       vector<bool> prime(n+1, true);
 698 | // //       prime[0] = prime[1] = false;
 699 | // //
 700 | // //       for(int i=2; i<n; i++){
 701 | // //           if(prime[i]){
 702 | // //               count++;
 703 | // //               for(int j=2*i; j<n; j=j+i){
 704 | // //                   prime[j] = 0;
 705 | // //              }
 706 | // //           }
 707 | // //       }
 708 | // //        return count;
 709 | // //    }
 710 | // //};
 711 | 	
 712 | 	
 713 | // //	class Solution {
 714 | // //    bool isPrime(int n){
 715 | // //        if(n<=1){
 716 | // //            return false;
 717 | // //        }
 718 | // //        for(int i=2; i<n; i++){
 719 | // //            if(n%i==0){
 720 | // //                return false;
 721 | // //            }
 722 | // //        }
 723 | // //        return true;
 724 | // //    }
 725 | // //public:
 726 | // //    int countPrimes(int n) {
 727 | // //        int count = 0;
 728 | // //        for(int i=2; i<n; i++){
 729 | // //            if(isPrime(i)){
 730 | // //                count++;
 731 | // //            }
 732 | // //        }
 733 | // //        return count;
 734 | // //    }
 735 | // //};
 736 | 	
 737 | 	
 738 | // //	int target;
 739 | // //	cin>>target;
 740 | 	
 741 | // //	if(isPresent(arr1, target, 3, 4)){	
 742 | // //		cout<<"Element Found";
 743 | // //	}	
 744 | // //	else{
 745 | // //		cout<<"Element Not Found";
 746 | // //	}
 747 | 
 748 | // 	cout<<"Row Wise Sum = ";
 749 | // 	printSum(arr2, 3, 3);
 750 | // 	cout<<endl;
 751 | // //	cout<<"Colum Wise Sum = ";
 752 | // //	printcolSum(arr2, 3, 3);
 753 | // //	cout<<endl;
 754 | 	
 755 | // 	cout<<"The Largest Sum is "<<LargetRowSum(arr2, 3,  3);	
 756 | 	
 757 | // 	return 0;
 758 | // }
 759 | 
 760 | 
 761 | // //54. Spiral Matrix
 762 | // //class Solution {
 763 | // //public:
 764 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
 765 | // //        int row = matrix.size();
 766 | // //        int col = matrix[0].size();
 767 | // //        vector<int> ans;
 768 | // //        int count = 0;
 769 | // //        int total = row*col;
 770 | // //        int startingRow = 0;
 771 | // //        int startingCol = 0;
 772 | // //        int endingRow = row-1;
 773 | // //        int endingCol = col-1;
 774 | // //
 775 | // //        while(count<total){
 776 | // //
 777 | // //            for(int i=startingCol; count<total && i<=endingCol; i++){
 778 | // //                ans.push_back(matrix[startingRow][i]);
 779 | // //                count++;
 780 | // //            }
 781 | // //            startingRow++;
 782 | // //
 783 | // //            for(int i=startingRow; count<total &&i<=endingRow; i++){
 784 | // //                ans.push_back(matrix[i][endingCol]);
 785 | // //                count++;
 786 | // //            }
 787 | // //            endingCol--;
 788 | // //
 789 | // //            for(int i=endingCol; count<total && i>=startingCol; i--){
 790 | // //                ans.push_back(matrix[endingRow][i]);
 791 | // //                count++;
 792 | // //            }
 793 | // //            endingRow--;
 794 | // //
 795 | // //            for(int i=endingRow; count<total && i>=startingRow; i--){
 796 | // //                ans.push_back(matrix[i][startingCol]);
 797 | // //                count++;
 798 | // //            }
 799 | // //            startingCol++;
 800 | // //        }
 801 | // //        return ans;
 802 | // //    }
 803 | // //};
 804 | // //class Solution {
 805 | // //public:
 806 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
 807 | // //        int n=matrix.size(),m=matrix[0].size();
 808 | // //        int left=0,top=0;
 809 | // //        int bottom=n-1,right=m-1;
 810 | // //        vector<int>ans;
 811 | // //        while(left<=right&&top<=bottom)
 812 | // //        {
 813 | // //            for(int i=left;i<=right;i++)
 814 | // //            {
 815 | // //                ans.push_back(matrix[top][i]);
 816 | // //            }
 817 | // //            top++;
 818 | // //            for(int i=top;i<=bottom;i++)
 819 | // //            {
 820 | // //                ans.push_back(matrix[i][right]);
 821 | // //            }
 822 | // //            right--;
 823 | // //            if(top<=bottom)
 824 | // //            {
 825 | // //                for(int i=right;i>=left;i--)
 826 | // //                {
 827 | // //                    ans.push_back(matrix[bottom][i]);
 828 | // //                }
 829 | // //                bottom--;
 830 | // //            }
 831 | // //            if(left<=right)
 832 | // //            {
 833 | // //                for(int i=bottom;i>=top;i--)
 834 | // //                {
 835 | // //                    ans.push_back(matrix[i][left]);
 836 | // //                }
 837 | // //                left++;
 838 | // //            }
 839 | // //        }
 840 | // //        return ans;
 841 | // //    }
 842 | // //};
 843 | 
 844 | // //Rotate Image by 90 degree
 845 | // //class Solution {
 846 | // //public:
 847 | // //    void rotate(vector<vector<int>>& matrix) {
 848 | // //        int n = matrix.size();
 849 | // //        for(int i=0; i<(n+1)/2;i++){
 850 | // //            for(int j=0; j<n/2; j++){
 851 | // //                int temp = matrix[n-1-j][i];
 852 | // //                matrix[n-1-j][i] = matrix[n-1-i][n-j-1];
 853 | // //                matrix[n-1-i][n-j-1] = matrix[j][n-1-i];
 854 | // //                matrix[j][n-1-i] = matrix[i][j];
 855 | // //                matrix[i][j] = temp;
 856 | // //            }
 857 | // //        }
 858 | // //    }
 859 | // //    
 860 | // //};
 861 | 
 862 | 
 863 | 
 864 | 
 865 | 
 866 | 
 867 | 
 868 | 
 869 | 
 870 | 
 871 | 
 872 | 
 873 | 
 874 | // //Print Like a Wave
 875 | // //#include <bits/stdc++.h> 
 876 | // //vector<int> wavePrint(vector<vector<int>> arr, int nRows, int mCols)
 877 | // //{
 878 | // //    vector<int> ans;
 879 | // //
 880 | // //    for(int col=0; col<mCols; col++){
 881 | // //        if(col&1){
 882 | // //            for(int row=nRows-1; row>=0; row--){
 883 | // //                ans.push_back(arr[row][col]);
 884 | // //            }
 885 | // //        }
 886 | // //        else{
 887 | // //            for(int row=0; row<nRows; row++){
 888 | // //                ans.push_back(arr[row][col]);
 889 | // //            }
 890 | // //        }
 891 | // //    }
 892 | // //    return ans;
 893 | // //}
 894 | 
 895 | 
 896 | 
 897 | 
 898 | // // 2d matrix
 899 | 
 900 | // //class Solution {
 901 | // //public:
 902 | // //    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
 903 | // //        // if(matrix.size()==0 || matrix[0].size()==0){
 904 | // //        //     return matrix;
 905 | // //        // }
 906 | // //        vector<int> ans;
 907 | // //        int m = matrix.size();
 908 | // //        int n = matrix[0].size();
 909 | // //        int row=0, col=0;        
 910 | // //        bool up = true;
 911 | // //
 912 | // //        while(row<m && col<n){
 913 | // //            if(up){
 914 | // //                while(row>0 && col<n-1){
 915 | // //                    ans.push_back(matrix[row][col]);
 916 | // //                    row--;
 917 | // //                    col++;
 918 | // //                }
 919 | // //                 ans.push_back(matrix[row][col]);
 920 | // //                 if(col==n-1){
 921 | // //                     row++;
 922 | // //                 }
 923 | // //                 else{
 924 | // //                     col++;
 925 | // //                 }
 926 | // //            }
 927 | // //            else{
 928 | // //                while(col>0 && row<m-1){
 929 | // //                 ans.push_back(matrix[row][col]);
 930 | // //                 row++;
 931 | // //                 col--;   
 932 | // //                }
 933 | // //                ans.push_back(matrix[row][col]);
 934 | // //                if(row==m-1){
 935 | // //                    col++;
 936 | // //                }
 937 | // //                else{
 938 | // //                    row++;
 939 | // //                }
 940 | // //            }
 941 | // //            up = !up; // Fix: Toggle the boolean variable 'up'
 942 | // //        }
 943 | // //        return ans;
 944 | // //    }
 945 | // //};
 946 | 
 947 | 
 948 | 
 949 | 
 950 | // // Modular Exponentiation
 951 | // //#include <bits/stdc++.h>
 952 | // //
 953 | // //int modularExponentiation(int x, int n, int m) {
 954 | // //	int res = 1;
 955 | // //	while(n>0){
 956 | // //		if(n&1){
 957 | // //			res = (1LL*(res) * (x)%m)%m;
 958 | // //		}
 959 | // //		x = (1LL * (x)%m * (x)%m) %m;
 960 | // //		n = n>>1;
 961 | // //	}
 962 | // //	return res;
 963 | // //}
 964 | 
 965 | 
 966 | 
 967 | #include <iostream>
 968 | using namespace std;
 969 | 
 970 | int main() {
 971 |     int t;
 972 |     cin >> t;  // Read number of test cases
 973 |     
 974 |     while (t--) {
 975 |         int a1, a2, b1, b2;
 976 |         cin >> a1 >> a2 >> b1 >> b2;
 977 |         
 978 |         int suneeWins = 0;
 979 |         
 980 |         // Compare the values in each possible way to determine Sunee's wins
 981 |         if ((a1 > b1 && a2 > b2) || (a1 > b2 && a2 > b1)) {
 982 |             suneeWins = 1;
 983 |         }
 984 |         
 985 |         cout << suneeWins << endl;
 986 |     }
 987 |     
 988 |     return 0;
 989 | }
 990 | 
 991 | 
 992 | #include <iostream>
 993 | using namespace std;
 994 | 
 995 | int main() {
 996 |     int t;
 997 |     cin >> t;  // Read number of test cases
 998 |     
 999 |     while(t--) {
1000 |         int n;
1001 |         cin >> n;  // Read the two-digit positive integer
1002 |         int sum = (n / 10) + (n % 10);  // Calculate the sum of the digits
1003 |         cout << sum << endl;  // Output the result
1004 |     }
1005 | 
1006 |         return 0;
1007 |     }
1008 | 
1009 | 
1010 | #include <iostream>
1011 | using namespace std;
1012 | 
1013 | 
1014 | int main() {
1015 |     int t;
1016 |     cin >> t;  // Read number of test cases
1017 |     
1018 |     while(t--){
1019 |         int a1, a2, b1, b2;
1020 |         cin>>a1>>a2>>b1>>b2;
1021 |         
1022 |         int suneeWins = 0;
1023 |         
1024 |         if(a1>b1 && a2>b2){
1025 |             suneeWins++;
1026 |         }
1027 |         if(a1>b2 && a2>b1){
1028 |             suneeWins++;
1029 |         }
1030 |         if(a2>b1 && a1>b2){
1031 |             suneeWins++;
1032 |         }
1033 |         
1034 |         cout<<suneeWins<<endl;
1035 |     }
1036 |     
1037 |     
1038 |     return 0;
1039 | }
1040 | 


--------------------------------------------------------------------------------
/D11-Array.cpp:
--------------------------------------------------------------------------------
   1 | //152. Maximum Product Subarray
   2 | class Solution {
   3 | public:
   4 |     int maxProduct(vector<int>& nums) {
   5 |         int n = nums.size();
   6 |         int Max = nums[0], a = 1, b = 1;
   7 | 
   8 |         for(int i = 0; i < n; i++){
   9 |             a = (a == 0 ? 1 : a) * nums[i];
  10 |             b = (b == 0 ? 1 : b) * nums[n - 1 - i];
  11 |             
  12 |             Max = max(Max, max(a, b));
  13 |         }
  14 | 
  15 |         return Max;
  16 |     }
  17 | };
  18 | 
  19 | 
  20 | class Solution {
  21 | public:
  22 |     int maxProduct(vector<int>& nums) {
  23 |         int n = nums.size();
  24 |         if (n == 0) return 0;
  25 |         
  26 |         // Use long long to handle large products
  27 |         long long maxProd = nums[0];
  28 |         long long minProd = nums[0];
  29 |         long long result = nums[0];
  30 |         
  31 |         // Traverse the array starting from the second element
  32 |         for (int i = 1; i < n; i++) {
  33 |             // If nums[i] is negative, swap maxProd and minProd
  34 |             if (nums[i] < 0) {
  35 |                 swap(maxProd, minProd);
  36 |             }
  37 |             
  38 |             // Update maxProd and minProd
  39 |             maxProd = max((long long)nums[i], maxProd * nums[i]);
  40 |             minProd = min((long long)nums[i], minProd * nums[i]);
  41 |             
  42 |             // Update the result
  43 |             result = max(result, maxProd);
  44 |         }
  45 |         
  46 |         return (int)result; // Cast back to int before returning
  47 |     }
  48 | };
  49 | 
  50 | 
  51 | 
  52 | 
  53 | 
  54 | //42. Trapping Rain Water
  55 | class Solution {
  56 | public:
  57 |     int trap(vector<int>& height) {
  58 |         int n = height.size();
  59 |         int left[n];
  60 |         int right[n];
  61 |         left[0] = height[0];
  62 | 
  63 |         for(int i=1; i<n; i++){
  64 |             left[i] = max(left[i-1], height[i]);
  65 |         }
  66 |         right[n-1] = height[n-1];
  67 |         
  68 |         for(int i=n-2; i>=0; i--){
  69 |             right[i] = max(right[i+1], height[i]);
  70 |         }
  71 |         int ssum=0;
  72 |         for(int i=0; i<n; i++){
  73 |             ssum += (min(left[i], right[i]) - height[i]);
  74 |         }
  75 |         return ssum;
  76 |     }
  77 | };
  78 | 
  79 | class Solution {
  80 | public:
  81 |     int trap(vector<int>& height) {
  82 |         int min = height[0];
  83 |         vector<int> left;
  84 |         for(int i=0; i<height.size(); i++){
  85 |             min = max(min, height[i]);
  86 |             left.push_back(min);
  87 |         }   
  88 |         int Max = height[height.size()];
  89 |         vector<int> right;
  90 |         for(int i=height.size(); i>-0; i--){
  91 |             Max = max(Max, height[i]);
  92 |             right.push_back(Max);
  93 |         }   
  94 |         vector<int> sumarr;
  95 |         for(int i=0; i<height.size(); i++){
  96 |             int Sum = max(left[i],right[i]);
  97 |             int ans = Sum - height[i];
  98 |             sumarr.push_back(ans);
  99 |         }
 100 |         int ssum = 0;
 101 |         for(int i=0; i<sumarr.size(); i++){
 102 |             ssum += sumarr[i];
 103 |         }
 104 |         return ssum;
 105 |     }
 106 | };
 107 | 
 108 | //215. Kth Largest Element in an Array
 109 | 
 110 | class Solution {
 111 | public:
 112 |     int findKthLargest(vector<int>& nums, int k) {
 113 |         sort(nums.begin(), nums.end());
 114 |         int n = nums.size();
 115 |         return nums[n-k];
 116 |     }
 117 | };
 118 | 
 119 | 
 120 | class Solution {
 121 | public:
 122 |     int findKthLargest(vector<int>& nums, int k) {
 123 |         sort(nums.begin(), nums.end());
 124 |         int max=0;
 125 |         int size = nums.size();
 126 |         if(size==1){
 127 |                 return 1;
 128 |         }
 129 |         int till = size-k;
 130 |         for(int i=0; i<till; i++){
 131 |             if(nums[till]){
 132 |                 max=nums[till];
 133 |             }
 134 |         }
 135 |         return max;
 136 |     }
 137 | };
 138 | 
 139 | 
 140 | 
 141 | // Minimum Number of Pushes to Type Word II 
 142 | class Solution {
 143 | public:
 144 |     int minimumPushes(string word) {
 145 |         int arr[26] = {0}; // Initialize array with zeros
 146 |         
 147 |         for(char ch: word) {
 148 |             arr[ch - 'a']++;
 149 |         }
 150 |         
 151 |         // Convert C-style array to vector for using sort function
 152 |         vector<int> frequencies(arr, arr + 26);
 153 |         sort(frequencies.begin(), frequencies.end());
 154 |         
 155 |         int count = 0;
 156 |         int minKeyPress = 0;
 157 |         
 158 |         for(int i = 25; i >= 0; i--) {
 159 |             if(frequencies[i] == 0) break;
 160 |             int val = frequencies[i] * (count / 8 + 1);
 161 |             minKeyPress += val;
 162 |             count++; 
 163 |         }
 164 |         
 165 |         return minKeyPress;
 166 |     }
 167 | };
 168 | 
 169 | class Solution {
 170 | public:
 171 |     int minimumPushes(string word) {
 172 |         int arr[26];
 173 |         for(char ch: word){
 174 |             arr[ch-'a']++;
 175 |         }
 176 |         sort(arr[].begin(), arr[].end());
 177 | 
 178 |         int count=0;
 179 |         int minkeypress=0;
 180 | 
 181 |         for(int i=25; i>=0; i--){
 182 |             if(arr[i]==0) break;
 183 |             int val = arr[i]*(count/8 + 1);
 184 |             minkeypress += val;
 185 |             count++; 
 186 |         }
 187 |         return minkeypress;
 188 |     }
 189 | };
 190 | 
 191 | 
 192 | #include <unordered_map>
 193 | #include <string>
 194 | 
 195 | class Solution {
 196 | public:
 197 |     int minimumPushes(std::string word) {
 198 |         std::unordered_map<char, int> keyMap = {
 199 |             {'a', 2}, {'b', 3}, {'c', 4}, {'d', 5}, {'e', 6}, {'f', 2}, {'g', 2},
 200 |             {'h', 3}, {'i', 3}, {'j', 4}, {'k', 4}, {'l', 5}, {'m', 5}, {'n', 6},
 201 |             {'o', 6}, {'p', 7}, {'q', 7}, {'r', 7}, {'s', 7}, {'t', 8}, {'u', 8},
 202 |             {'v', 8}, {'w', 9}, {'x', 9}, {'y', 9}, {'z', 9}
 203 |         };
 204 |         
 205 |         int totalPushes = 0;
 206 |         for (char c : word) {
 207 |             totalPushes += keyMap[c];
 208 |         }
 209 |         
 210 |         return totalPushes;
 211 |     }
 212 | };
 213 | 
 214 | 
 215 | class Solution {
 216 | public:
 217 |     int minimumPushes(string word) {
 218 |         int two = 0, three = 0, four=0, five=0, six=0, seven=0, eight=0, nine=0;
 219 |         for( char c: word){
 220 |             if(word[c]=='a' || word[c]=='f' || word[c]=='g'){
 221 |                 two++;
 222 |             }
 223 |             if(word[c]=='b' || word[c]=='h' || word[c]=='i'){
 224 |                 three++;
 225 |             }
 226 |             if(word[c]=='c' || word[c]=='j' || word[c]=='k'){
 227 |                 four++;
 228 |             }
 229 |             if(word[c]=='d' || word[c]=='l' || word[c]=='m'){
 230 |                 five++;
 231 |             }
 232 |             if(word[c]=='e' || word[c]=='n' || word[c]=='o'){
 233 |                 six++;
 234 |             }
 235 |             if(word[c]=='p' || word[c]=='q' || word[c]=='r' || word[c]=='s'){
 236 |                 seven++;
 237 |             }
 238 |             if(word[c]=='t' || word[c]=='u' || word[c]=='v'){
 239 |                 eight++;
 240 |             }
 241 |             if(word[c]=='w' || word[c]=='x' || word[c]=='y' || word[c]=='z'){
 242 |                 nine++;
 243 |             }   
 244 |         }
 245 |         int ans = two+three+four+five+six+seven+eight+nine;
 246 |         return ans;
 247 |     }
 248 | };
 249 | 
 250 | 
 251 | //2053. Kth Distinct String in an Array
 252 | 
 253 | class Solution {
 254 | public:
 255 |     string kthDistinct(vector<string>& arr, int k) {
 256 |         unordered_map<string, int> mp;
 257 |         int i;
 258 | 
 259 |         for(i=0; i<arr.size(); i++){
 260 |             mp[arr[i]]++;
 261 |         }
 262 | 
 263 |         for(i=0; i<arr.size(); i++){
 264 |             if(mp[arr[i]]==1){
 265 |                 k--;
 266 |                 if(k==0)
 267 |                     return arr[i];
 268 |             }
 269 |         }
 270 |         return "";
 271 |     }
 272 | };
 273 | 
 274 | 
 275 | 
 276 | class Solution {
 277 | public:
 278 |     string kthDistinct(vector<string>& arr, int k) {
 279 |         vector<string>& ans;
 280 |         int  j=0, count=0;
 281 |         for(int i=0; i<arr.size(); i++){
 282 |             for(j=i+1; j<arr.size(); j++){
 283 |                 // if(arr[i]==arr[j]){
 284 |                 //     k--;
 285 |                 //     if(k==0){
 286 |                 //         ans = arr[j];
 287 |                 //     }
 288 |                 count++;
 289 |                 }
 290 |                 if(count>0){
 291 |                     ans = arr[i];
 292 |                 }
 293 |             }
 294 |             j=0;
 295 |         }
 296 |         // if(k==0){
 297 |         //     return ans;
 298 |         // }
 299 |         return ans;
 300 |     }
 301 | };
 302 | 
 303 | 
 304 | 
 305 | 
 306 | 
 307 | 
 308 | 
 309 | //1508. Range Sum of Sorted Subarray Sums
 310 | //SOLUTION-1
 311 | class Solution {
 312 | public:
 313 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
 314 |         const unsigned int M = 1000000007;
 315 |         vector<int> sums;
 316 |         
 317 |         // Generate all subarray sums
 318 |         for(int i = 0; i < n; i++) {
 319 |             int current_sum = 0;
 320 |             for(int j = i; j < n; j++) {
 321 |                 current_sum = (current_sum + nums[j]) % M;
 322 |                 sums.push_back(current_sum);
 323 |             }
 324 |         }
 325 | 
 326 |         // Sort the subarray sums
 327 |         sort(sums.begin(), sums.end());
 328 |         
 329 |         // Calculate the sum of elements from `left-1` to `right-1`
 330 |         long long result = 0;
 331 |         for(int i = left - 1; i < right; i++) {
 332 |             result = (result + sums[i]) % M;
 333 |         }
 334 |         
 335 |         return (int)result;
 336 |     }
 337 | };
 338 | 
 339 | 
 340 | //SOLUTION-2
 341 | class Solution {
 342 | public:
 343 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
 344 |         long long sum = 0;
 345 |         const unsigned int M = 1000000007;
 346 |         vector<int> csum;
 347 |         vector<int> sums;
 348 |         for(int i=0; i<n ; i++){
 349 |             sum = (sum+nums[i])%M;
 350 |             csum.push_back(sum);
 351 |         }
 352 | 
 353 |         for(int i=0; i<n; i++){
 354 |             sums.push_back(csum[i]);
 355 |             for(int j=i+1; j<n; j++){
 356 |                 sums.push_back(csum[j]-csum[i]);
 357 |             }
 358 |         }
 359 |         sort(sums.begin(), sums.end());
 360 |         sum=0;
 361 |         for(int i=left-1; i<=right-1; i++){
 362 |             sum += sums[i];
 363 |         }
 364 |         return sum;
 365 |     }
 366 | };
 367 | 
 368 | //33. Search in Rotated Sorted Array
 369 | class Solution {
 370 | public:
 371 |     int search(vector<int>& nums, int target) {
 372 |         int low=0; 
 373 |         int high = nums.size() -1;
 374 | 
 375 |         while( low <= high){
 376 |             int mid = (low + high) / 2;
 377 | 
 378 |             if(nums[mid] == target) return mid;
 379 | 
 380 |             if(nums[low] <= nums[mid]){
 381 |                 if(nums[low] <= target && target <= nums[mid]){
 382 |                     high = mid - 1;
 383 |                 }else{
 384 |                     low = mid + 1;
 385 |                 }
 386 |             }else{
 387 |                 if(nums[mid] <= target && target <= nums[high]){
 388 |                     low = mid + 1;
 389 |                 }else{
 390 |                     high = mid - 1;
 391 |                 }
 392 |             }
 393 |         }
 394 |         return -1;
 395 |     }
 396 | };
 397 | 
 398 | 
 399 | 
 400 | //1, 3, 4, 7, 9, 9 12, 56
 401 | 
 402 | int min = LLONG_MAX;
 403 | 
 404 | for(int i=0; i<n-m-1; i++){  //i+m-1<n -> i<n-m+1
 405 |     int diff = min(arr[i+m-1] - arr[i]);
 406 | }
 407 | return min;
 408 | 
 409 | 
 410 | 
 411 | 
 412 | 
 413 | //contains Duplicate
 414 | class Solution {
 415 | public:
 416 |     bool containsDuplicate(vector<int>& nums) {
 417 |         unordered_set<int >s(nums.begin(), nums.end());
 418 |         return nums.size() != s.size();
 419 |     }
 420 | };
 421 | 
 422 | 
 423 | class Solution {
 424 | public:
 425 |     bool containsDuplicate(vector<int>& nums) {
 426 |         sort(nums.begin(), nums.end());
 427 |         int n = nums.size();
 428 |         for(int i=1; i<n; i++){
 429 |             if(nums[i-1] == nums[i]){
 430 |                 return true;
 431 |             }
 432 |         }
 433 |         return false;
 434 |     }
 435 | };
 436 | 
 437 | 
 438 | //Minimum Swaps to Group All 1's Together
 439 | class Solution {
 440 | public:
 441 |     int minSwaps(vector<int>& nums) {
 442 |         int n = nums.size();
 443 |         int o=0, z=0;
 444 | 
 445 |         for(int i=0; i<n; i++){
 446 |             o += (nums[i]==1);
 447 |             z += (nums[i]==0);
 448 |         }
 449 | 
 450 |         nums.insert(nums.end(), nums.begin(), nums.end());
 451 | 
 452 |         int ans = n;
 453 |         int i=0, j=0, one=0;
 454 | 
 455 |         while(j<2*n){
 456 |             one += (nums[j]==1);
 457 | 
 458 |             if(j-i+1 == o){
 459 |                 ans = min(ans, o-one);
 460 |                 one -= (nums[i]==1);
 461 |                 i++;
 462 |             }
 463 |             j++;
 464 |         }
 465 |         return(ans==n ? 0:ans);
 466 |     }
 467 | };
 468 | 
 469 | //Count Senior number of citizen
 470 | 
 471 | int count = 0;
 472 | 
 473 | for(String s: arr){
 474 |     int a = (s[11]-'O' * 10)+(s[12]-'O');
 475 |     if(a>60){
 476 |         count++;
 477 |     }
 478 |     return count;
 479 | }
 480 | 
 481 | 
 482 | 
 483 | 
 484 | 
 485 | // 53. Maximum Subarray
 486 | // Approach 1: Brute Force
 487 | // for(int i=0 ->n){
 488 | // for(int j=0 ->n){
 489 | //     for(int k=i -> j){
 490 | //         sum = sum + arr[k];
 491 | //     }
 492 | // }
 493 | // }
 494 | 
 495 | // for(int i=0 ->n){
 496 | //     sum
 497 | // for(int j=0 ->n){
 498 | //     for(int k=i -> j){
 499 | //         sum = sum + arr[k];
 500 | //     }
 501 | // }
 502 | // }
 503 | 
 504 | 
 505 | 
 506 | class Solution {
 507 | public:
 508 |     int maxSubArray(vector<int>& nums) {
 509 |         int sum = 0;
 510 |         int maxi = nums[0];
 511 | 
 512 | 
 513 |         for(int i=0; i<nums.size(); i++){
 514 |             //Step-1
 515 |             sum = sum + nums[i];
 516 |             //Step-2
 517 |             maxi = max(maxi, sum);
 518 |             //Step-3
 519 |             if(sum<0)
 520 |                 sum=0;
 521 |         }
 522 |         return maxi;
 523 |     }
 524 | };
 525 | 
 526 | 
 527 | 
 528 | // DSA Sheet Sloving String Q-1: Maximum and minimum of an array using minimum number of comparisons
 529 | // Approch-1: set max and min from 1st two element of array
 530 | 
 531 | #include <iostream>
 532 | using namespace std;
 533 | 
 534 | int main() {
 535 |     int n = 0;
 536 |     int arr[n];
 537 |     int max, min;
 538 |     cin>>n;
 539 |     for(int i=0; i<n; i++){
 540 |         cin>>arr[i];
 541 |     }
 542 |     if(n==0){
 543 |         max = arr[0];
 544 |         min = arr[0];
 545 |     }
 546 |     if(n==1){
 547 |         if(arr[0]>arr[1]){
 548 |             max = arr[0];
 549 |             min = arr[1];
 550 |         }
 551 |         else{
 552 |             max = arr[1];
 553 |             min = arr[0];
 554 |         }
 555 |     }
 556 |     else{
 557 |         if(arr[0]>arr[1]){
 558 |             max = arr[0];
 559 |             min = arr[1];
 560 |         }
 561 |         else{
 562 |             max = arr[1];
 563 |             min = arr[0];
 564 |         }
 565 |         for(int i=2; i<n; i++){
 566 |             if(max<arr[i]){
 567 |                 max = arr[i];
 568 |             }
 569 |             if(min>arr[i]){
 570 |                 min = arr[i];
 571 |             }
 572 |         }
 573 |     }
 574 |     cout<<"Max" << max<<endl;
 575 |     cout<<"Min" << min<<endl;
 576 | 
 577 |     return 0;
 578 | }
 579 | 
 580 | 
 581 | // DSA Sheet Sloving String Q-2: Array Reverse
 582 | // Online C++ compiler to run C++ program online
 583 | #include <iostream>
 584 | using namespace std;
 585 | 
 586 | int main() {
 587 |     
 588 |     int n, i, j, temp;
 589 |     int arr[n];
 590 |     
 591 |     cin>>n;
 592 |     
 593 |     for(int k=0; k<n; k++){
 594 |         cin >> arr[k];
 595 |     }
 596 |     
 597 |     
 598 |     for(int i=0, j=n-1; i<n/2; i++,j--){
 599 |         temp = arr[i];
 600 |         arr[j] = arr[i];
 601 |         arr[j] = temp;
 602 |     }
 603 |     
 604 |     for(int k=0; k<n; k++){
 605 |         cout << arr[k];
 606 |     }
 607 |     
 608 |     
 609 |     return 0;
 610 | }
 611 | 
 612 | 
 613 | 
 614 | 
 615 | // #include <iostream>
 616 | // using namespace std;
 617 | 
 618 | // /* run this program using the console pauser or add your own getch, system("pause") or input loop */
 619 | 
 620 | // void printSum(int arr[][3], int row, int col){
 621 | // 	for(int row=0; row<3; row++){
 622 | // 		int sum = 0;
 623 | // 		for(int col=0; col<3; col++){
 624 | // 					sum += arr[row][col];	
 625 | // 		}
 626 | // 		cout<<sum<<" ";
 627 | // 	}
 628 | // }
 629 | 
 630 | // void printcolSum(int arr[][3], int row, int col){
 631 | // 	for(int row=0; row<3; row++){
 632 | // 		int sum = 0;
 633 | // 		for(int col=0; col<3; col++){
 634 | // 					sum += arr[col][row];	
 635 | // 		}
 636 | // 		cout<<sum<<" ";
 637 | // 	}
 638 | // }
 639 | 
 640 | 
 641 | // bool isPresent(int arr[][4], int target, int row, int col){
 642 | // 	for(int row=0; row<3; row++){
 643 | // 		for(int col=0; col<4; col++){
 644 | 			
 645 | // 			if(arr[row][col] == target){
 646 | // 				return 1;
 647 | // 			}
 648 | 			
 649 | // 		}
 650 | // 	}
 651 | // 	return 0;
 652 | // }
 653 | 
 654 | 
 655 | // int LargetRowSum(int arr[][3], int row, int col){
 656 | // 	int maxi = INT_MIN;
 657 | // 	int rowIndex = -1;
 658 | // 	for( int row=0; row<3; row++){
 659 | // 		int sum = 0;
 660 | // 		for(int col=0; col<3; col++){
 661 | // 			sum += arr[row][col];
 662 | // 		}
 663 | // 		if(sum > maxi){
 664 | // 			maxi = sum;
 665 | // 			rowIndex = row;
 666 | // 		}
 667 | // 	}
 668 | // 	return rowIndex;
 669 | // }
 670 | 
 671 | 
 672 | // int main(int argc, char** argv) {
 673 | 	
 674 | // //	int arr1[3][4] = {{1,11,111,1111}, {2,22,222,2222}, {3,33,333,3333}};
 675 | // 	int arr2[3][3];
 676 | 	
 677 | // 	for(int row=0; row<3; row++){
 678 | // 		for(int col=0; col<3; col++){
 679 | // 			cin>>arr2[row][col];
 680 | // 		}
 681 | // 	}
 682 | 	
 683 | // 	for(int row=0; row<3; row++){
 684 | // 		for(int col=0; col<3; col++){
 685 | // 			cout<<arr2[row][col]<<" ";
 686 | // 		}
 687 | // 		cout<<endl;
 688 | // 	}
 689 | 	
 690 | 
 691 | // //Sieve of Eratosthenes
 692 | 	
 693 | // //	class Solution {
 694 | // //public:
 695 | // //    int countPrimes(int n) {
 696 | // //        int count = 0;
 697 | // //       vector<bool> prime(n+1, true);
 698 | // //       prime[0] = prime[1] = false;
 699 | // //
 700 | // //       for(int i=2; i<n; i++){
 701 | // //           if(prime[i]){
 702 | // //               count++;
 703 | // //               for(int j=2*i; j<n; j=j+i){
 704 | // //                   prime[j] = 0;
 705 | // //              }
 706 | // //           }
 707 | // //       }
 708 | // //        return count;
 709 | // //    }
 710 | // //};
 711 | 	
 712 | 	
 713 | // //	class Solution {
 714 | // //    bool isPrime(int n){
 715 | // //        if(n<=1){
 716 | // //            return false;
 717 | // //        }
 718 | // //        for(int i=2; i<n; i++){
 719 | // //            if(n%i==0){
 720 | // //                return false;
 721 | // //            }
 722 | // //        }
 723 | // //        return true;
 724 | // //    }
 725 | // //public:
 726 | // //    int countPrimes(int n) {
 727 | // //        int count = 0;
 728 | // //        for(int i=2; i<n; i++){
 729 | // //            if(isPrime(i)){
 730 | // //                count++;
 731 | // //            }
 732 | // //        }
 733 | // //        return count;
 734 | // //    }
 735 | // //};
 736 | 	
 737 | 	
 738 | // //	int target;
 739 | // //	cin>>target;
 740 | 	
 741 | // //	if(isPresent(arr1, target, 3, 4)){	
 742 | // //		cout<<"Element Found";
 743 | // //	}	
 744 | // //	else{
 745 | // //		cout<<"Element Not Found";
 746 | // //	}
 747 | 
 748 | // 	cout<<"Row Wise Sum = ";
 749 | // 	printSum(arr2, 3, 3);
 750 | // 	cout<<endl;
 751 | // //	cout<<"Colum Wise Sum = ";
 752 | // //	printcolSum(arr2, 3, 3);
 753 | // //	cout<<endl;
 754 | 	
 755 | // 	cout<<"The Largest Sum is "<<LargetRowSum(arr2, 3,  3);	
 756 | 	
 757 | // 	return 0;
 758 | // }
 759 | 
 760 | 
 761 | // //54. Spiral Matrix
 762 | // //class Solution {
 763 | // //public:
 764 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
 765 | // //        int row = matrix.size();
 766 | // //        int col = matrix[0].size();
 767 | // //        vector<int> ans;
 768 | // //        int count = 0;
 769 | // //        int total = row*col;
 770 | // //        int startingRow = 0;
 771 | // //        int startingCol = 0;
 772 | // //        int endingRow = row-1;
 773 | // //        int endingCol = col-1;
 774 | // //
 775 | // //        while(count<total){
 776 | // //
 777 | // //            for(int i=startingCol; count<total && i<=endingCol; i++){
 778 | // //                ans.push_back(matrix[startingRow][i]);
 779 | // //                count++;
 780 | // //            }
 781 | // //            startingRow++;
 782 | // //
 783 | // //            for(int i=startingRow; count<total &&i<=endingRow; i++){
 784 | // //                ans.push_back(matrix[i][endingCol]);
 785 | // //                count++;
 786 | // //            }
 787 | // //            endingCol--;
 788 | // //
 789 | // //            for(int i=endingCol; count<total && i>=startingCol; i--){
 790 | // //                ans.push_back(matrix[endingRow][i]);
 791 | // //                count++;
 792 | // //            }
 793 | // //            endingRow--;
 794 | // //
 795 | // //            for(int i=endingRow; count<total && i>=startingRow; i--){
 796 | // //                ans.push_back(matrix[i][startingCol]);
 797 | // //                count++;
 798 | // //            }
 799 | // //            startingCol++;
 800 | // //        }
 801 | // //        return ans;
 802 | // //    }
 803 | // //};
 804 | // //class Solution {
 805 | // //public:
 806 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
 807 | // //        int n=matrix.size(),m=matrix[0].size();
 808 | // //        int left=0,top=0;
 809 | // //        int bottom=n-1,right=m-1;
 810 | // //        vector<int>ans;
 811 | // //        while(left<=right&&top<=bottom)
 812 | // //        {
 813 | // //            for(int i=left;i<=right;i++)
 814 | // //            {
 815 | // //                ans.push_back(matrix[top][i]);
 816 | // //            }
 817 | // //            top++;
 818 | // //            for(int i=top;i<=bottom;i++)
 819 | // //            {
 820 | // //                ans.push_back(matrix[i][right]);
 821 | // //            }
 822 | // //            right--;
 823 | // //            if(top<=bottom)
 824 | // //            {
 825 | // //                for(int i=right;i>=left;i--)
 826 | // //                {
 827 | // //                    ans.push_back(matrix[bottom][i]);
 828 | // //                }
 829 | // //                bottom--;
 830 | // //            }
 831 | // //            if(left<=right)
 832 | // //            {
 833 | // //                for(int i=bottom;i>=top;i--)
 834 | // //                {
 835 | // //                    ans.push_back(matrix[i][left]);
 836 | // //                }
 837 | // //                left++;
 838 | // //            }
 839 | // //        }
 840 | // //        return ans;
 841 | // //    }
 842 | // //};
 843 | 
 844 | // //Rotate Image by 90 degree
 845 | // //class Solution {
 846 | // //public:
 847 | // //    void rotate(vector<vector<int>>& matrix) {
 848 | // //        int n = matrix.size();
 849 | // //        for(int i=0; i<(n+1)/2;i++){
 850 | // //            for(int j=0; j<n/2; j++){
 851 | // //                int temp = matrix[n-1-j][i];
 852 | // //                matrix[n-1-j][i] = matrix[n-1-i][n-j-1];
 853 | // //                matrix[n-1-i][n-j-1] = matrix[j][n-1-i];
 854 | // //                matrix[j][n-1-i] = matrix[i][j];
 855 | // //                matrix[i][j] = temp;
 856 | // //            }
 857 | // //        }
 858 | // //    }
 859 | // //    
 860 | // //};
 861 | 
 862 | 
 863 | 
 864 | 
 865 | 
 866 | 
 867 | 
 868 | 
 869 | 
 870 | 
 871 | 
 872 | 
 873 | 
 874 | // //Print Like a Wave
 875 | // //#include <bits/stdc++.h> 
 876 | // //vector<int> wavePrint(vector<vector<int>> arr, int nRows, int mCols)
 877 | // //{
 878 | // //    vector<int> ans;
 879 | // //
 880 | // //    for(int col=0; col<mCols; col++){
 881 | // //        if(col&1){
 882 | // //            for(int row=nRows-1; row>=0; row--){
 883 | // //                ans.push_back(arr[row][col]);
 884 | // //            }
 885 | // //        }
 886 | // //        else{
 887 | // //            for(int row=0; row<nRows; row++){
 888 | // //                ans.push_back(arr[row][col]);
 889 | // //            }
 890 | // //        }
 891 | // //    }
 892 | // //    return ans;
 893 | // //}
 894 | 
 895 | 
 896 | 
 897 | 
 898 | // // 2d matrix
 899 | 
 900 | // //class Solution {
 901 | // //public:
 902 | // //    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
 903 | // //        // if(matrix.size()==0 || matrix[0].size()==0){
 904 | // //        //     return matrix;
 905 | // //        // }
 906 | // //        vector<int> ans;
 907 | // //        int m = matrix.size();
 908 | // //        int n = matrix[0].size();
 909 | // //        int row=0, col=0;        
 910 | // //        bool up = true;
 911 | // //
 912 | // //        while(row<m && col<n){
 913 | // //            if(up){
 914 | // //                while(row>0 && col<n-1){
 915 | // //                    ans.push_back(matrix[row][col]);
 916 | // //                    row--;
 917 | // //                    col++;
 918 | // //                }
 919 | // //                 ans.push_back(matrix[row][col]);
 920 | // //                 if(col==n-1){
 921 | // //                     row++;
 922 | // //                 }
 923 | // //                 else{
 924 | // //                     col++;
 925 | // //                 }
 926 | // //            }
 927 | // //            else{
 928 | // //                while(col>0 && row<m-1){
 929 | // //                 ans.push_back(matrix[row][col]);
 930 | // //                 row++;
 931 | // //                 col--;   
 932 | // //                }
 933 | // //                ans.push_back(matrix[row][col]);
 934 | // //                if(row==m-1){
 935 | // //                    col++;
 936 | // //                }
 937 | // //                else{
 938 | // //                    row++;
 939 | // //                }
 940 | // //            }
 941 | // //            up = !up; // Fix: Toggle the boolean variable 'up'
 942 | // //        }
 943 | // //        return ans;
 944 | // //    }
 945 | // //};
 946 | 
 947 | 
 948 | 
 949 | 
 950 | // // Modular Exponentiation
 951 | // //#include <bits/stdc++.h>
 952 | // //
 953 | // //int modularExponentiation(int x, int n, int m) {
 954 | // //	int res = 1;
 955 | // //	while(n>0){
 956 | // //		if(n&1){
 957 | // //			res = (1LL*(res) * (x)%m)%m;
 958 | // //		}
 959 | // //		x = (1LL * (x)%m * (x)%m) %m;
 960 | // //		n = n>>1;
 961 | // //	}
 962 | // //	return res;
 963 | // //}
 964 | 
 965 | 
 966 | 
 967 | #include <iostream>
 968 | using namespace std;
 969 | 
 970 | int main() {
 971 |     int t;
 972 |     cin >> t;  // Read number of test cases
 973 |     
 974 |     while (t--) {
 975 |         int a1, a2, b1, b2;
 976 |         cin >> a1 >> a2 >> b1 >> b2;
 977 |         
 978 |         int suneeWins = 0;
 979 |         
 980 |         // Compare the values in each possible way to determine Sunee's wins
 981 |         if ((a1 > b1 && a2 > b2) || (a1 > b2 && a2 > b1)) {
 982 |             suneeWins = 1;
 983 |         }
 984 |         
 985 |         cout << suneeWins << endl;
 986 |     }
 987 |     
 988 |     return 0;
 989 | }
 990 | 
 991 | 
 992 | #include <iostream>
 993 | using namespace std;
 994 | 
 995 | int main() {
 996 |     int t;
 997 |     cin >> t;  // Read number of test cases
 998 |     
 999 |     while(t--) {
1000 |         int n;
1001 |         cin >> n;  // Read the two-digit positive integer
1002 |         int sum = (n / 10) + (n % 10);  // Calculate the sum of the digits
1003 |         cout << sum << endl;  // Output the result
1004 |     }
1005 | 
1006 |         return 0;
1007 |     }
1008 | 
1009 | 
1010 | #include <iostream>
1011 | using namespace std;
1012 | 
1013 | 
1014 | int main() {
1015 |     int t;
1016 |     cin >> t;  // Read number of test cases
1017 |     
1018 |     while(t--){
1019 |         int a1, a2, b1, b2;
1020 |         cin>>a1>>a2>>b1>>b2;
1021 |         
1022 |         int suneeWins = 0;
1023 |         
1024 |         if(a1>b1 && a2>b2){
1025 |             suneeWins++;
1026 |         }
1027 |         if(a1>b2 && a2>b1){
1028 |             suneeWins++;
1029 |         }
1030 |         if(a2>b1 && a1>b2){
1031 |             suneeWins++;
1032 |         }
1033 |         
1034 |         cout<<suneeWins<<endl;
1035 |     }
1036 |     
1037 |     
1038 |     return 0;
1039 | }
1040 | 


--------------------------------------------------------------------------------
/D12-Array.cpp:
--------------------------------------------------------------------------------
   1 | //152. Maximum Product Subarray
   2 | class Solution {
   3 | public:
   4 |     int maxProduct(vector<int>& nums) {
   5 |         int n = nums.size();
   6 |         int Max = nums[0], a = 1, b = 1;
   7 | 
   8 |         for(int i = 0; i < n; i++){
   9 |             a = (a == 0 ? 1 : a) * nums[i];
  10 |             b = (b == 0 ? 1 : b) * nums[n - 1 - i];
  11 |             
  12 |             Max = max(Max, max(a, b));
  13 |         }
  14 | 
  15 |         return Max;
  16 |     }
  17 | };
  18 | 
  19 | 
  20 | class Solution {
  21 | public:
  22 |     int maxProduct(vector<int>& nums) {
  23 |         int n = nums.size();
  24 |         if (n == 0) return 0;
  25 |         
  26 |         // Use long long to handle large products
  27 |         long long maxProd = nums[0];
  28 |         long long minProd = nums[0];
  29 |         long long result = nums[0];
  30 |         
  31 |         // Traverse the array starting from the second element
  32 |         for (int i = 1; i < n; i++) {
  33 |             // If nums[i] is negative, swap maxProd and minProd
  34 |             if (nums[i] < 0) {
  35 |                 swap(maxProd, minProd);
  36 |             }
  37 |             
  38 |             // Update maxProd and minProd
  39 |             maxProd = max((long long)nums[i], maxProd * nums[i]);
  40 |             minProd = min((long long)nums[i], minProd * nums[i]);
  41 |             
  42 |             // Update the result
  43 |             result = max(result, maxProd);
  44 |         }
  45 |         
  46 |         return (int)result; // Cast back to int before returning
  47 |     }
  48 | };
  49 | 
  50 | 
  51 | 
  52 | 
  53 | 
  54 | //42. Trapping Rain Water
  55 | class Solution {
  56 | public:
  57 |     int trap(vector<int>& height) {
  58 |         int n = height.size();
  59 |         int left[n];
  60 |         int right[n];
  61 |         left[0] = height[0];
  62 | 
  63 |         for(int i=1; i<n; i++){
  64 |             left[i] = max(left[i-1], height[i]);
  65 |         }
  66 |         right[n-1] = height[n-1];
  67 |         
  68 |         for(int i=n-2; i>=0; i--){
  69 |             right[i] = max(right[i+1], height[i]);
  70 |         }
  71 |         int ssum=0;
  72 |         for(int i=0; i<n; i++){
  73 |             ssum += (min(left[i], right[i]) - height[i]);
  74 |         }
  75 |         return ssum;
  76 |     }
  77 | };
  78 | 
  79 | class Solution {
  80 | public:
  81 |     int trap(vector<int>& height) {
  82 |         int min = height[0];
  83 |         vector<int> left;
  84 |         for(int i=0; i<height.size(); i++){
  85 |             min = max(min, height[i]);
  86 |             left.push_back(min);
  87 |         }   
  88 |         int Max = height[height.size()];
  89 |         vector<int> right;
  90 |         for(int i=height.size(); i>-0; i--){
  91 |             Max = max(Max, height[i]);
  92 |             right.push_back(Max);
  93 |         }   
  94 |         vector<int> sumarr;
  95 |         for(int i=0; i<height.size(); i++){
  96 |             int Sum = max(left[i],right[i]);
  97 |             int ans = Sum - height[i];
  98 |             sumarr.push_back(ans);
  99 |         }
 100 |         int ssum = 0;
 101 |         for(int i=0; i<sumarr.size(); i++){
 102 |             ssum += sumarr[i];
 103 |         }
 104 |         return ssum;
 105 |     }
 106 | };
 107 | 
 108 | //215. Kth Largest Element in an Array
 109 | 
 110 | class Solution {
 111 | public:
 112 |     int findKthLargest(vector<int>& nums, int k) {
 113 |         sort(nums.begin(), nums.end());
 114 |         int n = nums.size();
 115 |         return nums[n-k];
 116 |     }
 117 | };
 118 | 
 119 | 
 120 | class Solution {
 121 | public:
 122 |     int findKthLargest(vector<int>& nums, int k) {
 123 |         sort(nums.begin(), nums.end());
 124 |         int max=0;
 125 |         int size = nums.size();
 126 |         if(size==1){
 127 |                 return 1;
 128 |         }
 129 |         int till = size-k;
 130 |         for(int i=0; i<till; i++){
 131 |             if(nums[till]){
 132 |                 max=nums[till];
 133 |             }
 134 |         }
 135 |         return max;
 136 |     }
 137 | };
 138 | 
 139 | 
 140 | 
 141 | // Minimum Number of Pushes to Type Word II 
 142 | class Solution {
 143 | public:
 144 |     int minimumPushes(string word) {
 145 |         int arr[26] = {0}; // Initialize array with zeros
 146 |         
 147 |         for(char ch: word) {
 148 |             arr[ch - 'a']++;
 149 |         }
 150 |         
 151 |         // Convert C-style array to vector for using sort function
 152 |         vector<int> frequencies(arr, arr + 26);
 153 |         sort(frequencies.begin(), frequencies.end());
 154 |         
 155 |         int count = 0;
 156 |         int minKeyPress = 0;
 157 |         
 158 |         for(int i = 25; i >= 0; i--) {
 159 |             if(frequencies[i] == 0) break;
 160 |             int val = frequencies[i] * (count / 8 + 1);
 161 |             minKeyPress += val;
 162 |             count++; 
 163 |         }
 164 |         
 165 |         return minKeyPress;
 166 |     }
 167 | };
 168 | 
 169 | class Solution {
 170 | public:
 171 |     int minimumPushes(string word) {
 172 |         int arr[26];
 173 |         for(char ch: word){
 174 |             arr[ch-'a']++;
 175 |         }
 176 |         sort(arr[].begin(), arr[].end());
 177 | 
 178 |         int count=0;
 179 |         int minkeypress=0;
 180 | 
 181 |         for(int i=25; i>=0; i--){
 182 |             if(arr[i]==0) break;
 183 |             int val = arr[i]*(count/8 + 1);
 184 |             minkeypress += val;
 185 |             count++; 
 186 |         }
 187 |         return minkeypress;
 188 |     }
 189 | };
 190 | 
 191 | 
 192 | #include <unordered_map>
 193 | #include <string>
 194 | 
 195 | class Solution {
 196 | public:
 197 |     int minimumPushes(std::string word) {
 198 |         std::unordered_map<char, int> keyMap = {
 199 |             {'a', 2}, {'b', 3}, {'c', 4}, {'d', 5}, {'e', 6}, {'f', 2}, {'g', 2},
 200 |             {'h', 3}, {'i', 3}, {'j', 4}, {'k', 4}, {'l', 5}, {'m', 5}, {'n', 6},
 201 |             {'o', 6}, {'p', 7}, {'q', 7}, {'r', 7}, {'s', 7}, {'t', 8}, {'u', 8},
 202 |             {'v', 8}, {'w', 9}, {'x', 9}, {'y', 9}, {'z', 9}
 203 |         };
 204 |         
 205 |         int totalPushes = 0;
 206 |         for (char c : word) {
 207 |             totalPushes += keyMap[c];
 208 |         }
 209 |         
 210 |         return totalPushes;
 211 |     }
 212 | };
 213 | 
 214 | 
 215 | class Solution {
 216 | public:
 217 |     int minimumPushes(string word) {
 218 |         int two = 0, three = 0, four=0, five=0, six=0, seven=0, eight=0, nine=0;
 219 |         for( char c: word){
 220 |             if(word[c]=='a' || word[c]=='f' || word[c]=='g'){
 221 |                 two++;
 222 |             }
 223 |             if(word[c]=='b' || word[c]=='h' || word[c]=='i'){
 224 |                 three++;
 225 |             }
 226 |             if(word[c]=='c' || word[c]=='j' || word[c]=='k'){
 227 |                 four++;
 228 |             }
 229 |             if(word[c]=='d' || word[c]=='l' || word[c]=='m'){
 230 |                 five++;
 231 |             }
 232 |             if(word[c]=='e' || word[c]=='n' || word[c]=='o'){
 233 |                 six++;
 234 |             }
 235 |             if(word[c]=='p' || word[c]=='q' || word[c]=='r' || word[c]=='s'){
 236 |                 seven++;
 237 |             }
 238 |             if(word[c]=='t' || word[c]=='u' || word[c]=='v'){
 239 |                 eight++;
 240 |             }
 241 |             if(word[c]=='w' || word[c]=='x' || word[c]=='y' || word[c]=='z'){
 242 |                 nine++;
 243 |             }   
 244 |         }
 245 |         int ans = two+three+four+five+six+seven+eight+nine;
 246 |         return ans;
 247 |     }
 248 | };
 249 | 
 250 | 
 251 | //2053. Kth Distinct String in an Array
 252 | 
 253 | class Solution {
 254 | public:
 255 |     string kthDistinct(vector<string>& arr, int k) {
 256 |         unordered_map<string, int> mp;
 257 |         int i;
 258 | 
 259 |         for(i=0; i<arr.size(); i++){
 260 |             mp[arr[i]]++;
 261 |         }
 262 | 
 263 |         for(i=0; i<arr.size(); i++){
 264 |             if(mp[arr[i]]==1){
 265 |                 k--;
 266 |                 if(k==0)
 267 |                     return arr[i];
 268 |             }
 269 |         }
 270 |         return "";
 271 |     }
 272 | };
 273 | 
 274 | 
 275 | 
 276 | class Solution {
 277 | public:
 278 |     string kthDistinct(vector<string>& arr, int k) {
 279 |         vector<string>& ans;
 280 |         int  j=0, count=0;
 281 |         for(int i=0; i<arr.size(); i++){
 282 |             for(j=i+1; j<arr.size(); j++){
 283 |                 // if(arr[i]==arr[j]){
 284 |                 //     k--;
 285 |                 //     if(k==0){
 286 |                 //         ans = arr[j];
 287 |                 //     }
 288 |                 count++;
 289 |                 }
 290 |                 if(count>0){
 291 |                     ans = arr[i];
 292 |                 }
 293 |             }
 294 |             j=0;
 295 |         }
 296 |         // if(k==0){
 297 |         //     return ans;
 298 |         // }
 299 |         return ans;
 300 |     }
 301 | };
 302 | 
 303 | 
 304 | 
 305 | 
 306 | 
 307 | 
 308 | 
 309 | //1508. Range Sum of Sorted Subarray Sums
 310 | //SOLUTION-1
 311 | class Solution {
 312 | public:
 313 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
 314 |         const unsigned int M = 1000000007;
 315 |         vector<int> sums;
 316 |         
 317 |         // Generate all subarray sums
 318 |         for(int i = 0; i < n; i++) {
 319 |             int current_sum = 0;
 320 |             for(int j = i; j < n; j++) {
 321 |                 current_sum = (current_sum + nums[j]) % M;
 322 |                 sums.push_back(current_sum);
 323 |             }
 324 |         }
 325 | 
 326 |         // Sort the subarray sums
 327 |         sort(sums.begin(), sums.end());
 328 |         
 329 |         // Calculate the sum of elements from `left-1` to `right-1`
 330 |         long long result = 0;
 331 |         for(int i = left - 1; i < right; i++) {
 332 |             result = (result + sums[i]) % M;
 333 |         }
 334 |         
 335 |         return (int)result;
 336 |     }
 337 | };
 338 | 
 339 | 
 340 | //SOLUTION-2
 341 | class Solution {
 342 | public:
 343 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
 344 |         long long sum = 0;
 345 |         const unsigned int M = 1000000007;
 346 |         vector<int> csum;
 347 |         vector<int> sums;
 348 |         for(int i=0; i<n ; i++){
 349 |             sum = (sum+nums[i])%M;
 350 |             csum.push_back(sum);
 351 |         }
 352 | 
 353 |         for(int i=0; i<n; i++){
 354 |             sums.push_back(csum[i]);
 355 |             for(int j=i+1; j<n; j++){
 356 |                 sums.push_back(csum[j]-csum[i]);
 357 |             }
 358 |         }
 359 |         sort(sums.begin(), sums.end());
 360 |         sum=0;
 361 |         for(int i=left-1; i<=right-1; i++){
 362 |             sum += sums[i];
 363 |         }
 364 |         return sum;
 365 |     }
 366 | };
 367 | 
 368 | //33. Search in Rotated Sorted Array
 369 | class Solution {
 370 | public:
 371 |     int search(vector<int>& nums, int target) {
 372 |         int low=0; 
 373 |         int high = nums.size() -1;
 374 | 
 375 |         while( low <= high){
 376 |             int mid = (low + high) / 2;
 377 | 
 378 |             if(nums[mid] == target) return mid;
 379 | 
 380 |             if(nums[low] <= nums[mid]){
 381 |                 if(nums[low] <= target && target <= nums[mid]){
 382 |                     high = mid - 1;
 383 |                 }else{
 384 |                     low = mid + 1;
 385 |                 }
 386 |             }else{
 387 |                 if(nums[mid] <= target && target <= nums[high]){
 388 |                     low = mid + 1;
 389 |                 }else{
 390 |                     high = mid - 1;
 391 |                 }
 392 |             }
 393 |         }
 394 |         return -1;
 395 |     }
 396 | };
 397 | 
 398 | 
 399 | 
 400 | //1, 3, 4, 7, 9, 9 12, 56
 401 | 
 402 | int min = LLONG_MAX;
 403 | 
 404 | for(int i=0; i<n-m-1; i++){  //i+m-1<n -> i<n-m+1
 405 |     int diff = min(arr[i+m-1] - arr[i]);
 406 | }
 407 | return min;
 408 | 
 409 | 
 410 | 
 411 | 
 412 | 
 413 | //contains Duplicate
 414 | class Solution {
 415 | public:
 416 |     bool containsDuplicate(vector<int>& nums) {
 417 |         unordered_set<int >s(nums.begin(), nums.end());
 418 |         return nums.size() != s.size();
 419 |     }
 420 | };
 421 | 
 422 | 
 423 | class Solution {
 424 | public:
 425 |     bool containsDuplicate(vector<int>& nums) {
 426 |         sort(nums.begin(), nums.end());
 427 |         int n = nums.size();
 428 |         for(int i=1; i<n; i++){
 429 |             if(nums[i-1] == nums[i]){
 430 |                 return true;
 431 |             }
 432 |         }
 433 |         return false;
 434 |     }
 435 | };
 436 | 
 437 | 
 438 | //Minimum Swaps to Group All 1's Together
 439 | class Solution {
 440 | public:
 441 |     int minSwaps(vector<int>& nums) {
 442 |         int n = nums.size();
 443 |         int o=0, z=0;
 444 | 
 445 |         for(int i=0; i<n; i++){
 446 |             o += (nums[i]==1);
 447 |             z += (nums[i]==0);
 448 |         }
 449 | 
 450 |         nums.insert(nums.end(), nums.begin(), nums.end());
 451 | 
 452 |         int ans = n;
 453 |         int i=0, j=0, one=0;
 454 | 
 455 |         while(j<2*n){
 456 |             one += (nums[j]==1);
 457 | 
 458 |             if(j-i+1 == o){
 459 |                 ans = min(ans, o-one);
 460 |                 one -= (nums[i]==1);
 461 |                 i++;
 462 |             }
 463 |             j++;
 464 |         }
 465 |         return(ans==n ? 0:ans);
 466 |     }
 467 | };
 468 | 
 469 | //Count Senior number of citizen
 470 | 
 471 | int count = 0;
 472 | 
 473 | for(String s: arr){
 474 |     int a = (s[11]-'O' * 10)+(s[12]-'O');
 475 |     if(a>60){
 476 |         count++;
 477 |     }
 478 |     return count;
 479 | }
 480 | 
 481 | 
 482 | 
 483 | 
 484 | 
 485 | // 53. Maximum Subarray
 486 | // Approach 1: Brute Force
 487 | // for(int i=0 ->n){
 488 | // for(int j=0 ->n){
 489 | //     for(int k=i -> j){
 490 | //         sum = sum + arr[k];
 491 | //     }
 492 | // }
 493 | // }
 494 | 
 495 | // for(int i=0 ->n){
 496 | //     sum
 497 | // for(int j=0 ->n){
 498 | //     for(int k=i -> j){
 499 | //         sum = sum + arr[k];
 500 | //     }
 501 | // }
 502 | // }
 503 | 
 504 | 
 505 | 
 506 | class Solution {
 507 | public:
 508 |     int maxSubArray(vector<int>& nums) {
 509 |         int sum = 0;
 510 |         int maxi = nums[0];
 511 | 
 512 | 
 513 |         for(int i=0; i<nums.size(); i++){
 514 |             //Step-1
 515 |             sum = sum + nums[i];
 516 |             //Step-2
 517 |             maxi = max(maxi, sum);
 518 |             //Step-3
 519 |             if(sum<0)
 520 |                 sum=0;
 521 |         }
 522 |         return maxi;
 523 |     }
 524 | };
 525 | 
 526 | 
 527 | 
 528 | // DSA Sheet Sloving String Q-1: Maximum and minimum of an array using minimum number of comparisons
 529 | // Approch-1: set max and min from 1st two element of array
 530 | 
 531 | #include <iostream>
 532 | using namespace std;
 533 | 
 534 | int main() {
 535 |     int n = 0;
 536 |     int arr[n];
 537 |     int max, min;
 538 |     cin>>n;
 539 |     for(int i=0; i<n; i++){
 540 |         cin>>arr[i];
 541 |     }
 542 |     if(n==0){
 543 |         max = arr[0];
 544 |         min = arr[0];
 545 |     }
 546 |     if(n==1){
 547 |         if(arr[0]>arr[1]){
 548 |             max = arr[0];
 549 |             min = arr[1];
 550 |         }
 551 |         else{
 552 |             max = arr[1];
 553 |             min = arr[0];
 554 |         }
 555 |     }
 556 |     else{
 557 |         if(arr[0]>arr[1]){
 558 |             max = arr[0];
 559 |             min = arr[1];
 560 |         }
 561 |         else{
 562 |             max = arr[1];
 563 |             min = arr[0];
 564 |         }
 565 |         for(int i=2; i<n; i++){
 566 |             if(max<arr[i]){
 567 |                 max = arr[i];
 568 |             }
 569 |             if(min>arr[i]){
 570 |                 min = arr[i];
 571 |             }
 572 |         }
 573 |     }
 574 |     cout<<"Max" << max<<endl;
 575 |     cout<<"Min" << min<<endl;
 576 | 
 577 |     return 0;
 578 | }
 579 | 
 580 | 
 581 | // DSA Sheet Sloving String Q-2: Array Reverse
 582 | // Online C++ compiler to run C++ program online
 583 | #include <iostream>
 584 | using namespace std;
 585 | 
 586 | int main() {
 587 |     
 588 |     int n, i, j, temp;
 589 |     int arr[n];
 590 |     
 591 |     cin>>n;
 592 |     
 593 |     for(int k=0; k<n; k++){
 594 |         cin >> arr[k];
 595 |     }
 596 |     
 597 |     
 598 |     for(int i=0, j=n-1; i<n/2; i++,j--){
 599 |         temp = arr[i];
 600 |         arr[j] = arr[i];
 601 |         arr[j] = temp;
 602 |     }
 603 |     
 604 |     for(int k=0; k<n; k++){
 605 |         cout << arr[k];
 606 |     }
 607 |     
 608 |     
 609 |     return 0;
 610 | }
 611 | 
 612 | 
 613 | 
 614 | 
 615 | // #include <iostream>
 616 | // using namespace std;
 617 | 
 618 | // /* run this program using the console pauser or add your own getch, system("pause") or input loop */
 619 | 
 620 | // void printSum(int arr[][3], int row, int col){
 621 | // 	for(int row=0; row<3; row++){
 622 | // 		int sum = 0;
 623 | // 		for(int col=0; col<3; col++){
 624 | // 					sum += arr[row][col];	
 625 | // 		}
 626 | // 		cout<<sum<<" ";
 627 | // 	}
 628 | // }
 629 | 
 630 | // void printcolSum(int arr[][3], int row, int col){
 631 | // 	for(int row=0; row<3; row++){
 632 | // 		int sum = 0;
 633 | // 		for(int col=0; col<3; col++){
 634 | // 					sum += arr[col][row];	
 635 | // 		}
 636 | // 		cout<<sum<<" ";
 637 | // 	}
 638 | // }
 639 | 
 640 | 
 641 | // bool isPresent(int arr[][4], int target, int row, int col){
 642 | // 	for(int row=0; row<3; row++){
 643 | // 		for(int col=0; col<4; col++){
 644 | 			
 645 | // 			if(arr[row][col] == target){
 646 | // 				return 1;
 647 | // 			}
 648 | 			
 649 | // 		}
 650 | // 	}
 651 | // 	return 0;
 652 | // }
 653 | 
 654 | 
 655 | // int LargetRowSum(int arr[][3], int row, int col){
 656 | // 	int maxi = INT_MIN;
 657 | // 	int rowIndex = -1;
 658 | // 	for( int row=0; row<3; row++){
 659 | // 		int sum = 0;
 660 | // 		for(int col=0; col<3; col++){
 661 | // 			sum += arr[row][col];
 662 | // 		}
 663 | // 		if(sum > maxi){
 664 | // 			maxi = sum;
 665 | // 			rowIndex = row;
 666 | // 		}
 667 | // 	}
 668 | // 	return rowIndex;
 669 | // }
 670 | 
 671 | 
 672 | // int main(int argc, char** argv) {
 673 | 	
 674 | // //	int arr1[3][4] = {{1,11,111,1111}, {2,22,222,2222}, {3,33,333,3333}};
 675 | // 	int arr2[3][3];
 676 | 	
 677 | // 	for(int row=0; row<3; row++){
 678 | // 		for(int col=0; col<3; col++){
 679 | // 			cin>>arr2[row][col];
 680 | // 		}
 681 | // 	}
 682 | 	
 683 | // 	for(int row=0; row<3; row++){
 684 | // 		for(int col=0; col<3; col++){
 685 | // 			cout<<arr2[row][col]<<" ";
 686 | // 		}
 687 | // 		cout<<endl;
 688 | // 	}
 689 | 	
 690 | 
 691 | // //Sieve of Eratosthenes
 692 | 	
 693 | // //	class Solution {
 694 | // //public:
 695 | // //    int countPrimes(int n) {
 696 | // //        int count = 0;
 697 | // //       vector<bool> prime(n+1, true);
 698 | // //       prime[0] = prime[1] = false;
 699 | // //
 700 | // //       for(int i=2; i<n; i++){
 701 | // //           if(prime[i]){
 702 | // //               count++;
 703 | // //               for(int j=2*i; j<n; j=j+i){
 704 | // //                   prime[j] = 0;
 705 | // //              }
 706 | // //           }
 707 | // //       }
 708 | // //        return count;
 709 | // //    }
 710 | // //};
 711 | 	
 712 | 	
 713 | // //	class Solution {
 714 | // //    bool isPrime(int n){
 715 | // //        if(n<=1){
 716 | // //            return false;
 717 | // //        }
 718 | // //        for(int i=2; i<n; i++){
 719 | // //            if(n%i==0){
 720 | // //                return false;
 721 | // //            }
 722 | // //        }
 723 | // //        return true;
 724 | // //    }
 725 | // //public:
 726 | // //    int countPrimes(int n) {
 727 | // //        int count = 0;
 728 | // //        for(int i=2; i<n; i++){
 729 | // //            if(isPrime(i)){
 730 | // //                count++;
 731 | // //            }
 732 | // //        }
 733 | // //        return count;
 734 | // //    }
 735 | // //};
 736 | 	
 737 | 	
 738 | // //	int target;
 739 | // //	cin>>target;
 740 | 	
 741 | // //	if(isPresent(arr1, target, 3, 4)){	
 742 | // //		cout<<"Element Found";
 743 | // //	}	
 744 | // //	else{
 745 | // //		cout<<"Element Not Found";
 746 | // //	}
 747 | 
 748 | // 	cout<<"Row Wise Sum = ";
 749 | // 	printSum(arr2, 3, 3);
 750 | // 	cout<<endl;
 751 | // //	cout<<"Colum Wise Sum = ";
 752 | // //	printcolSum(arr2, 3, 3);
 753 | // //	cout<<endl;
 754 | 	
 755 | // 	cout<<"The Largest Sum is "<<LargetRowSum(arr2, 3,  3);	
 756 | 	
 757 | // 	return 0;
 758 | // }
 759 | 
 760 | 
 761 | // //54. Spiral Matrix
 762 | // //class Solution {
 763 | // //public:
 764 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
 765 | // //        int row = matrix.size();
 766 | // //        int col = matrix[0].size();
 767 | // //        vector<int> ans;
 768 | // //        int count = 0;
 769 | // //        int total = row*col;
 770 | // //        int startingRow = 0;
 771 | // //        int startingCol = 0;
 772 | // //        int endingRow = row-1;
 773 | // //        int endingCol = col-1;
 774 | // //
 775 | // //        while(count<total){
 776 | // //
 777 | // //            for(int i=startingCol; count<total && i<=endingCol; i++){
 778 | // //                ans.push_back(matrix[startingRow][i]);
 779 | // //                count++;
 780 | // //            }
 781 | // //            startingRow++;
 782 | // //
 783 | // //            for(int i=startingRow; count<total &&i<=endingRow; i++){
 784 | // //                ans.push_back(matrix[i][endingCol]);
 785 | // //                count++;
 786 | // //            }
 787 | // //            endingCol--;
 788 | // //
 789 | // //            for(int i=endingCol; count<total && i>=startingCol; i--){
 790 | // //                ans.push_back(matrix[endingRow][i]);
 791 | // //                count++;
 792 | // //            }
 793 | // //            endingRow--;
 794 | // //
 795 | // //            for(int i=endingRow; count<total && i>=startingRow; i--){
 796 | // //                ans.push_back(matrix[i][startingCol]);
 797 | // //                count++;
 798 | // //            }
 799 | // //            startingCol++;
 800 | // //        }
 801 | // //        return ans;
 802 | // //    }
 803 | // //};
 804 | // //class Solution {
 805 | // //public:
 806 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
 807 | // //        int n=matrix.size(),m=matrix[0].size();
 808 | // //        int left=0,top=0;
 809 | // //        int bottom=n-1,right=m-1;
 810 | // //        vector<int>ans;
 811 | // //        while(left<=right&&top<=bottom)
 812 | // //        {
 813 | // //            for(int i=left;i<=right;i++)
 814 | // //            {
 815 | // //                ans.push_back(matrix[top][i]);
 816 | // //            }
 817 | // //            top++;
 818 | // //            for(int i=top;i<=bottom;i++)
 819 | // //            {
 820 | // //                ans.push_back(matrix[i][right]);
 821 | // //            }
 822 | // //            right--;
 823 | // //            if(top<=bottom)
 824 | // //            {
 825 | // //                for(int i=right;i>=left;i--)
 826 | // //                {
 827 | // //                    ans.push_back(matrix[bottom][i]);
 828 | // //                }
 829 | // //                bottom--;
 830 | // //            }
 831 | // //            if(left<=right)
 832 | // //            {
 833 | // //                for(int i=bottom;i>=top;i--)
 834 | // //                {
 835 | // //                    ans.push_back(matrix[i][left]);
 836 | // //                }
 837 | // //                left++;
 838 | // //            }
 839 | // //        }
 840 | // //        return ans;
 841 | // //    }
 842 | // //};
 843 | 
 844 | // //Rotate Image by 90 degree
 845 | // //class Solution {
 846 | // //public:
 847 | // //    void rotate(vector<vector<int>>& matrix) {
 848 | // //        int n = matrix.size();
 849 | // //        for(int i=0; i<(n+1)/2;i++){
 850 | // //            for(int j=0; j<n/2; j++){
 851 | // //                int temp = matrix[n-1-j][i];
 852 | // //                matrix[n-1-j][i] = matrix[n-1-i][n-j-1];
 853 | // //                matrix[n-1-i][n-j-1] = matrix[j][n-1-i];
 854 | // //                matrix[j][n-1-i] = matrix[i][j];
 855 | // //                matrix[i][j] = temp;
 856 | // //            }
 857 | // //        }
 858 | // //    }
 859 | // //    
 860 | // //};
 861 | 
 862 | 
 863 | 
 864 | 
 865 | 
 866 | 
 867 | 
 868 | 
 869 | 
 870 | 
 871 | 
 872 | 
 873 | 
 874 | // //Print Like a Wave
 875 | // //#include <bits/stdc++.h> 
 876 | // //vector<int> wavePrint(vector<vector<int>> arr, int nRows, int mCols)
 877 | // //{
 878 | // //    vector<int> ans;
 879 | // //
 880 | // //    for(int col=0; col<mCols; col++){
 881 | // //        if(col&1){
 882 | // //            for(int row=nRows-1; row>=0; row--){
 883 | // //                ans.push_back(arr[row][col]);
 884 | // //            }
 885 | // //        }
 886 | // //        else{
 887 | // //            for(int row=0; row<nRows; row++){
 888 | // //                ans.push_back(arr[row][col]);
 889 | // //            }
 890 | // //        }
 891 | // //    }
 892 | // //    return ans;
 893 | // //}
 894 | 
 895 | 
 896 | 
 897 | 
 898 | // // 2d matrix
 899 | 
 900 | // //class Solution {
 901 | // //public:
 902 | // //    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
 903 | // //        // if(matrix.size()==0 || matrix[0].size()==0){
 904 | // //        //     return matrix;
 905 | // //        // }
 906 | // //        vector<int> ans;
 907 | // //        int m = matrix.size();
 908 | // //        int n = matrix[0].size();
 909 | // //        int row=0, col=0;        
 910 | // //        bool up = true;
 911 | // //
 912 | // //        while(row<m && col<n){
 913 | // //            if(up){
 914 | // //                while(row>0 && col<n-1){
 915 | // //                    ans.push_back(matrix[row][col]);
 916 | // //                    row--;
 917 | // //                    col++;
 918 | // //                }
 919 | // //                 ans.push_back(matrix[row][col]);
 920 | // //                 if(col==n-1){
 921 | // //                     row++;
 922 | // //                 }
 923 | // //                 else{
 924 | // //                     col++;
 925 | // //                 }
 926 | // //            }
 927 | // //            else{
 928 | // //                while(col>0 && row<m-1){
 929 | // //                 ans.push_back(matrix[row][col]);
 930 | // //                 row++;
 931 | // //                 col--;   
 932 | // //                }
 933 | // //                ans.push_back(matrix[row][col]);
 934 | // //                if(row==m-1){
 935 | // //                    col++;
 936 | // //                }
 937 | // //                else{
 938 | // //                    row++;
 939 | // //                }
 940 | // //            }
 941 | // //            up = !up; // Fix: Toggle the boolean variable 'up'
 942 | // //        }
 943 | // //        return ans;
 944 | // //    }
 945 | // //};
 946 | 
 947 | 
 948 | 
 949 | 
 950 | // // Modular Exponentiation
 951 | // //#include <bits/stdc++.h>
 952 | // //
 953 | // //int modularExponentiation(int x, int n, int m) {
 954 | // //	int res = 1;
 955 | // //	while(n>0){
 956 | // //		if(n&1){
 957 | // //			res = (1LL*(res) * (x)%m)%m;
 958 | // //		}
 959 | // //		x = (1LL * (x)%m * (x)%m) %m;
 960 | // //		n = n>>1;
 961 | // //	}
 962 | // //	return res;
 963 | // //}
 964 | 
 965 | 
 966 | 
 967 | #include <iostream>
 968 | using namespace std;
 969 | 
 970 | int main() {
 971 |     int t;
 972 |     cin >> t;  // Read number of test cases
 973 |     
 974 |     while (t--) {
 975 |         int a1, a2, b1, b2;
 976 |         cin >> a1 >> a2 >> b1 >> b2;
 977 |         
 978 |         int suneeWins = 0;
 979 |         
 980 |         // Compare the values in each possible way to determine Sunee's wins
 981 |         if ((a1 > b1 && a2 > b2) || (a1 > b2 && a2 > b1)) {
 982 |             suneeWins = 1;
 983 |         }
 984 |         
 985 |         cout << suneeWins << endl;
 986 |     }
 987 |     
 988 |     return 0;
 989 | }
 990 | 
 991 | 
 992 | #include <iostream>
 993 | using namespace std;
 994 | 
 995 | int main() {
 996 |     int t;
 997 |     cin >> t;  // Read number of test cases
 998 |     
 999 |     while(t--) {
1000 |         int n;
1001 |         cin >> n;  // Read the two-digit positive integer
1002 |         int sum = (n / 10) + (n % 10);  // Calculate the sum of the digits
1003 |         cout << sum << endl;  // Output the result
1004 |     }
1005 | 
1006 |         return 0;
1007 |     }
1008 | 
1009 | 
1010 | #include <iostream>
1011 | using namespace std;
1012 | 
1013 | 
1014 | int main() {
1015 |     int t;
1016 |     cin >> t;  // Read number of test cases
1017 |     
1018 |     while(t--){
1019 |         int a1, a2, b1, b2;
1020 |         cin>>a1>>a2>>b1>>b2;
1021 |         
1022 |         int suneeWins = 0;
1023 |         
1024 |         if(a1>b1 && a2>b2){
1025 |             suneeWins++;
1026 |         }
1027 |         if(a1>b2 && a2>b1){
1028 |             suneeWins++;
1029 |         }
1030 |         if(a2>b1 && a1>b2){
1031 |             suneeWins++;
1032 |         }
1033 |         
1034 |         cout<<suneeWins<<endl;
1035 |     }
1036 |     
1037 |     
1038 |     return 0;
1039 | }
1040 | 


--------------------------------------------------------------------------------
/D13-Array.cpp:
--------------------------------------------------------------------------------
   1 | //152. Maximum Product Subarray
   2 | class Solution {
   3 | public:
   4 |     int maxProduct(vector<int>& nums) {
   5 |         int n = nums.size();
   6 |         int Max = nums[0], a = 1, b = 1;
   7 | 
   8 |         for(int i = 0; i < n; i++){
   9 |             a = (a == 0 ? 1 : a) * nums[i];
  10 |             b = (b == 0 ? 1 : b) * nums[n - 1 - i];
  11 |             
  12 |             Max = max(Max, max(a, b));
  13 |         }
  14 | 
  15 |         return Max;
  16 |     }
  17 | };
  18 | 
  19 | 
  20 | class Solution {
  21 | public:
  22 |     int maxProduct(vector<int>& nums) {
  23 |         int n = nums.size();
  24 |         if (n == 0) return 0;
  25 |         
  26 |         // Use long long to handle large products
  27 |         long long maxProd = nums[0];
  28 |         long long minProd = nums[0];
  29 |         long long result = nums[0];
  30 |         
  31 |         // Traverse the array starting from the second element
  32 |         for (int i = 1; i < n; i++) {
  33 |             // If nums[i] is negative, swap maxProd and minProd
  34 |             if (nums[i] < 0) {
  35 |                 swap(maxProd, minProd);
  36 |             }
  37 |             
  38 |             // Update maxProd and minProd
  39 |             maxProd = max((long long)nums[i], maxProd * nums[i]);
  40 |             minProd = min((long long)nums[i], minProd * nums[i]);
  41 |             
  42 |             // Update the result
  43 |             result = max(result, maxProd);
  44 |         }
  45 |         
  46 |         return (int)result; // Cast back to int before returning
  47 |     }
  48 | };
  49 | 
  50 | 
  51 | 
  52 | 
  53 | 
  54 | //42. Trapping Rain Water
  55 | class Solution {
  56 | public:
  57 |     int trap(vector<int>& height) {
  58 |         int n = height.size();
  59 |         int left[n];
  60 |         int right[n];
  61 |         left[0] = height[0];
  62 | 
  63 |         for(int i=1; i<n; i++){
  64 |             left[i] = max(left[i-1], height[i]);
  65 |         }
  66 |         right[n-1] = height[n-1];
  67 |         
  68 |         for(int i=n-2; i>=0; i--){
  69 |             right[i] = max(right[i+1], height[i]);
  70 |         }
  71 |         int ssum=0;
  72 |         for(int i=0; i<n; i++){
  73 |             ssum += (min(left[i], right[i]) - height[i]);
  74 |         }
  75 |         return ssum;
  76 |     }
  77 | };
  78 | 
  79 | class Solution {
  80 | public:
  81 |     int trap(vector<int>& height) {
  82 |         int min = height[0];
  83 |         vector<int> left;
  84 |         for(int i=0; i<height.size(); i++){
  85 |             min = max(min, height[i]);
  86 |             left.push_back(min);
  87 |         }   
  88 |         int Max = height[height.size()];
  89 |         vector<int> right;
  90 |         for(int i=height.size(); i>-0; i--){
  91 |             Max = max(Max, height[i]);
  92 |             right.push_back(Max);
  93 |         }   
  94 |         vector<int> sumarr;
  95 |         for(int i=0; i<height.size(); i++){
  96 |             int Sum = max(left[i],right[i]);
  97 |             int ans = Sum - height[i];
  98 |             sumarr.push_back(ans);
  99 |         }
 100 |         int ssum = 0;
 101 |         for(int i=0; i<sumarr.size(); i++){
 102 |             ssum += sumarr[i];
 103 |         }
 104 |         return ssum;
 105 |     }
 106 | };
 107 | 
 108 | //215. Kth Largest Element in an Array
 109 | 
 110 | class Solution {
 111 | public:
 112 |     int findKthLargest(vector<int>& nums, int k) {
 113 |         sort(nums.begin(), nums.end());
 114 |         int n = nums.size();
 115 |         return nums[n-k];
 116 |     }
 117 | };
 118 | 
 119 | 
 120 | class Solution {
 121 | public:
 122 |     int findKthLargest(vector<int>& nums, int k) {
 123 |         sort(nums.begin(), nums.end());
 124 |         int max=0;
 125 |         int size = nums.size();
 126 |         if(size==1){
 127 |                 return 1;
 128 |         }
 129 |         int till = size-k;
 130 |         for(int i=0; i<till; i++){
 131 |             if(nums[till]){
 132 |                 max=nums[till];
 133 |             }
 134 |         }
 135 |         return max;
 136 |     }
 137 | };
 138 | 
 139 | 
 140 | 
 141 | // Minimum Number of Pushes to Type Word II 
 142 | class Solution {
 143 | public:
 144 |     int minimumPushes(string word) {
 145 |         int arr[26] = {0}; // Initialize array with zeros
 146 |         
 147 |         for(char ch: word) {
 148 |             arr[ch - 'a']++;
 149 |         }
 150 |         
 151 |         // Convert C-style array to vector for using sort function
 152 |         vector<int> frequencies(arr, arr + 26);
 153 |         sort(frequencies.begin(), frequencies.end());
 154 |         
 155 |         int count = 0;
 156 |         int minKeyPress = 0;
 157 |         
 158 |         for(int i = 25; i >= 0; i--) {
 159 |             if(frequencies[i] == 0) break;
 160 |             int val = frequencies[i] * (count / 8 + 1);
 161 |             minKeyPress += val;
 162 |             count++; 
 163 |         }
 164 |         
 165 |         return minKeyPress;
 166 |     }
 167 | };
 168 | 
 169 | class Solution {
 170 | public:
 171 |     int minimumPushes(string word) {
 172 |         int arr[26];
 173 |         for(char ch: word){
 174 |             arr[ch-'a']++;
 175 |         }
 176 |         sort(arr[].begin(), arr[].end());
 177 | 
 178 |         int count=0;
 179 |         int minkeypress=0;
 180 | 
 181 |         for(int i=25; i>=0; i--){
 182 |             if(arr[i]==0) break;
 183 |             int val = arr[i]*(count/8 + 1);
 184 |             minkeypress += val;
 185 |             count++; 
 186 |         }
 187 |         return minkeypress;
 188 |     }
 189 | };
 190 | 
 191 | 
 192 | #include <unordered_map>
 193 | #include <string>
 194 | 
 195 | class Solution {
 196 | public:
 197 |     int minimumPushes(std::string word) {
 198 |         std::unordered_map<char, int> keyMap = {
 199 |             {'a', 2}, {'b', 3}, {'c', 4}, {'d', 5}, {'e', 6}, {'f', 2}, {'g', 2},
 200 |             {'h', 3}, {'i', 3}, {'j', 4}, {'k', 4}, {'l', 5}, {'m', 5}, {'n', 6},
 201 |             {'o', 6}, {'p', 7}, {'q', 7}, {'r', 7}, {'s', 7}, {'t', 8}, {'u', 8},
 202 |             {'v', 8}, {'w', 9}, {'x', 9}, {'y', 9}, {'z', 9}
 203 |         };
 204 |         
 205 |         int totalPushes = 0;
 206 |         for (char c : word) {
 207 |             totalPushes += keyMap[c];
 208 |         }
 209 |         
 210 |         return totalPushes;
 211 |     }
 212 | };
 213 | 
 214 | 
 215 | class Solution {
 216 | public:
 217 |     int minimumPushes(string word) {
 218 |         int two = 0, three = 0, four=0, five=0, six=0, seven=0, eight=0, nine=0;
 219 |         for( char c: word){
 220 |             if(word[c]=='a' || word[c]=='f' || word[c]=='g'){
 221 |                 two++;
 222 |             }
 223 |             if(word[c]=='b' || word[c]=='h' || word[c]=='i'){
 224 |                 three++;
 225 |             }
 226 |             if(word[c]=='c' || word[c]=='j' || word[c]=='k'){
 227 |                 four++;
 228 |             }
 229 |             if(word[c]=='d' || word[c]=='l' || word[c]=='m'){
 230 |                 five++;
 231 |             }
 232 |             if(word[c]=='e' || word[c]=='n' || word[c]=='o'){
 233 |                 six++;
 234 |             }
 235 |             if(word[c]=='p' || word[c]=='q' || word[c]=='r' || word[c]=='s'){
 236 |                 seven++;
 237 |             }
 238 |             if(word[c]=='t' || word[c]=='u' || word[c]=='v'){
 239 |                 eight++;
 240 |             }
 241 |             if(word[c]=='w' || word[c]=='x' || word[c]=='y' || word[c]=='z'){
 242 |                 nine++;
 243 |             }   
 244 |         }
 245 |         int ans = two+three+four+five+six+seven+eight+nine;
 246 |         return ans;
 247 |     }
 248 | };
 249 | 
 250 | 
 251 | //2053. Kth Distinct String in an Array
 252 | 
 253 | class Solution {
 254 | public:
 255 |     string kthDistinct(vector<string>& arr, int k) {
 256 |         unordered_map<string, int> mp;
 257 |         int i;
 258 | 
 259 |         for(i=0; i<arr.size(); i++){
 260 |             mp[arr[i]]++;
 261 |         }
 262 | 
 263 |         for(i=0; i<arr.size(); i++){
 264 |             if(mp[arr[i]]==1){
 265 |                 k--;
 266 |                 if(k==0)
 267 |                     return arr[i];
 268 |             }
 269 |         }
 270 |         return "";
 271 |     }
 272 | };
 273 | 
 274 | 
 275 | 
 276 | class Solution {
 277 | public:
 278 |     string kthDistinct(vector<string>& arr, int k) {
 279 |         vector<string>& ans;
 280 |         int  j=0, count=0;
 281 |         for(int i=0; i<arr.size(); i++){
 282 |             for(j=i+1; j<arr.size(); j++){
 283 |                 // if(arr[i]==arr[j]){
 284 |                 //     k--;
 285 |                 //     if(k==0){
 286 |                 //         ans = arr[j];
 287 |                 //     }
 288 |                 count++;
 289 |                 }
 290 |                 if(count>0){
 291 |                     ans = arr[i];
 292 |                 }
 293 |             }
 294 |             j=0;
 295 |         }
 296 |         // if(k==0){
 297 |         //     return ans;
 298 |         // }
 299 |         return ans;
 300 |     }
 301 | };
 302 | 
 303 | 
 304 | 
 305 | 
 306 | 
 307 | 
 308 | 
 309 | //1508. Range Sum of Sorted Subarray Sums
 310 | //SOLUTION-1
 311 | class Solution {
 312 | public:
 313 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
 314 |         const unsigned int M = 1000000007;
 315 |         vector<int> sums;
 316 |         
 317 |         // Generate all subarray sums
 318 |         for(int i = 0; i < n; i++) {
 319 |             int current_sum = 0;
 320 |             for(int j = i; j < n; j++) {
 321 |                 current_sum = (current_sum + nums[j]) % M;
 322 |                 sums.push_back(current_sum);
 323 |             }
 324 |         }
 325 | 
 326 |         // Sort the subarray sums
 327 |         sort(sums.begin(), sums.end());
 328 |         
 329 |         // Calculate the sum of elements from `left-1` to `right-1`
 330 |         long long result = 0;
 331 |         for(int i = left - 1; i < right; i++) {
 332 |             result = (result + sums[i]) % M;
 333 |         }
 334 |         
 335 |         return (int)result;
 336 |     }
 337 | };
 338 | 
 339 | 
 340 | //SOLUTION-2
 341 | class Solution {
 342 | public:
 343 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
 344 |         long long sum = 0;
 345 |         const unsigned int M = 1000000007;
 346 |         vector<int> csum;
 347 |         vector<int> sums;
 348 |         for(int i=0; i<n ; i++){
 349 |             sum = (sum+nums[i])%M;
 350 |             csum.push_back(sum);
 351 |         }
 352 | 
 353 |         for(int i=0; i<n; i++){
 354 |             sums.push_back(csum[i]);
 355 |             for(int j=i+1; j<n; j++){
 356 |                 sums.push_back(csum[j]-csum[i]);
 357 |             }
 358 |         }
 359 |         sort(sums.begin(), sums.end());
 360 |         sum=0;
 361 |         for(int i=left-1; i<=right-1; i++){
 362 |             sum += sums[i];
 363 |         }
 364 |         return sum;
 365 |     }
 366 | };
 367 | 
 368 | //33. Search in Rotated Sorted Array
 369 | class Solution {
 370 | public:
 371 |     int search(vector<int>& nums, int target) {
 372 |         int low=0; 
 373 |         int high = nums.size() -1;
 374 | 
 375 |         while( low <= high){
 376 |             int mid = (low + high) / 2;
 377 | 
 378 |             if(nums[mid] == target) return mid;
 379 | 
 380 |             if(nums[low] <= nums[mid]){
 381 |                 if(nums[low] <= target && target <= nums[mid]){
 382 |                     high = mid - 1;
 383 |                 }else{
 384 |                     low = mid + 1;
 385 |                 }
 386 |             }else{
 387 |                 if(nums[mid] <= target && target <= nums[high]){
 388 |                     low = mid + 1;
 389 |                 }else{
 390 |                     high = mid - 1;
 391 |                 }
 392 |             }
 393 |         }
 394 |         return -1;
 395 |     }
 396 | };
 397 | 
 398 | 
 399 | 
 400 | //1, 3, 4, 7, 9, 9 12, 56
 401 | 
 402 | int min = LLONG_MAX;
 403 | 
 404 | for(int i=0; i<n-m-1; i++){  //i+m-1<n -> i<n-m+1
 405 |     int diff = min(arr[i+m-1] - arr[i]);
 406 | }
 407 | return min;
 408 | 
 409 | 
 410 | 
 411 | 
 412 | 
 413 | //contains Duplicate
 414 | class Solution {
 415 | public:
 416 |     bool containsDuplicate(vector<int>& nums) {
 417 |         unordered_set<int >s(nums.begin(), nums.end());
 418 |         return nums.size() != s.size();
 419 |     }
 420 | };
 421 | 
 422 | 
 423 | class Solution {
 424 | public:
 425 |     bool containsDuplicate(vector<int>& nums) {
 426 |         sort(nums.begin(), nums.end());
 427 |         int n = nums.size();
 428 |         for(int i=1; i<n; i++){
 429 |             if(nums[i-1] == nums[i]){
 430 |                 return true;
 431 |             }
 432 |         }
 433 |         return false;
 434 |     }
 435 | };
 436 | 
 437 | 
 438 | //Minimum Swaps to Group All 1's Together
 439 | class Solution {
 440 | public:
 441 |     int minSwaps(vector<int>& nums) {
 442 |         int n = nums.size();
 443 |         int o=0, z=0;
 444 | 
 445 |         for(int i=0; i<n; i++){
 446 |             o += (nums[i]==1);
 447 |             z += (nums[i]==0);
 448 |         }
 449 | 
 450 |         nums.insert(nums.end(), nums.begin(), nums.end());
 451 | 
 452 |         int ans = n;
 453 |         int i=0, j=0, one=0;
 454 | 
 455 |         while(j<2*n){
 456 |             one += (nums[j]==1);
 457 | 
 458 |             if(j-i+1 == o){
 459 |                 ans = min(ans, o-one);
 460 |                 one -= (nums[i]==1);
 461 |                 i++;
 462 |             }
 463 |             j++;
 464 |         }
 465 |         return(ans==n ? 0:ans);
 466 |     }
 467 | };
 468 | 
 469 | //Count Senior number of citizen
 470 | 
 471 | int count = 0;
 472 | 
 473 | for(String s: arr){
 474 |     int a = (s[11]-'O' * 10)+(s[12]-'O');
 475 |     if(a>60){
 476 |         count++;
 477 |     }
 478 |     return count;
 479 | }
 480 | 
 481 | 
 482 | 
 483 | 
 484 | 
 485 | // 53. Maximum Subarray
 486 | // Approach 1: Brute Force
 487 | // for(int i=0 ->n){
 488 | // for(int j=0 ->n){
 489 | //     for(int k=i -> j){
 490 | //         sum = sum + arr[k];
 491 | //     }
 492 | // }
 493 | // }
 494 | 
 495 | // for(int i=0 ->n){
 496 | //     sum
 497 | // for(int j=0 ->n){
 498 | //     for(int k=i -> j){
 499 | //         sum = sum + arr[k];
 500 | //     }
 501 | // }
 502 | // }
 503 | 
 504 | 
 505 | 
 506 | class Solution {
 507 | public:
 508 |     int maxSubArray(vector<int>& nums) {
 509 |         int sum = 0;
 510 |         int maxi = nums[0];
 511 | 
 512 | 
 513 |         for(int i=0; i<nums.size(); i++){
 514 |             //Step-1
 515 |             sum = sum + nums[i];
 516 |             //Step-2
 517 |             maxi = max(maxi, sum);
 518 |             //Step-3
 519 |             if(sum<0)
 520 |                 sum=0;
 521 |         }
 522 |         return maxi;
 523 |     }
 524 | };
 525 | 
 526 | 
 527 | 
 528 | // DSA Sheet Sloving String Q-1: Maximum and minimum of an array using minimum number of comparisons
 529 | // Approch-1: set max and min from 1st two element of array
 530 | 
 531 | #include <iostream>
 532 | using namespace std;
 533 | 
 534 | int main() {
 535 |     int n = 0;
 536 |     int arr[n];
 537 |     int max, min;
 538 |     cin>>n;
 539 |     for(int i=0; i<n; i++){
 540 |         cin>>arr[i];
 541 |     }
 542 |     if(n==0){
 543 |         max = arr[0];
 544 |         min = arr[0];
 545 |     }
 546 |     if(n==1){
 547 |         if(arr[0]>arr[1]){
 548 |             max = arr[0];
 549 |             min = arr[1];
 550 |         }
 551 |         else{
 552 |             max = arr[1];
 553 |             min = arr[0];
 554 |         }
 555 |     }
 556 |     else{
 557 |         if(arr[0]>arr[1]){
 558 |             max = arr[0];
 559 |             min = arr[1];
 560 |         }
 561 |         else{
 562 |             max = arr[1];
 563 |             min = arr[0];
 564 |         }
 565 |         for(int i=2; i<n; i++){
 566 |             if(max<arr[i]){
 567 |                 max = arr[i];
 568 |             }
 569 |             if(min>arr[i]){
 570 |                 min = arr[i];
 571 |             }
 572 |         }
 573 |     }
 574 |     cout<<"Max" << max<<endl;
 575 |     cout<<"Min" << min<<endl;
 576 | 
 577 |     return 0;
 578 | }
 579 | 
 580 | 
 581 | // DSA Sheet Sloving String Q-2: Array Reverse
 582 | // Online C++ compiler to run C++ program online
 583 | #include <iostream>
 584 | using namespace std;
 585 | 
 586 | int main() {
 587 |     
 588 |     int n, i, j, temp;
 589 |     int arr[n];
 590 |     
 591 |     cin>>n;
 592 |     
 593 |     for(int k=0; k<n; k++){
 594 |         cin >> arr[k];
 595 |     }
 596 |     
 597 |     
 598 |     for(int i=0, j=n-1; i<n/2; i++,j--){
 599 |         temp = arr[i];
 600 |         arr[j] = arr[i];
 601 |         arr[j] = temp;
 602 |     }
 603 |     
 604 |     for(int k=0; k<n; k++){
 605 |         cout << arr[k];
 606 |     }
 607 |     
 608 |     
 609 |     return 0;
 610 | }
 611 | 
 612 | 
 613 | 
 614 | 
 615 | // #include <iostream>
 616 | // using namespace std;
 617 | 
 618 | // /* run this program using the console pauser or add your own getch, system("pause") or input loop */
 619 | 
 620 | // void printSum(int arr[][3], int row, int col){
 621 | // 	for(int row=0; row<3; row++){
 622 | // 		int sum = 0;
 623 | // 		for(int col=0; col<3; col++){
 624 | // 					sum += arr[row][col];	
 625 | // 		}
 626 | // 		cout<<sum<<" ";
 627 | // 	}
 628 | // }
 629 | 
 630 | // void printcolSum(int arr[][3], int row, int col){
 631 | // 	for(int row=0; row<3; row++){
 632 | // 		int sum = 0;
 633 | // 		for(int col=0; col<3; col++){
 634 | // 					sum += arr[col][row];	
 635 | // 		}
 636 | // 		cout<<sum<<" ";
 637 | // 	}
 638 | // }
 639 | 
 640 | 
 641 | // bool isPresent(int arr[][4], int target, int row, int col){
 642 | // 	for(int row=0; row<3; row++){
 643 | // 		for(int col=0; col<4; col++){
 644 | 			
 645 | // 			if(arr[row][col] == target){
 646 | // 				return 1;
 647 | // 			}
 648 | 			
 649 | // 		}
 650 | // 	}
 651 | // 	return 0;
 652 | // }
 653 | 
 654 | 
 655 | // int LargetRowSum(int arr[][3], int row, int col){
 656 | // 	int maxi = INT_MIN;
 657 | // 	int rowIndex = -1;
 658 | // 	for( int row=0; row<3; row++){
 659 | // 		int sum = 0;
 660 | // 		for(int col=0; col<3; col++){
 661 | // 			sum += arr[row][col];
 662 | // 		}
 663 | // 		if(sum > maxi){
 664 | // 			maxi = sum;
 665 | // 			rowIndex = row;
 666 | // 		}
 667 | // 	}
 668 | // 	return rowIndex;
 669 | // }
 670 | 
 671 | 
 672 | // int main(int argc, char** argv) {
 673 | 	
 674 | // //	int arr1[3][4] = {{1,11,111,1111}, {2,22,222,2222}, {3,33,333,3333}};
 675 | // 	int arr2[3][3];
 676 | 	
 677 | // 	for(int row=0; row<3; row++){
 678 | // 		for(int col=0; col<3; col++){
 679 | // 			cin>>arr2[row][col];
 680 | // 		}
 681 | // 	}
 682 | 	
 683 | // 	for(int row=0; row<3; row++){
 684 | // 		for(int col=0; col<3; col++){
 685 | // 			cout<<arr2[row][col]<<" ";
 686 | // 		}
 687 | // 		cout<<endl;
 688 | // 	}
 689 | 	
 690 | 
 691 | // //Sieve of Eratosthenes
 692 | 	
 693 | // //	class Solution {
 694 | // //public:
 695 | // //    int countPrimes(int n) {
 696 | // //        int count = 0;
 697 | // //       vector<bool> prime(n+1, true);
 698 | // //       prime[0] = prime[1] = false;
 699 | // //
 700 | // //       for(int i=2; i<n; i++){
 701 | // //           if(prime[i]){
 702 | // //               count++;
 703 | // //               for(int j=2*i; j<n; j=j+i){
 704 | // //                   prime[j] = 0;
 705 | // //              }
 706 | // //           }
 707 | // //       }
 708 | // //        return count;
 709 | // //    }
 710 | // //};
 711 | 	
 712 | 	
 713 | // //	class Solution {
 714 | // //    bool isPrime(int n){
 715 | // //        if(n<=1){
 716 | // //            return false;
 717 | // //        }
 718 | // //        for(int i=2; i<n; i++){
 719 | // //            if(n%i==0){
 720 | // //                return false;
 721 | // //            }
 722 | // //        }
 723 | // //        return true;
 724 | // //    }
 725 | // //public:
 726 | // //    int countPrimes(int n) {
 727 | // //        int count = 0;
 728 | // //        for(int i=2; i<n; i++){
 729 | // //            if(isPrime(i)){
 730 | // //                count++;
 731 | // //            }
 732 | // //        }
 733 | // //        return count;
 734 | // //    }
 735 | // //};
 736 | 	
 737 | 	
 738 | // //	int target;
 739 | // //	cin>>target;
 740 | 	
 741 | // //	if(isPresent(arr1, target, 3, 4)){	
 742 | // //		cout<<"Element Found";
 743 | // //	}	
 744 | // //	else{
 745 | // //		cout<<"Element Not Found";
 746 | // //	}
 747 | 
 748 | // 	cout<<"Row Wise Sum = ";
 749 | // 	printSum(arr2, 3, 3);
 750 | // 	cout<<endl;
 751 | // //	cout<<"Colum Wise Sum = ";
 752 | // //	printcolSum(arr2, 3, 3);
 753 | // //	cout<<endl;
 754 | 	
 755 | // 	cout<<"The Largest Sum is "<<LargetRowSum(arr2, 3,  3);	
 756 | 	
 757 | // 	return 0;
 758 | // }
 759 | 
 760 | 
 761 | // //54. Spiral Matrix
 762 | // //class Solution {
 763 | // //public:
 764 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
 765 | // //        int row = matrix.size();
 766 | // //        int col = matrix[0].size();
 767 | // //        vector<int> ans;
 768 | // //        int count = 0;
 769 | // //        int total = row*col;
 770 | // //        int startingRow = 0;
 771 | // //        int startingCol = 0;
 772 | // //        int endingRow = row-1;
 773 | // //        int endingCol = col-1;
 774 | // //
 775 | // //        while(count<total){
 776 | // //
 777 | // //            for(int i=startingCol; count<total && i<=endingCol; i++){
 778 | // //                ans.push_back(matrix[startingRow][i]);
 779 | // //                count++;
 780 | // //            }
 781 | // //            startingRow++;
 782 | // //
 783 | // //            for(int i=startingRow; count<total &&i<=endingRow; i++){
 784 | // //                ans.push_back(matrix[i][endingCol]);
 785 | // //                count++;
 786 | // //            }
 787 | // //            endingCol--;
 788 | // //
 789 | // //            for(int i=endingCol; count<total && i>=startingCol; i--){
 790 | // //                ans.push_back(matrix[endingRow][i]);
 791 | // //                count++;
 792 | // //            }
 793 | // //            endingRow--;
 794 | // //
 795 | // //            for(int i=endingRow; count<total && i>=startingRow; i--){
 796 | // //                ans.push_back(matrix[i][startingCol]);
 797 | // //                count++;
 798 | // //            }
 799 | // //            startingCol++;
 800 | // //        }
 801 | // //        return ans;
 802 | // //    }
 803 | // //};
 804 | // //class Solution {
 805 | // //public:
 806 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
 807 | // //        int n=matrix.size(),m=matrix[0].size();
 808 | // //        int left=0,top=0;
 809 | // //        int bottom=n-1,right=m-1;
 810 | // //        vector<int>ans;
 811 | // //        while(left<=right&&top<=bottom)
 812 | // //        {
 813 | // //            for(int i=left;i<=right;i++)
 814 | // //            {
 815 | // //                ans.push_back(matrix[top][i]);
 816 | // //            }
 817 | // //            top++;
 818 | // //            for(int i=top;i<=bottom;i++)
 819 | // //            {
 820 | // //                ans.push_back(matrix[i][right]);
 821 | // //            }
 822 | // //            right--;
 823 | // //            if(top<=bottom)
 824 | // //            {
 825 | // //                for(int i=right;i>=left;i--)
 826 | // //                {
 827 | // //                    ans.push_back(matrix[bottom][i]);
 828 | // //                }
 829 | // //                bottom--;
 830 | // //            }
 831 | // //            if(left<=right)
 832 | // //            {
 833 | // //                for(int i=bottom;i>=top;i--)
 834 | // //                {
 835 | // //                    ans.push_back(matrix[i][left]);
 836 | // //                }
 837 | // //                left++;
 838 | // //            }
 839 | // //        }
 840 | // //        return ans;
 841 | // //    }
 842 | // //};
 843 | 
 844 | // //Rotate Image by 90 degree
 845 | // //class Solution {
 846 | // //public:
 847 | // //    void rotate(vector<vector<int>>& matrix) {
 848 | // //        int n = matrix.size();
 849 | // //        for(int i=0; i<(n+1)/2;i++){
 850 | // //            for(int j=0; j<n/2; j++){
 851 | // //                int temp = matrix[n-1-j][i];
 852 | // //                matrix[n-1-j][i] = matrix[n-1-i][n-j-1];
 853 | // //                matrix[n-1-i][n-j-1] = matrix[j][n-1-i];
 854 | // //                matrix[j][n-1-i] = matrix[i][j];
 855 | // //                matrix[i][j] = temp;
 856 | // //            }
 857 | // //        }
 858 | // //    }
 859 | // //    
 860 | // //};
 861 | 
 862 | 
 863 | 
 864 | 
 865 | 
 866 | 
 867 | 
 868 | 
 869 | 
 870 | 
 871 | 
 872 | 
 873 | 
 874 | // //Print Like a Wave
 875 | // //#include <bits/stdc++.h> 
 876 | // //vector<int> wavePrint(vector<vector<int>> arr, int nRows, int mCols)
 877 | // //{
 878 | // //    vector<int> ans;
 879 | // //
 880 | // //    for(int col=0; col<mCols; col++){
 881 | // //        if(col&1){
 882 | // //            for(int row=nRows-1; row>=0; row--){
 883 | // //                ans.push_back(arr[row][col]);
 884 | // //            }
 885 | // //        }
 886 | // //        else{
 887 | // //            for(int row=0; row<nRows; row++){
 888 | // //                ans.push_back(arr[row][col]);
 889 | // //            }
 890 | // //        }
 891 | // //    }
 892 | // //    return ans;
 893 | // //}
 894 | 
 895 | 
 896 | 
 897 | 
 898 | // // 2d matrix
 899 | 
 900 | // //class Solution {
 901 | // //public:
 902 | // //    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
 903 | // //        // if(matrix.size()==0 || matrix[0].size()==0){
 904 | // //        //     return matrix;
 905 | // //        // }
 906 | // //        vector<int> ans;
 907 | // //        int m = matrix.size();
 908 | // //        int n = matrix[0].size();
 909 | // //        int row=0, col=0;        
 910 | // //        bool up = true;
 911 | // //
 912 | // //        while(row<m && col<n){
 913 | // //            if(up){
 914 | // //                while(row>0 && col<n-1){
 915 | // //                    ans.push_back(matrix[row][col]);
 916 | // //                    row--;
 917 | // //                    col++;
 918 | // //                }
 919 | // //                 ans.push_back(matrix[row][col]);
 920 | // //                 if(col==n-1){
 921 | // //                     row++;
 922 | // //                 }
 923 | // //                 else{
 924 | // //                     col++;
 925 | // //                 }
 926 | // //            }
 927 | // //            else{
 928 | // //                while(col>0 && row<m-1){
 929 | // //                 ans.push_back(matrix[row][col]);
 930 | // //                 row++;
 931 | // //                 col--;   
 932 | // //                }
 933 | // //                ans.push_back(matrix[row][col]);
 934 | // //                if(row==m-1){
 935 | // //                    col++;
 936 | // //                }
 937 | // //                else{
 938 | // //                    row++;
 939 | // //                }
 940 | // //            }
 941 | // //            up = !up; // Fix: Toggle the boolean variable 'up'
 942 | // //        }
 943 | // //        return ans;
 944 | // //    }
 945 | // //};
 946 | 
 947 | 
 948 | 
 949 | 
 950 | // // Modular Exponentiation
 951 | // //#include <bits/stdc++.h>
 952 | // //
 953 | // //int modularExponentiation(int x, int n, int m) {
 954 | // //	int res = 1;
 955 | // //	while(n>0){
 956 | // //		if(n&1){
 957 | // //			res = (1LL*(res) * (x)%m)%m;
 958 | // //		}
 959 | // //		x = (1LL * (x)%m * (x)%m) %m;
 960 | // //		n = n>>1;
 961 | // //	}
 962 | // //	return res;
 963 | // //}
 964 | 
 965 | 
 966 | 
 967 | #include <iostream>
 968 | using namespace std;
 969 | 
 970 | int main() {
 971 |     int t;
 972 |     cin >> t;  // Read number of test cases
 973 |     
 974 |     while (t--) {
 975 |         int a1, a2, b1, b2;
 976 |         cin >> a1 >> a2 >> b1 >> b2;
 977 |         
 978 |         int suneeWins = 0;
 979 |         
 980 |         // Compare the values in each possible way to determine Sunee's wins
 981 |         if ((a1 > b1 && a2 > b2) || (a1 > b2 && a2 > b1)) {
 982 |             suneeWins = 1;
 983 |         }
 984 |         
 985 |         cout << suneeWins << endl;
 986 |     }
 987 |     
 988 |     return 0;
 989 | }
 990 | 
 991 | 
 992 | #include <iostream>
 993 | using namespace std;
 994 | 
 995 | int main() {
 996 |     int t;
 997 |     cin >> t;  // Read number of test cases
 998 |     
 999 |     while(t--) {
1000 |         int n;
1001 |         cin >> n;  // Read the two-digit positive integer
1002 |         int sum = (n / 10) + (n % 10);  // Calculate the sum of the digits
1003 |         cout << sum << endl;  // Output the result
1004 |     }
1005 | 
1006 |         return 0;
1007 |     }
1008 | 
1009 | 
1010 | #include <iostream>
1011 | using namespace std;
1012 | 
1013 | 
1014 | int main() {
1015 |     int t;
1016 |     cin >> t;  // Read number of test cases
1017 |     
1018 |     while(t--){
1019 |         int a1, a2, b1, b2;
1020 |         cin>>a1>>a2>>b1>>b2;
1021 |         
1022 |         int suneeWins = 0;
1023 |         
1024 |         if(a1>b1 && a2>b2){
1025 |             suneeWins++;
1026 |         }
1027 |         if(a1>b2 && a2>b1){
1028 |             suneeWins++;
1029 |         }
1030 |         if(a2>b1 && a1>b2){
1031 |             suneeWins++;
1032 |         }
1033 |         
1034 |         cout<<suneeWins<<endl;
1035 |     }
1036 |     
1037 |     
1038 |     return 0;
1039 | }
1040 | 


--------------------------------------------------------------------------------
/D2-String.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | // 53. Maximum Subarray
  3 | // Approach 1: Brute Force
  4 | // for(int i=0 ->n){
  5 | // for(int j=0 ->n){
  6 | //     for(int k=i -> j){
  7 | //         sum = sum + arr[k];
  8 | //     }
  9 | // }
 10 | // }
 11 | 
 12 | // for(int i=0 ->n){
 13 | //     sum
 14 | // for(int j=0 ->n){
 15 | //     for(int k=i -> j){
 16 | //         sum = sum + arr[k];
 17 | //     }
 18 | // }
 19 | // }
 20 | 
 21 | 
 22 | 
 23 | class Solution {
 24 | public:
 25 |     int maxSubArray(vector<int>& nums) {
 26 |         int sum = 0;
 27 |         int maxi = nums[0];
 28 | 
 29 | 
 30 |         for(int i=0; i<nums.size(); i++){
 31 |             //Step-1
 32 |             sum = sum + nums[i];
 33 |             //Step-2
 34 |             maxi = max(maxi, sum);
 35 |             //Step-3
 36 |             if(sum<0)
 37 |                 sum=0;
 38 |         }
 39 |         return maxi;
 40 |     }
 41 | };
 42 | 
 43 | 
 44 | 
 45 | // DSA Sheet Sloving String Q-1: Maximum and minimum of an array using minimum number of comparisons
 46 | // Approch-1: set max and min from 1st two element of array
 47 | 
 48 | #include <iostream>
 49 | using namespace std;
 50 | 
 51 | int main() {
 52 |     int n = 0;
 53 |     int arr[n];
 54 |     int max, min;
 55 |     cin>>n;
 56 |     for(int i=0; i<n; i++){
 57 |         cin>>arr[i];
 58 |     }
 59 |     if(n==0){
 60 |         max = arr[0];
 61 |         min = arr[0];
 62 |     }
 63 |     if(n==1){
 64 |         if(arr[0]>arr[1]){
 65 |             max = arr[0];
 66 |             min = arr[1];
 67 |         }
 68 |         else{
 69 |             max = arr[1];
 70 |             min = arr[0];
 71 |         }
 72 |     }
 73 |     else{
 74 |         if(arr[0]>arr[1]){
 75 |             max = arr[0];
 76 |             min = arr[1];
 77 |         }
 78 |         else{
 79 |             max = arr[1];
 80 |             min = arr[0];
 81 |         }
 82 |         for(int i=2; i<n; i++){
 83 |             if(max<arr[i]){
 84 |                 max = arr[i];
 85 |             }
 86 |             if(min>arr[i]){
 87 |                 min = arr[i];
 88 |             }
 89 |         }
 90 |     }
 91 |     cout<<"Max" << max<<endl;
 92 |     cout<<"Min" << min<<endl;
 93 | 
 94 |     return 0;
 95 | }
 96 | 
 97 | 
 98 | // DSA Sheet Sloving String Q-2: Array Reverse
 99 | // Online C++ compiler to run C++ program online
100 | #include <iostream>
101 | using namespace std;
102 | 
103 | int main() {
104 |     
105 |     int n, i, j, temp;
106 |     int arr[n];
107 |     
108 |     cin>>n;
109 |     
110 |     for(int k=0; k<n; k++){
111 |         cin >> arr[k];
112 |     }
113 |     
114 |     
115 |     for(int i=0, j=n-1; i<n/2; i++,j--){
116 |         temp = arr[i];
117 |         arr[j] = arr[i];
118 |         arr[j] = temp;
119 |     }
120 |     
121 |     for(int k=0; k<n; k++){
122 |         cout << arr[k];
123 |     }
124 |     
125 |     
126 |     return 0;
127 | }
128 | 
129 | 
130 | 
131 | 
132 | // #include <iostream>
133 | // using namespace std;
134 | 
135 | // /* run this program using the console pauser or add your own getch, system("pause") or input loop */
136 | 
137 | // void printSum(int arr[][3], int row, int col){
138 | // 	for(int row=0; row<3; row++){
139 | // 		int sum = 0;
140 | // 		for(int col=0; col<3; col++){
141 | // 					sum += arr[row][col];	
142 | // 		}
143 | // 		cout<<sum<<" ";
144 | // 	}
145 | // }
146 | 
147 | // void printcolSum(int arr[][3], int row, int col){
148 | // 	for(int row=0; row<3; row++){
149 | // 		int sum = 0;
150 | // 		for(int col=0; col<3; col++){
151 | // 					sum += arr[col][row];	
152 | // 		}
153 | // 		cout<<sum<<" ";
154 | // 	}
155 | // }
156 | 
157 | 
158 | // bool isPresent(int arr[][4], int target, int row, int col){
159 | // 	for(int row=0; row<3; row++){
160 | // 		for(int col=0; col<4; col++){
161 | 			
162 | // 			if(arr[row][col] == target){
163 | // 				return 1;
164 | // 			}
165 | 			
166 | // 		}
167 | // 	}
168 | // 	return 0;
169 | // }
170 | 
171 | 
172 | // int LargetRowSum(int arr[][3], int row, int col){
173 | // 	int maxi = INT_MIN;
174 | // 	int rowIndex = -1;
175 | // 	for( int row=0; row<3; row++){
176 | // 		int sum = 0;
177 | // 		for(int col=0; col<3; col++){
178 | // 			sum += arr[row][col];
179 | // 		}
180 | // 		if(sum > maxi){
181 | // 			maxi = sum;
182 | // 			rowIndex = row;
183 | // 		}
184 | // 	}
185 | // 	return rowIndex;
186 | // }
187 | 
188 | 
189 | // int main(int argc, char** argv) {
190 | 	
191 | // //	int arr1[3][4] = {{1,11,111,1111}, {2,22,222,2222}, {3,33,333,3333}};
192 | // 	int arr2[3][3];
193 | 	
194 | // 	for(int row=0; row<3; row++){
195 | // 		for(int col=0; col<3; col++){
196 | // 			cin>>arr2[row][col];
197 | // 		}
198 | // 	}
199 | 	
200 | // 	for(int row=0; row<3; row++){
201 | // 		for(int col=0; col<3; col++){
202 | // 			cout<<arr2[row][col]<<" ";
203 | // 		}
204 | // 		cout<<endl;
205 | // 	}
206 | 	
207 | 
208 | // //Sieve of Eratosthenes
209 | 	
210 | // //	class Solution {
211 | // //public:
212 | // //    int countPrimes(int n) {
213 | // //        int count = 0;
214 | // //       vector<bool> prime(n+1, true);
215 | // //       prime[0] = prime[1] = false;
216 | // //
217 | // //       for(int i=2; i<n; i++){
218 | // //           if(prime[i]){
219 | // //               count++;
220 | // //               for(int j=2*i; j<n; j=j+i){
221 | // //                   prime[j] = 0;
222 | // //              }
223 | // //           }
224 | // //       }
225 | // //        return count;
226 | // //    }
227 | // //};
228 | 	
229 | 	
230 | // //	class Solution {
231 | // //    bool isPrime(int n){
232 | // //        if(n<=1){
233 | // //            return false;
234 | // //        }
235 | // //        for(int i=2; i<n; i++){
236 | // //            if(n%i==0){
237 | // //                return false;
238 | // //            }
239 | // //        }
240 | // //        return true;
241 | // //    }
242 | // //public:
243 | // //    int countPrimes(int n) {
244 | // //        int count = 0;
245 | // //        for(int i=2; i<n; i++){
246 | // //            if(isPrime(i)){
247 | // //                count++;
248 | // //            }
249 | // //        }
250 | // //        return count;
251 | // //    }
252 | // //};
253 | 	
254 | 	
255 | // //	int target;
256 | // //	cin>>target;
257 | 	
258 | // //	if(isPresent(arr1, target, 3, 4)){	
259 | // //		cout<<"Element Found";
260 | // //	}	
261 | // //	else{
262 | // //		cout<<"Element Not Found";
263 | // //	}
264 | 
265 | // 	cout<<"Row Wise Sum = ";
266 | // 	printSum(arr2, 3, 3);
267 | // 	cout<<endl;
268 | // //	cout<<"Colum Wise Sum = ";
269 | // //	printcolSum(arr2, 3, 3);
270 | // //	cout<<endl;
271 | 	
272 | // 	cout<<"The Largest Sum is "<<LargetRowSum(arr2, 3,  3);	
273 | 	
274 | // 	return 0;
275 | // }
276 | 
277 | 
278 | // //54. Spiral Matrix
279 | // //class Solution {
280 | // //public:
281 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
282 | // //        int row = matrix.size();
283 | // //        int col = matrix[0].size();
284 | // //        vector<int> ans;
285 | // //        int count = 0;
286 | // //        int total = row*col;
287 | // //        int startingRow = 0;
288 | // //        int startingCol = 0;
289 | // //        int endingRow = row-1;
290 | // //        int endingCol = col-1;
291 | // //
292 | // //        while(count<total){
293 | // //
294 | // //            for(int i=startingCol; count<total && i<=endingCol; i++){
295 | // //                ans.push_back(matrix[startingRow][i]);
296 | // //                count++;
297 | // //            }
298 | // //            startingRow++;
299 | // //
300 | // //            for(int i=startingRow; count<total &&i<=endingRow; i++){
301 | // //                ans.push_back(matrix[i][endingCol]);
302 | // //                count++;
303 | // //            }
304 | // //            endingCol--;
305 | // //
306 | // //            for(int i=endingCol; count<total && i>=startingCol; i--){
307 | // //                ans.push_back(matrix[endingRow][i]);
308 | // //                count++;
309 | // //            }
310 | // //            endingRow--;
311 | // //
312 | // //            for(int i=endingRow; count<total && i>=startingRow; i--){
313 | // //                ans.push_back(matrix[i][startingCol]);
314 | // //                count++;
315 | // //            }
316 | // //            startingCol++;
317 | // //        }
318 | // //        return ans;
319 | // //    }
320 | // //};
321 | // //class Solution {
322 | // //public:
323 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
324 | // //        int n=matrix.size(),m=matrix[0].size();
325 | // //        int left=0,top=0;
326 | // //        int bottom=n-1,right=m-1;
327 | // //        vector<int>ans;
328 | // //        while(left<=right&&top<=bottom)
329 | // //        {
330 | // //            for(int i=left;i<=right;i++)
331 | // //            {
332 | // //                ans.push_back(matrix[top][i]);
333 | // //            }
334 | // //            top++;
335 | // //            for(int i=top;i<=bottom;i++)
336 | // //            {
337 | // //                ans.push_back(matrix[i][right]);
338 | // //            }
339 | // //            right--;
340 | // //            if(top<=bottom)
341 | // //            {
342 | // //                for(int i=right;i>=left;i--)
343 | // //                {
344 | // //                    ans.push_back(matrix[bottom][i]);
345 | // //                }
346 | // //                bottom--;
347 | // //            }
348 | // //            if(left<=right)
349 | // //            {
350 | // //                for(int i=bottom;i>=top;i--)
351 | // //                {
352 | // //                    ans.push_back(matrix[i][left]);
353 | // //                }
354 | // //                left++;
355 | // //            }
356 | // //        }
357 | // //        return ans;
358 | // //    }
359 | // //};
360 | 
361 | // //Rotate Image by 90 degree
362 | // //class Solution {
363 | // //public:
364 | // //    void rotate(vector<vector<int>>& matrix) {
365 | // //        int n = matrix.size();
366 | // //        for(int i=0; i<(n+1)/2;i++){
367 | // //            for(int j=0; j<n/2; j++){
368 | // //                int temp = matrix[n-1-j][i];
369 | // //                matrix[n-1-j][i] = matrix[n-1-i][n-j-1];
370 | // //                matrix[n-1-i][n-j-1] = matrix[j][n-1-i];
371 | // //                matrix[j][n-1-i] = matrix[i][j];
372 | // //                matrix[i][j] = temp;
373 | // //            }
374 | // //        }
375 | // //    }
376 | // //    
377 | // //};
378 | 
379 | 
380 | 
381 | 
382 | 
383 | 
384 | 
385 | 
386 | 
387 | 
388 | 
389 | 
390 | 
391 | // //Print Like a Wave
392 | // //#include <bits/stdc++.h> 
393 | // //vector<int> wavePrint(vector<vector<int>> arr, int nRows, int mCols)
394 | // //{
395 | // //    vector<int> ans;
396 | // //
397 | // //    for(int col=0; col<mCols; col++){
398 | // //        if(col&1){
399 | // //            for(int row=nRows-1; row>=0; row--){
400 | // //                ans.push_back(arr[row][col]);
401 | // //            }
402 | // //        }
403 | // //        else{
404 | // //            for(int row=0; row<nRows; row++){
405 | // //                ans.push_back(arr[row][col]);
406 | // //            }
407 | // //        }
408 | // //    }
409 | // //    return ans;
410 | // //}
411 | 
412 | 
413 | 
414 | 
415 | // // 2d matrix
416 | 
417 | // //class Solution {
418 | // //public:
419 | // //    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
420 | // //        // if(matrix.size()==0 || matrix[0].size()==0){
421 | // //        //     return matrix;
422 | // //        // }
423 | // //        vector<int> ans;
424 | // //        int m = matrix.size();
425 | // //        int n = matrix[0].size();
426 | // //        int row=0, col=0;        
427 | // //        bool up = true;
428 | // //
429 | // //        while(row<m && col<n){
430 | // //            if(up){
431 | // //                while(row>0 && col<n-1){
432 | // //                    ans.push_back(matrix[row][col]);
433 | // //                    row--;
434 | // //                    col++;
435 | // //                }
436 | // //                 ans.push_back(matrix[row][col]);
437 | // //                 if(col==n-1){
438 | // //                     row++;
439 | // //                 }
440 | // //                 else{
441 | // //                     col++;
442 | // //                 }
443 | // //            }
444 | // //            else{
445 | // //                while(col>0 && row<m-1){
446 | // //                 ans.push_back(matrix[row][col]);
447 | // //                 row++;
448 | // //                 col--;   
449 | // //                }
450 | // //                ans.push_back(matrix[row][col]);
451 | // //                if(row==m-1){
452 | // //                    col++;
453 | // //                }
454 | // //                else{
455 | // //                    row++;
456 | // //                }
457 | // //            }
458 | // //            up = !up; // Fix: Toggle the boolean variable 'up'
459 | // //        }
460 | // //        return ans;
461 | // //    }
462 | // //};
463 | 
464 | 
465 | 
466 | 
467 | // // Modular Exponentiation
468 | // //#include <bits/stdc++.h>
469 | // //
470 | // //int modularExponentiation(int x, int n, int m) {
471 | // //	int res = 1;
472 | // //	while(n>0){
473 | // //		if(n&1){
474 | // //			res = (1LL*(res) * (x)%m)%m;
475 | // //		}
476 | // //		x = (1LL * (x)%m * (x)%m) %m;
477 | // //		n = n>>1;
478 | // //	}
479 | // //	return res;
480 | // //}
481 | 


--------------------------------------------------------------------------------
/D3-String.cpp:
--------------------------------------------------------------------------------
  1 | //Count Senior number of citizen
  2 | 
  3 | int count = 0;
  4 | 
  5 | for(String s: arr){
  6 |     int a = (s[11]-'O' * 10)+(s[12]-'O');
  7 |     if(a>60){
  8 |         count++;
  9 |     }
 10 |     return count;
 11 | }
 12 | 
 13 | 
 14 | 
 15 | 
 16 | 
 17 | // 53. Maximum Subarray
 18 | // Approach 1: Brute Force
 19 | // for(int i=0 ->n){
 20 | // for(int j=0 ->n){
 21 | //     for(int k=i -> j){
 22 | //         sum = sum + arr[k];
 23 | //     }
 24 | // }
 25 | // }
 26 | 
 27 | // for(int i=0 ->n){
 28 | //     sum
 29 | // for(int j=0 ->n){
 30 | //     for(int k=i -> j){
 31 | //         sum = sum + arr[k];
 32 | //     }
 33 | // }
 34 | // }
 35 | 
 36 | 
 37 | 
 38 | class Solution {
 39 | public:
 40 |     int maxSubArray(vector<int>& nums) {
 41 |         int sum = 0;
 42 |         int maxi = nums[0];
 43 | 
 44 | 
 45 |         for(int i=0; i<nums.size(); i++){
 46 |             //Step-1
 47 |             sum = sum + nums[i];
 48 |             //Step-2
 49 |             maxi = max(maxi, sum);
 50 |             //Step-3
 51 |             if(sum<0)
 52 |                 sum=0;
 53 |         }
 54 |         return maxi;
 55 |     }
 56 | };
 57 | 
 58 | 
 59 | 
 60 | // DSA Sheet Sloving String Q-1: Maximum and minimum of an array using minimum number of comparisons
 61 | // Approch-1: set max and min from 1st two element of array
 62 | 
 63 | #include <iostream>
 64 | using namespace std;
 65 | 
 66 | int main() {
 67 |     int n = 0;
 68 |     int arr[n];
 69 |     int max, min;
 70 |     cin>>n;
 71 |     for(int i=0; i<n; i++){
 72 |         cin>>arr[i];
 73 |     }
 74 |     if(n==0){
 75 |         max = arr[0];
 76 |         min = arr[0];
 77 |     }
 78 |     if(n==1){
 79 |         if(arr[0]>arr[1]){
 80 |             max = arr[0];
 81 |             min = arr[1];
 82 |         }
 83 |         else{
 84 |             max = arr[1];
 85 |             min = arr[0];
 86 |         }
 87 |     }
 88 |     else{
 89 |         if(arr[0]>arr[1]){
 90 |             max = arr[0];
 91 |             min = arr[1];
 92 |         }
 93 |         else{
 94 |             max = arr[1];
 95 |             min = arr[0];
 96 |         }
 97 |         for(int i=2; i<n; i++){
 98 |             if(max<arr[i]){
 99 |                 max = arr[i];
100 |             }
101 |             if(min>arr[i]){
102 |                 min = arr[i];
103 |             }
104 |         }
105 |     }
106 |     cout<<"Max" << max<<endl;
107 |     cout<<"Min" << min<<endl;
108 | 
109 |     return 0;
110 | }
111 | 
112 | 
113 | // DSA Sheet Sloving String Q-2: Array Reverse
114 | // Online C++ compiler to run C++ program online
115 | #include <iostream>
116 | using namespace std;
117 | 
118 | int main() {
119 |     
120 |     int n, i, j, temp;
121 |     int arr[n];
122 |     
123 |     cin>>n;
124 |     
125 |     for(int k=0; k<n; k++){
126 |         cin >> arr[k];
127 |     }
128 |     
129 |     
130 |     for(int i=0, j=n-1; i<n/2; i++,j--){
131 |         temp = arr[i];
132 |         arr[j] = arr[i];
133 |         arr[j] = temp;
134 |     }
135 |     
136 |     for(int k=0; k<n; k++){
137 |         cout << arr[k];
138 |     }
139 |     
140 |     
141 |     return 0;
142 | }
143 | 
144 | 
145 | 
146 | 
147 | // #include <iostream>
148 | // using namespace std;
149 | 
150 | // /* run this program using the console pauser or add your own getch, system("pause") or input loop */
151 | 
152 | // void printSum(int arr[][3], int row, int col){
153 | // 	for(int row=0; row<3; row++){
154 | // 		int sum = 0;
155 | // 		for(int col=0; col<3; col++){
156 | // 					sum += arr[row][col];	
157 | // 		}
158 | // 		cout<<sum<<" ";
159 | // 	}
160 | // }
161 | 
162 | // void printcolSum(int arr[][3], int row, int col){
163 | // 	for(int row=0; row<3; row++){
164 | // 		int sum = 0;
165 | // 		for(int col=0; col<3; col++){
166 | // 					sum += arr[col][row];	
167 | // 		}
168 | // 		cout<<sum<<" ";
169 | // 	}
170 | // }
171 | 
172 | 
173 | // bool isPresent(int arr[][4], int target, int row, int col){
174 | // 	for(int row=0; row<3; row++){
175 | // 		for(int col=0; col<4; col++){
176 | 			
177 | // 			if(arr[row][col] == target){
178 | // 				return 1;
179 | // 			}
180 | 			
181 | // 		}
182 | // 	}
183 | // 	return 0;
184 | // }
185 | 
186 | 
187 | // int LargetRowSum(int arr[][3], int row, int col){
188 | // 	int maxi = INT_MIN;
189 | // 	int rowIndex = -1;
190 | // 	for( int row=0; row<3; row++){
191 | // 		int sum = 0;
192 | // 		for(int col=0; col<3; col++){
193 | // 			sum += arr[row][col];
194 | // 		}
195 | // 		if(sum > maxi){
196 | // 			maxi = sum;
197 | // 			rowIndex = row;
198 | // 		}
199 | // 	}
200 | // 	return rowIndex;
201 | // }
202 | 
203 | 
204 | // int main(int argc, char** argv) {
205 | 	
206 | // //	int arr1[3][4] = {{1,11,111,1111}, {2,22,222,2222}, {3,33,333,3333}};
207 | // 	int arr2[3][3];
208 | 	
209 | // 	for(int row=0; row<3; row++){
210 | // 		for(int col=0; col<3; col++){
211 | // 			cin>>arr2[row][col];
212 | // 		}
213 | // 	}
214 | 	
215 | // 	for(int row=0; row<3; row++){
216 | // 		for(int col=0; col<3; col++){
217 | // 			cout<<arr2[row][col]<<" ";
218 | // 		}
219 | // 		cout<<endl;
220 | // 	}
221 | 	
222 | 
223 | // //Sieve of Eratosthenes
224 | 	
225 | // //	class Solution {
226 | // //public:
227 | // //    int countPrimes(int n) {
228 | // //        int count = 0;
229 | // //       vector<bool> prime(n+1, true);
230 | // //       prime[0] = prime[1] = false;
231 | // //
232 | // //       for(int i=2; i<n; i++){
233 | // //           if(prime[i]){
234 | // //               count++;
235 | // //               for(int j=2*i; j<n; j=j+i){
236 | // //                   prime[j] = 0;
237 | // //              }
238 | // //           }
239 | // //       }
240 | // //        return count;
241 | // //    }
242 | // //};
243 | 	
244 | 	
245 | // //	class Solution {
246 | // //    bool isPrime(int n){
247 | // //        if(n<=1){
248 | // //            return false;
249 | // //        }
250 | // //        for(int i=2; i<n; i++){
251 | // //            if(n%i==0){
252 | // //                return false;
253 | // //            }
254 | // //        }
255 | // //        return true;
256 | // //    }
257 | // //public:
258 | // //    int countPrimes(int n) {
259 | // //        int count = 0;
260 | // //        for(int i=2; i<n; i++){
261 | // //            if(isPrime(i)){
262 | // //                count++;
263 | // //            }
264 | // //        }
265 | // //        return count;
266 | // //    }
267 | // //};
268 | 	
269 | 	
270 | // //	int target;
271 | // //	cin>>target;
272 | 	
273 | // //	if(isPresent(arr1, target, 3, 4)){	
274 | // //		cout<<"Element Found";
275 | // //	}	
276 | // //	else{
277 | // //		cout<<"Element Not Found";
278 | // //	}
279 | 
280 | // 	cout<<"Row Wise Sum = ";
281 | // 	printSum(arr2, 3, 3);
282 | // 	cout<<endl;
283 | // //	cout<<"Colum Wise Sum = ";
284 | // //	printcolSum(arr2, 3, 3);
285 | // //	cout<<endl;
286 | 	
287 | // 	cout<<"The Largest Sum is "<<LargetRowSum(arr2, 3,  3);	
288 | 	
289 | // 	return 0;
290 | // }
291 | 
292 | 
293 | // //54. Spiral Matrix
294 | // //class Solution {
295 | // //public:
296 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
297 | // //        int row = matrix.size();
298 | // //        int col = matrix[0].size();
299 | // //        vector<int> ans;
300 | // //        int count = 0;
301 | // //        int total = row*col;
302 | // //        int startingRow = 0;
303 | // //        int startingCol = 0;
304 | // //        int endingRow = row-1;
305 | // //        int endingCol = col-1;
306 | // //
307 | // //        while(count<total){
308 | // //
309 | // //            for(int i=startingCol; count<total && i<=endingCol; i++){
310 | // //                ans.push_back(matrix[startingRow][i]);
311 | // //                count++;
312 | // //            }
313 | // //            startingRow++;
314 | // //
315 | // //            for(int i=startingRow; count<total &&i<=endingRow; i++){
316 | // //                ans.push_back(matrix[i][endingCol]);
317 | // //                count++;
318 | // //            }
319 | // //            endingCol--;
320 | // //
321 | // //            for(int i=endingCol; count<total && i>=startingCol; i--){
322 | // //                ans.push_back(matrix[endingRow][i]);
323 | // //                count++;
324 | // //            }
325 | // //            endingRow--;
326 | // //
327 | // //            for(int i=endingRow; count<total && i>=startingRow; i--){
328 | // //                ans.push_back(matrix[i][startingCol]);
329 | // //                count++;
330 | // //            }
331 | // //            startingCol++;
332 | // //        }
333 | // //        return ans;
334 | // //    }
335 | // //};
336 | // //class Solution {
337 | // //public:
338 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
339 | // //        int n=matrix.size(),m=matrix[0].size();
340 | // //        int left=0,top=0;
341 | // //        int bottom=n-1,right=m-1;
342 | // //        vector<int>ans;
343 | // //        while(left<=right&&top<=bottom)
344 | // //        {
345 | // //            for(int i=left;i<=right;i++)
346 | // //            {
347 | // //                ans.push_back(matrix[top][i]);
348 | // //            }
349 | // //            top++;
350 | // //            for(int i=top;i<=bottom;i++)
351 | // //            {
352 | // //                ans.push_back(matrix[i][right]);
353 | // //            }
354 | // //            right--;
355 | // //            if(top<=bottom)
356 | // //            {
357 | // //                for(int i=right;i>=left;i--)
358 | // //                {
359 | // //                    ans.push_back(matrix[bottom][i]);
360 | // //                }
361 | // //                bottom--;
362 | // //            }
363 | // //            if(left<=right)
364 | // //            {
365 | // //                for(int i=bottom;i>=top;i--)
366 | // //                {
367 | // //                    ans.push_back(matrix[i][left]);
368 | // //                }
369 | // //                left++;
370 | // //            }
371 | // //        }
372 | // //        return ans;
373 | // //    }
374 | // //};
375 | 
376 | // //Rotate Image by 90 degree
377 | // //class Solution {
378 | // //public:
379 | // //    void rotate(vector<vector<int>>& matrix) {
380 | // //        int n = matrix.size();
381 | // //        for(int i=0; i<(n+1)/2;i++){
382 | // //            for(int j=0; j<n/2; j++){
383 | // //                int temp = matrix[n-1-j][i];
384 | // //                matrix[n-1-j][i] = matrix[n-1-i][n-j-1];
385 | // //                matrix[n-1-i][n-j-1] = matrix[j][n-1-i];
386 | // //                matrix[j][n-1-i] = matrix[i][j];
387 | // //                matrix[i][j] = temp;
388 | // //            }
389 | // //        }
390 | // //    }
391 | // //    
392 | // //};
393 | 
394 | 
395 | 
396 | 
397 | 
398 | 
399 | 
400 | 
401 | 
402 | 
403 | 
404 | 
405 | 
406 | // //Print Like a Wave
407 | // //#include <bits/stdc++.h> 
408 | // //vector<int> wavePrint(vector<vector<int>> arr, int nRows, int mCols)
409 | // //{
410 | // //    vector<int> ans;
411 | // //
412 | // //    for(int col=0; col<mCols; col++){
413 | // //        if(col&1){
414 | // //            for(int row=nRows-1; row>=0; row--){
415 | // //                ans.push_back(arr[row][col]);
416 | // //            }
417 | // //        }
418 | // //        else{
419 | // //            for(int row=0; row<nRows; row++){
420 | // //                ans.push_back(arr[row][col]);
421 | // //            }
422 | // //        }
423 | // //    }
424 | // //    return ans;
425 | // //}
426 | 
427 | 
428 | 
429 | 
430 | // // 2d matrix
431 | 
432 | // //class Solution {
433 | // //public:
434 | // //    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
435 | // //        // if(matrix.size()==0 || matrix[0].size()==0){
436 | // //        //     return matrix;
437 | // //        // }
438 | // //        vector<int> ans;
439 | // //        int m = matrix.size();
440 | // //        int n = matrix[0].size();
441 | // //        int row=0, col=0;        
442 | // //        bool up = true;
443 | // //
444 | // //        while(row<m && col<n){
445 | // //            if(up){
446 | // //                while(row>0 && col<n-1){
447 | // //                    ans.push_back(matrix[row][col]);
448 | // //                    row--;
449 | // //                    col++;
450 | // //                }
451 | // //                 ans.push_back(matrix[row][col]);
452 | // //                 if(col==n-1){
453 | // //                     row++;
454 | // //                 }
455 | // //                 else{
456 | // //                     col++;
457 | // //                 }
458 | // //            }
459 | // //            else{
460 | // //                while(col>0 && row<m-1){
461 | // //                 ans.push_back(matrix[row][col]);
462 | // //                 row++;
463 | // //                 col--;   
464 | // //                }
465 | // //                ans.push_back(matrix[row][col]);
466 | // //                if(row==m-1){
467 | // //                    col++;
468 | // //                }
469 | // //                else{
470 | // //                    row++;
471 | // //                }
472 | // //            }
473 | // //            up = !up; // Fix: Toggle the boolean variable 'up'
474 | // //        }
475 | // //        return ans;
476 | // //    }
477 | // //};
478 | 
479 | 
480 | 
481 | 
482 | // // Modular Exponentiation
483 | // //#include <bits/stdc++.h>
484 | // //
485 | // //int modularExponentiation(int x, int n, int m) {
486 | // //	int res = 1;
487 | // //	while(n>0){
488 | // //		if(n&1){
489 | // //			res = (1LL*(res) * (x)%m)%m;
490 | // //		}
491 | // //		x = (1LL * (x)%m * (x)%m) %m;
492 | // //		n = n>>1;
493 | // //	}
494 | // //	return res;
495 | // //}
496 | 


--------------------------------------------------------------------------------
/D4-Array.cpp:
--------------------------------------------------------------------------------
  1 | //33. Search in Rotated Sorted Array
  2 | class Solution {
  3 | public:
  4 |     int search(vector<int>& nums, int target) {
  5 |         int low=0; 
  6 |         int high = nums.size() -1;
  7 | 
  8 |         while( low <= high){
  9 |             int mid = (low + high) / 2;
 10 | 
 11 |             if(nums[mid] == target) return mid;
 12 | 
 13 |             if(nums[low] <= nums[mid]){
 14 |                 if(nums[low] <= target && target <= nums[mid]){
 15 |                     high = mid - 1;
 16 |                 }else{
 17 |                     low = mid + 1;
 18 |                 }
 19 |             }else{
 20 |                 if(nums[mid] <= target && target <= nums[high]){
 21 |                     low = mid + 1;
 22 |                 }else{
 23 |                     high = mid - 1;
 24 |                 }
 25 |             }
 26 |         }
 27 |         return -1;
 28 |     }
 29 | };
 30 | 
 31 | 
 32 | 
 33 | //1, 3, 4, 7, 9, 9 12, 56
 34 | 
 35 | int min = LLONG_MAX;
 36 | 
 37 | for(int i=0; i<n-m-1; i++){  //i+m-1<n -> i<n-m+1
 38 |     int diff = min(arr[i+m-1] - arr[i]);
 39 | }
 40 | return min;
 41 | 
 42 | 
 43 | 
 44 | 
 45 | 
 46 | //contains Duplicate
 47 | class Solution {
 48 | public:
 49 |     bool containsDuplicate(vector<int>& nums) {
 50 |         unordered_set<int >s(nums.begin(), nums.end());
 51 |         return nums.size() != s.size();
 52 |     }
 53 | };
 54 | 
 55 | 
 56 | class Solution {
 57 | public:
 58 |     bool containsDuplicate(vector<int>& nums) {
 59 |         sort(nums.begin(), nums.end());
 60 |         int n = nums.size();
 61 |         for(int i=1; i<n; i++){
 62 |             if(nums[i-1] == nums[i]){
 63 |                 return true;
 64 |             }
 65 |         }
 66 |         return false;
 67 |     }
 68 | };
 69 | 
 70 | 
 71 | //Minimum Swaps to Group All 1's Together
 72 | class Solution {
 73 | public:
 74 |     int minSwaps(vector<int>& nums) {
 75 |         int n = nums.size();
 76 |         int o=0, z=0;
 77 | 
 78 |         for(int i=0; i<n; i++){
 79 |             o += (nums[i]==1);
 80 |             z += (nums[i]==0);
 81 |         }
 82 | 
 83 |         nums.insert(nums.end(), nums.begin(), nums.end());
 84 | 
 85 |         int ans = n;
 86 |         int i=0, j=0, one=0;
 87 | 
 88 |         while(j<2*n){
 89 |             one += (nums[j]==1);
 90 | 
 91 |             if(j-i+1 == o){
 92 |                 ans = min(ans, o-one);
 93 |                 one -= (nums[i]==1);
 94 |                 i++;
 95 |             }
 96 |             j++;
 97 |         }
 98 |         return(ans==n ? 0:ans);
 99 |     }
100 | };
101 | 
102 | //Count Senior number of citizen
103 | 
104 | int count = 0;
105 | 
106 | for(String s: arr){
107 |     int a = (s[11]-'O' * 10)+(s[12]-'O');
108 |     if(a>60){
109 |         count++;
110 |     }
111 |     return count;
112 | }
113 | 
114 | 
115 | 
116 | 
117 | 
118 | // 53. Maximum Subarray
119 | // Approach 1: Brute Force
120 | // for(int i=0 ->n){
121 | // for(int j=0 ->n){
122 | //     for(int k=i -> j){
123 | //         sum = sum + arr[k];
124 | //     }
125 | // }
126 | // }
127 | 
128 | // for(int i=0 ->n){
129 | //     sum
130 | // for(int j=0 ->n){
131 | //     for(int k=i -> j){
132 | //         sum = sum + arr[k];
133 | //     }
134 | // }
135 | // }
136 | 
137 | 
138 | 
139 | class Solution {
140 | public:
141 |     int maxSubArray(vector<int>& nums) {
142 |         int sum = 0;
143 |         int maxi = nums[0];
144 | 
145 | 
146 |         for(int i=0; i<nums.size(); i++){
147 |             //Step-1
148 |             sum = sum + nums[i];
149 |             //Step-2
150 |             maxi = max(maxi, sum);
151 |             //Step-3
152 |             if(sum<0)
153 |                 sum=0;
154 |         }
155 |         return maxi;
156 |     }
157 | };
158 | 
159 | 
160 | 
161 | // DSA Sheet Sloving String Q-1: Maximum and minimum of an array using minimum number of comparisons
162 | // Approch-1: set max and min from 1st two element of array
163 | 
164 | #include <iostream>
165 | using namespace std;
166 | 
167 | int main() {
168 |     int n = 0;
169 |     int arr[n];
170 |     int max, min;
171 |     cin>>n;
172 |     for(int i=0; i<n; i++){
173 |         cin>>arr[i];
174 |     }
175 |     if(n==0){
176 |         max = arr[0];
177 |         min = arr[0];
178 |     }
179 |     if(n==1){
180 |         if(arr[0]>arr[1]){
181 |             max = arr[0];
182 |             min = arr[1];
183 |         }
184 |         else{
185 |             max = arr[1];
186 |             min = arr[0];
187 |         }
188 |     }
189 |     else{
190 |         if(arr[0]>arr[1]){
191 |             max = arr[0];
192 |             min = arr[1];
193 |         }
194 |         else{
195 |             max = arr[1];
196 |             min = arr[0];
197 |         }
198 |         for(int i=2; i<n; i++){
199 |             if(max<arr[i]){
200 |                 max = arr[i];
201 |             }
202 |             if(min>arr[i]){
203 |                 min = arr[i];
204 |             }
205 |         }
206 |     }
207 |     cout<<"Max" << max<<endl;
208 |     cout<<"Min" << min<<endl;
209 | 
210 |     return 0;
211 | }
212 | 
213 | 
214 | // DSA Sheet Sloving String Q-2: Array Reverse
215 | // Online C++ compiler to run C++ program online
216 | #include <iostream>
217 | using namespace std;
218 | 
219 | int main() {
220 |     
221 |     int n, i, j, temp;
222 |     int arr[n];
223 |     
224 |     cin>>n;
225 |     
226 |     for(int k=0; k<n; k++){
227 |         cin >> arr[k];
228 |     }
229 |     
230 |     
231 |     for(int i=0, j=n-1; i<n/2; i++,j--){
232 |         temp = arr[i];
233 |         arr[j] = arr[i];
234 |         arr[j] = temp;
235 |     }
236 |     
237 |     for(int k=0; k<n; k++){
238 |         cout << arr[k];
239 |     }
240 |     
241 |     
242 |     return 0;
243 | }
244 | 
245 | 
246 | 
247 | 
248 | // #include <iostream>
249 | // using namespace std;
250 | 
251 | // /* run this program using the console pauser or add your own getch, system("pause") or input loop */
252 | 
253 | // void printSum(int arr[][3], int row, int col){
254 | // 	for(int row=0; row<3; row++){
255 | // 		int sum = 0;
256 | // 		for(int col=0; col<3; col++){
257 | // 					sum += arr[row][col];	
258 | // 		}
259 | // 		cout<<sum<<" ";
260 | // 	}
261 | // }
262 | 
263 | // void printcolSum(int arr[][3], int row, int col){
264 | // 	for(int row=0; row<3; row++){
265 | // 		int sum = 0;
266 | // 		for(int col=0; col<3; col++){
267 | // 					sum += arr[col][row];	
268 | // 		}
269 | // 		cout<<sum<<" ";
270 | // 	}
271 | // }
272 | 
273 | 
274 | // bool isPresent(int arr[][4], int target, int row, int col){
275 | // 	for(int row=0; row<3; row++){
276 | // 		for(int col=0; col<4; col++){
277 | 			
278 | // 			if(arr[row][col] == target){
279 | // 				return 1;
280 | // 			}
281 | 			
282 | // 		}
283 | // 	}
284 | // 	return 0;
285 | // }
286 | 
287 | 
288 | // int LargetRowSum(int arr[][3], int row, int col){
289 | // 	int maxi = INT_MIN;
290 | // 	int rowIndex = -1;
291 | // 	for( int row=0; row<3; row++){
292 | // 		int sum = 0;
293 | // 		for(int col=0; col<3; col++){
294 | // 			sum += arr[row][col];
295 | // 		}
296 | // 		if(sum > maxi){
297 | // 			maxi = sum;
298 | // 			rowIndex = row;
299 | // 		}
300 | // 	}
301 | // 	return rowIndex;
302 | // }
303 | 
304 | 
305 | // int main(int argc, char** argv) {
306 | 	
307 | // //	int arr1[3][4] = {{1,11,111,1111}, {2,22,222,2222}, {3,33,333,3333}};
308 | // 	int arr2[3][3];
309 | 	
310 | // 	for(int row=0; row<3; row++){
311 | // 		for(int col=0; col<3; col++){
312 | // 			cin>>arr2[row][col];
313 | // 		}
314 | // 	}
315 | 	
316 | // 	for(int row=0; row<3; row++){
317 | // 		for(int col=0; col<3; col++){
318 | // 			cout<<arr2[row][col]<<" ";
319 | // 		}
320 | // 		cout<<endl;
321 | // 	}
322 | 	
323 | 
324 | // //Sieve of Eratosthenes
325 | 	
326 | // //	class Solution {
327 | // //public:
328 | // //    int countPrimes(int n) {
329 | // //        int count = 0;
330 | // //       vector<bool> prime(n+1, true);
331 | // //       prime[0] = prime[1] = false;
332 | // //
333 | // //       for(int i=2; i<n; i++){
334 | // //           if(prime[i]){
335 | // //               count++;
336 | // //               for(int j=2*i; j<n; j=j+i){
337 | // //                   prime[j] = 0;
338 | // //              }
339 | // //           }
340 | // //       }
341 | // //        return count;
342 | // //    }
343 | // //};
344 | 	
345 | 	
346 | // //	class Solution {
347 | // //    bool isPrime(int n){
348 | // //        if(n<=1){
349 | // //            return false;
350 | // //        }
351 | // //        for(int i=2; i<n; i++){
352 | // //            if(n%i==0){
353 | // //                return false;
354 | // //            }
355 | // //        }
356 | // //        return true;
357 | // //    }
358 | // //public:
359 | // //    int countPrimes(int n) {
360 | // //        int count = 0;
361 | // //        for(int i=2; i<n; i++){
362 | // //            if(isPrime(i)){
363 | // //                count++;
364 | // //            }
365 | // //        }
366 | // //        return count;
367 | // //    }
368 | // //};
369 | 	
370 | 	
371 | // //	int target;
372 | // //	cin>>target;
373 | 	
374 | // //	if(isPresent(arr1, target, 3, 4)){	
375 | // //		cout<<"Element Found";
376 | // //	}	
377 | // //	else{
378 | // //		cout<<"Element Not Found";
379 | // //	}
380 | 
381 | // 	cout<<"Row Wise Sum = ";
382 | // 	printSum(arr2, 3, 3);
383 | // 	cout<<endl;
384 | // //	cout<<"Colum Wise Sum = ";
385 | // //	printcolSum(arr2, 3, 3);
386 | // //	cout<<endl;
387 | 	
388 | // 	cout<<"The Largest Sum is "<<LargetRowSum(arr2, 3,  3);	
389 | 	
390 | // 	return 0;
391 | // }
392 | 
393 | 
394 | // //54. Spiral Matrix
395 | // //class Solution {
396 | // //public:
397 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
398 | // //        int row = matrix.size();
399 | // //        int col = matrix[0].size();
400 | // //        vector<int> ans;
401 | // //        int count = 0;
402 | // //        int total = row*col;
403 | // //        int startingRow = 0;
404 | // //        int startingCol = 0;
405 | // //        int endingRow = row-1;
406 | // //        int endingCol = col-1;
407 | // //
408 | // //        while(count<total){
409 | // //
410 | // //            for(int i=startingCol; count<total && i<=endingCol; i++){
411 | // //                ans.push_back(matrix[startingRow][i]);
412 | // //                count++;
413 | // //            }
414 | // //            startingRow++;
415 | // //
416 | // //            for(int i=startingRow; count<total &&i<=endingRow; i++){
417 | // //                ans.push_back(matrix[i][endingCol]);
418 | // //                count++;
419 | // //            }
420 | // //            endingCol--;
421 | // //
422 | // //            for(int i=endingCol; count<total && i>=startingCol; i--){
423 | // //                ans.push_back(matrix[endingRow][i]);
424 | // //                count++;
425 | // //            }
426 | // //            endingRow--;
427 | // //
428 | // //            for(int i=endingRow; count<total && i>=startingRow; i--){
429 | // //                ans.push_back(matrix[i][startingCol]);
430 | // //                count++;
431 | // //            }
432 | // //            startingCol++;
433 | // //        }
434 | // //        return ans;
435 | // //    }
436 | // //};
437 | // //class Solution {
438 | // //public:
439 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
440 | // //        int n=matrix.size(),m=matrix[0].size();
441 | // //        int left=0,top=0;
442 | // //        int bottom=n-1,right=m-1;
443 | // //        vector<int>ans;
444 | // //        while(left<=right&&top<=bottom)
445 | // //        {
446 | // //            for(int i=left;i<=right;i++)
447 | // //            {
448 | // //                ans.push_back(matrix[top][i]);
449 | // //            }
450 | // //            top++;
451 | // //            for(int i=top;i<=bottom;i++)
452 | // //            {
453 | // //                ans.push_back(matrix[i][right]);
454 | // //            }
455 | // //            right--;
456 | // //            if(top<=bottom)
457 | // //            {
458 | // //                for(int i=right;i>=left;i--)
459 | // //                {
460 | // //                    ans.push_back(matrix[bottom][i]);
461 | // //                }
462 | // //                bottom--;
463 | // //            }
464 | // //            if(left<=right)
465 | // //            {
466 | // //                for(int i=bottom;i>=top;i--)
467 | // //                {
468 | // //                    ans.push_back(matrix[i][left]);
469 | // //                }
470 | // //                left++;
471 | // //            }
472 | // //        }
473 | // //        return ans;
474 | // //    }
475 | // //};
476 | 
477 | // //Rotate Image by 90 degree
478 | // //class Solution {
479 | // //public:
480 | // //    void rotate(vector<vector<int>>& matrix) {
481 | // //        int n = matrix.size();
482 | // //        for(int i=0; i<(n+1)/2;i++){
483 | // //            for(int j=0; j<n/2; j++){
484 | // //                int temp = matrix[n-1-j][i];
485 | // //                matrix[n-1-j][i] = matrix[n-1-i][n-j-1];
486 | // //                matrix[n-1-i][n-j-1] = matrix[j][n-1-i];
487 | // //                matrix[j][n-1-i] = matrix[i][j];
488 | // //                matrix[i][j] = temp;
489 | // //            }
490 | // //        }
491 | // //    }
492 | // //    
493 | // //};
494 | 
495 | 
496 | 
497 | 
498 | 
499 | 
500 | 
501 | 
502 | 
503 | 
504 | 
505 | 
506 | 
507 | // //Print Like a Wave
508 | // //#include <bits/stdc++.h> 
509 | // //vector<int> wavePrint(vector<vector<int>> arr, int nRows, int mCols)
510 | // //{
511 | // //    vector<int> ans;
512 | // //
513 | // //    for(int col=0; col<mCols; col++){
514 | // //        if(col&1){
515 | // //            for(int row=nRows-1; row>=0; row--){
516 | // //                ans.push_back(arr[row][col]);
517 | // //            }
518 | // //        }
519 | // //        else{
520 | // //            for(int row=0; row<nRows; row++){
521 | // //                ans.push_back(arr[row][col]);
522 | // //            }
523 | // //        }
524 | // //    }
525 | // //    return ans;
526 | // //}
527 | 
528 | 
529 | 
530 | 
531 | // // 2d matrix
532 | 
533 | // //class Solution {
534 | // //public:
535 | // //    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
536 | // //        // if(matrix.size()==0 || matrix[0].size()==0){
537 | // //        //     return matrix;
538 | // //        // }
539 | // //        vector<int> ans;
540 | // //        int m = matrix.size();
541 | // //        int n = matrix[0].size();
542 | // //        int row=0, col=0;        
543 | // //        bool up = true;
544 | // //
545 | // //        while(row<m && col<n){
546 | // //            if(up){
547 | // //                while(row>0 && col<n-1){
548 | // //                    ans.push_back(matrix[row][col]);
549 | // //                    row--;
550 | // //                    col++;
551 | // //                }
552 | // //                 ans.push_back(matrix[row][col]);
553 | // //                 if(col==n-1){
554 | // //                     row++;
555 | // //                 }
556 | // //                 else{
557 | // //                     col++;
558 | // //                 }
559 | // //            }
560 | // //            else{
561 | // //                while(col>0 && row<m-1){
562 | // //                 ans.push_back(matrix[row][col]);
563 | // //                 row++;
564 | // //                 col--;   
565 | // //                }
566 | // //                ans.push_back(matrix[row][col]);
567 | // //                if(row==m-1){
568 | // //                    col++;
569 | // //                }
570 | // //                else{
571 | // //                    row++;
572 | // //                }
573 | // //            }
574 | // //            up = !up; // Fix: Toggle the boolean variable 'up'
575 | // //        }
576 | // //        return ans;
577 | // //    }
578 | // //};
579 | 
580 | 
581 | 
582 | 
583 | // // Modular Exponentiation
584 | // //#include <bits/stdc++.h>
585 | // //
586 | // //int modularExponentiation(int x, int n, int m) {
587 | // //	int res = 1;
588 | // //	while(n>0){
589 | // //		if(n&1){
590 | // //			res = (1LL*(res) * (x)%m)%m;
591 | // //		}
592 | // //		x = (1LL * (x)%m * (x)%m) %m;
593 | // //		n = n>>1;
594 | // //	}
595 | // //	return res;
596 | // //}
597 | 


--------------------------------------------------------------------------------
/D5-Array.cpp:
--------------------------------------------------------------------------------
  1 | //1508. Range Sum of Sorted Subarray Sums
  2 | //SOLUTION-1
  3 | class Solution {
  4 | public:
  5 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
  6 |         const unsigned int M = 1000000007;
  7 |         vector<int> sums;
  8 |         
  9 |         // Generate all subarray sums
 10 |         for(int i = 0; i < n; i++) {
 11 |             int current_sum = 0;
 12 |             for(int j = i; j < n; j++) {
 13 |                 current_sum = (current_sum + nums[j]) % M;
 14 |                 sums.push_back(current_sum);
 15 |             }
 16 |         }
 17 | 
 18 |         // Sort the subarray sums
 19 |         sort(sums.begin(), sums.end());
 20 |         
 21 |         // Calculate the sum of elements from `left-1` to `right-1`
 22 |         long long result = 0;
 23 |         for(int i = left - 1; i < right; i++) {
 24 |             result = (result + sums[i]) % M;
 25 |         }
 26 |         
 27 |         return (int)result;
 28 |     }
 29 | };
 30 | 
 31 | 
 32 | //SOLUTION-2
 33 | class Solution {
 34 | public:
 35 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
 36 |         long long sum = 0;
 37 |         const unsigned int M = 1000000007;
 38 |         vector<int> csum;
 39 |         vector<int> sums;
 40 |         for(int i=0; i<n ; i++){
 41 |             sum = (sum+nums[i])%M;
 42 |             csum.push_back(sum);
 43 |         }
 44 | 
 45 |         for(int i=0; i<n; i++){
 46 |             sums.push_back(csum[i]);
 47 |             for(int j=i+1; j<n; j++){
 48 |                 sums.push_back(csum[j]-csum[i]);
 49 |             }
 50 |         }
 51 |         sort(sums.begin(), sums.end());
 52 |         sum=0;
 53 |         for(int i=left-1; i<=right-1; i++){
 54 |             sum += sums[i];
 55 |         }
 56 |         return sum;
 57 |     }
 58 | };
 59 | 
 60 | //33. Search in Rotated Sorted Array
 61 | class Solution {
 62 | public:
 63 |     int search(vector<int>& nums, int target) {
 64 |         int low=0; 
 65 |         int high = nums.size() -1;
 66 | 
 67 |         while( low <= high){
 68 |             int mid = (low + high) / 2;
 69 | 
 70 |             if(nums[mid] == target) return mid;
 71 | 
 72 |             if(nums[low] <= nums[mid]){
 73 |                 if(nums[low] <= target && target <= nums[mid]){
 74 |                     high = mid - 1;
 75 |                 }else{
 76 |                     low = mid + 1;
 77 |                 }
 78 |             }else{
 79 |                 if(nums[mid] <= target && target <= nums[high]){
 80 |                     low = mid + 1;
 81 |                 }else{
 82 |                     high = mid - 1;
 83 |                 }
 84 |             }
 85 |         }
 86 |         return -1;
 87 |     }
 88 | };
 89 | 
 90 | 
 91 | 
 92 | //1, 3, 4, 7, 9, 9 12, 56
 93 | 
 94 | int min = LLONG_MAX;
 95 | 
 96 | for(int i=0; i<n-m-1; i++){  //i+m-1<n -> i<n-m+1
 97 |     int diff = min(arr[i+m-1] - arr[i]);
 98 | }
 99 | return min;
100 | 
101 | 
102 | 
103 | 
104 | 
105 | //contains Duplicate
106 | class Solution {
107 | public:
108 |     bool containsDuplicate(vector<int>& nums) {
109 |         unordered_set<int >s(nums.begin(), nums.end());
110 |         return nums.size() != s.size();
111 |     }
112 | };
113 | 
114 | 
115 | class Solution {
116 | public:
117 |     bool containsDuplicate(vector<int>& nums) {
118 |         sort(nums.begin(), nums.end());
119 |         int n = nums.size();
120 |         for(int i=1; i<n; i++){
121 |             if(nums[i-1] == nums[i]){
122 |                 return true;
123 |             }
124 |         }
125 |         return false;
126 |     }
127 | };
128 | 
129 | 
130 | //Minimum Swaps to Group All 1's Together
131 | class Solution {
132 | public:
133 |     int minSwaps(vector<int>& nums) {
134 |         int n = nums.size();
135 |         int o=0, z=0;
136 | 
137 |         for(int i=0; i<n; i++){
138 |             o += (nums[i]==1);
139 |             z += (nums[i]==0);
140 |         }
141 | 
142 |         nums.insert(nums.end(), nums.begin(), nums.end());
143 | 
144 |         int ans = n;
145 |         int i=0, j=0, one=0;
146 | 
147 |         while(j<2*n){
148 |             one += (nums[j]==1);
149 | 
150 |             if(j-i+1 == o){
151 |                 ans = min(ans, o-one);
152 |                 one -= (nums[i]==1);
153 |                 i++;
154 |             }
155 |             j++;
156 |         }
157 |         return(ans==n ? 0:ans);
158 |     }
159 | };
160 | 
161 | //Count Senior number of citizen
162 | 
163 | int count = 0;
164 | 
165 | for(String s: arr){
166 |     int a = (s[11]-'O' * 10)+(s[12]-'O');
167 |     if(a>60){
168 |         count++;
169 |     }
170 |     return count;
171 | }
172 | 
173 | 
174 | 
175 | 
176 | 
177 | // 53. Maximum Subarray
178 | // Approach 1: Brute Force
179 | // for(int i=0 ->n){
180 | // for(int j=0 ->n){
181 | //     for(int k=i -> j){
182 | //         sum = sum + arr[k];
183 | //     }
184 | // }
185 | // }
186 | 
187 | // for(int i=0 ->n){
188 | //     sum
189 | // for(int j=0 ->n){
190 | //     for(int k=i -> j){
191 | //         sum = sum + arr[k];
192 | //     }
193 | // }
194 | // }
195 | 
196 | 
197 | 
198 | class Solution {
199 | public:
200 |     int maxSubArray(vector<int>& nums) {
201 |         int sum = 0;
202 |         int maxi = nums[0];
203 | 
204 | 
205 |         for(int i=0; i<nums.size(); i++){
206 |             //Step-1
207 |             sum = sum + nums[i];
208 |             //Step-2
209 |             maxi = max(maxi, sum);
210 |             //Step-3
211 |             if(sum<0)
212 |                 sum=0;
213 |         }
214 |         return maxi;
215 |     }
216 | };
217 | 
218 | 
219 | 
220 | // DSA Sheet Sloving String Q-1: Maximum and minimum of an array using minimum number of comparisons
221 | // Approch-1: set max and min from 1st two element of array
222 | 
223 | #include <iostream>
224 | using namespace std;
225 | 
226 | int main() {
227 |     int n = 0;
228 |     int arr[n];
229 |     int max, min;
230 |     cin>>n;
231 |     for(int i=0; i<n; i++){
232 |         cin>>arr[i];
233 |     }
234 |     if(n==0){
235 |         max = arr[0];
236 |         min = arr[0];
237 |     }
238 |     if(n==1){
239 |         if(arr[0]>arr[1]){
240 |             max = arr[0];
241 |             min = arr[1];
242 |         }
243 |         else{
244 |             max = arr[1];
245 |             min = arr[0];
246 |         }
247 |     }
248 |     else{
249 |         if(arr[0]>arr[1]){
250 |             max = arr[0];
251 |             min = arr[1];
252 |         }
253 |         else{
254 |             max = arr[1];
255 |             min = arr[0];
256 |         }
257 |         for(int i=2; i<n; i++){
258 |             if(max<arr[i]){
259 |                 max = arr[i];
260 |             }
261 |             if(min>arr[i]){
262 |                 min = arr[i];
263 |             }
264 |         }
265 |     }
266 |     cout<<"Max" << max<<endl;
267 |     cout<<"Min" << min<<endl;
268 | 
269 |     return 0;
270 | }
271 | 
272 | 
273 | // DSA Sheet Sloving String Q-2: Array Reverse
274 | // Online C++ compiler to run C++ program online
275 | #include <iostream>
276 | using namespace std;
277 | 
278 | int main() {
279 |     
280 |     int n, i, j, temp;
281 |     int arr[n];
282 |     
283 |     cin>>n;
284 |     
285 |     for(int k=0; k<n; k++){
286 |         cin >> arr[k];
287 |     }
288 |     
289 |     
290 |     for(int i=0, j=n-1; i<n/2; i++,j--){
291 |         temp = arr[i];
292 |         arr[j] = arr[i];
293 |         arr[j] = temp;
294 |     }
295 |     
296 |     for(int k=0; k<n; k++){
297 |         cout << arr[k];
298 |     }
299 |     
300 |     
301 |     return 0;
302 | }
303 | 
304 | 
305 | 
306 | 
307 | // #include <iostream>
308 | // using namespace std;
309 | 
310 | // /* run this program using the console pauser or add your own getch, system("pause") or input loop */
311 | 
312 | // void printSum(int arr[][3], int row, int col){
313 | // 	for(int row=0; row<3; row++){
314 | // 		int sum = 0;
315 | // 		for(int col=0; col<3; col++){
316 | // 					sum += arr[row][col];	
317 | // 		}
318 | // 		cout<<sum<<" ";
319 | // 	}
320 | // }
321 | 
322 | // void printcolSum(int arr[][3], int row, int col){
323 | // 	for(int row=0; row<3; row++){
324 | // 		int sum = 0;
325 | // 		for(int col=0; col<3; col++){
326 | // 					sum += arr[col][row];	
327 | // 		}
328 | // 		cout<<sum<<" ";
329 | // 	}
330 | // }
331 | 
332 | 
333 | // bool isPresent(int arr[][4], int target, int row, int col){
334 | // 	for(int row=0; row<3; row++){
335 | // 		for(int col=0; col<4; col++){
336 | 			
337 | // 			if(arr[row][col] == target){
338 | // 				return 1;
339 | // 			}
340 | 			
341 | // 		}
342 | // 	}
343 | // 	return 0;
344 | // }
345 | 
346 | 
347 | // int LargetRowSum(int arr[][3], int row, int col){
348 | // 	int maxi = INT_MIN;
349 | // 	int rowIndex = -1;
350 | // 	for( int row=0; row<3; row++){
351 | // 		int sum = 0;
352 | // 		for(int col=0; col<3; col++){
353 | // 			sum += arr[row][col];
354 | // 		}
355 | // 		if(sum > maxi){
356 | // 			maxi = sum;
357 | // 			rowIndex = row;
358 | // 		}
359 | // 	}
360 | // 	return rowIndex;
361 | // }
362 | 
363 | 
364 | // int main(int argc, char** argv) {
365 | 	
366 | // //	int arr1[3][4] = {{1,11,111,1111}, {2,22,222,2222}, {3,33,333,3333}};
367 | // 	int arr2[3][3];
368 | 	
369 | // 	for(int row=0; row<3; row++){
370 | // 		for(int col=0; col<3; col++){
371 | // 			cin>>arr2[row][col];
372 | // 		}
373 | // 	}
374 | 	
375 | // 	for(int row=0; row<3; row++){
376 | // 		for(int col=0; col<3; col++){
377 | // 			cout<<arr2[row][col]<<" ";
378 | // 		}
379 | // 		cout<<endl;
380 | // 	}
381 | 	
382 | 
383 | // //Sieve of Eratosthenes
384 | 	
385 | // //	class Solution {
386 | // //public:
387 | // //    int countPrimes(int n) {
388 | // //        int count = 0;
389 | // //       vector<bool> prime(n+1, true);
390 | // //       prime[0] = prime[1] = false;
391 | // //
392 | // //       for(int i=2; i<n; i++){
393 | // //           if(prime[i]){
394 | // //               count++;
395 | // //               for(int j=2*i; j<n; j=j+i){
396 | // //                   prime[j] = 0;
397 | // //              }
398 | // //           }
399 | // //       }
400 | // //        return count;
401 | // //    }
402 | // //};
403 | 	
404 | 	
405 | // //	class Solution {
406 | // //    bool isPrime(int n){
407 | // //        if(n<=1){
408 | // //            return false;
409 | // //        }
410 | // //        for(int i=2; i<n; i++){
411 | // //            if(n%i==0){
412 | // //                return false;
413 | // //            }
414 | // //        }
415 | // //        return true;
416 | // //    }
417 | // //public:
418 | // //    int countPrimes(int n) {
419 | // //        int count = 0;
420 | // //        for(int i=2; i<n; i++){
421 | // //            if(isPrime(i)){
422 | // //                count++;
423 | // //            }
424 | // //        }
425 | // //        return count;
426 | // //    }
427 | // //};
428 | 	
429 | 	
430 | // //	int target;
431 | // //	cin>>target;
432 | 	
433 | // //	if(isPresent(arr1, target, 3, 4)){	
434 | // //		cout<<"Element Found";
435 | // //	}	
436 | // //	else{
437 | // //		cout<<"Element Not Found";
438 | // //	}
439 | 
440 | // 	cout<<"Row Wise Sum = ";
441 | // 	printSum(arr2, 3, 3);
442 | // 	cout<<endl;
443 | // //	cout<<"Colum Wise Sum = ";
444 | // //	printcolSum(arr2, 3, 3);
445 | // //	cout<<endl;
446 | 	
447 | // 	cout<<"The Largest Sum is "<<LargetRowSum(arr2, 3,  3);	
448 | 	
449 | // 	return 0;
450 | // }
451 | 
452 | 
453 | // //54. Spiral Matrix
454 | // //class Solution {
455 | // //public:
456 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
457 | // //        int row = matrix.size();
458 | // //        int col = matrix[0].size();
459 | // //        vector<int> ans;
460 | // //        int count = 0;
461 | // //        int total = row*col;
462 | // //        int startingRow = 0;
463 | // //        int startingCol = 0;
464 | // //        int endingRow = row-1;
465 | // //        int endingCol = col-1;
466 | // //
467 | // //        while(count<total){
468 | // //
469 | // //            for(int i=startingCol; count<total && i<=endingCol; i++){
470 | // //                ans.push_back(matrix[startingRow][i]);
471 | // //                count++;
472 | // //            }
473 | // //            startingRow++;
474 | // //
475 | // //            for(int i=startingRow; count<total &&i<=endingRow; i++){
476 | // //                ans.push_back(matrix[i][endingCol]);
477 | // //                count++;
478 | // //            }
479 | // //            endingCol--;
480 | // //
481 | // //            for(int i=endingCol; count<total && i>=startingCol; i--){
482 | // //                ans.push_back(matrix[endingRow][i]);
483 | // //                count++;
484 | // //            }
485 | // //            endingRow--;
486 | // //
487 | // //            for(int i=endingRow; count<total && i>=startingRow; i--){
488 | // //                ans.push_back(matrix[i][startingCol]);
489 | // //                count++;
490 | // //            }
491 | // //            startingCol++;
492 | // //        }
493 | // //        return ans;
494 | // //    }
495 | // //};
496 | // //class Solution {
497 | // //public:
498 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
499 | // //        int n=matrix.size(),m=matrix[0].size();
500 | // //        int left=0,top=0;
501 | // //        int bottom=n-1,right=m-1;
502 | // //        vector<int>ans;
503 | // //        while(left<=right&&top<=bottom)
504 | // //        {
505 | // //            for(int i=left;i<=right;i++)
506 | // //            {
507 | // //                ans.push_back(matrix[top][i]);
508 | // //            }
509 | // //            top++;
510 | // //            for(int i=top;i<=bottom;i++)
511 | // //            {
512 | // //                ans.push_back(matrix[i][right]);
513 | // //            }
514 | // //            right--;
515 | // //            if(top<=bottom)
516 | // //            {
517 | // //                for(int i=right;i>=left;i--)
518 | // //                {
519 | // //                    ans.push_back(matrix[bottom][i]);
520 | // //                }
521 | // //                bottom--;
522 | // //            }
523 | // //            if(left<=right)
524 | // //            {
525 | // //                for(int i=bottom;i>=top;i--)
526 | // //                {
527 | // //                    ans.push_back(matrix[i][left]);
528 | // //                }
529 | // //                left++;
530 | // //            }
531 | // //        }
532 | // //        return ans;
533 | // //    }
534 | // //};
535 | 
536 | // //Rotate Image by 90 degree
537 | // //class Solution {
538 | // //public:
539 | // //    void rotate(vector<vector<int>>& matrix) {
540 | // //        int n = matrix.size();
541 | // //        for(int i=0; i<(n+1)/2;i++){
542 | // //            for(int j=0; j<n/2; j++){
543 | // //                int temp = matrix[n-1-j][i];
544 | // //                matrix[n-1-j][i] = matrix[n-1-i][n-j-1];
545 | // //                matrix[n-1-i][n-j-1] = matrix[j][n-1-i];
546 | // //                matrix[j][n-1-i] = matrix[i][j];
547 | // //                matrix[i][j] = temp;
548 | // //            }
549 | // //        }
550 | // //    }
551 | // //    
552 | // //};
553 | 
554 | 
555 | 
556 | 
557 | 
558 | 
559 | 
560 | 
561 | 
562 | 
563 | 
564 | 
565 | 
566 | // //Print Like a Wave
567 | // //#include <bits/stdc++.h> 
568 | // //vector<int> wavePrint(vector<vector<int>> arr, int nRows, int mCols)
569 | // //{
570 | // //    vector<int> ans;
571 | // //
572 | // //    for(int col=0; col<mCols; col++){
573 | // //        if(col&1){
574 | // //            for(int row=nRows-1; row>=0; row--){
575 | // //                ans.push_back(arr[row][col]);
576 | // //            }
577 | // //        }
578 | // //        else{
579 | // //            for(int row=0; row<nRows; row++){
580 | // //                ans.push_back(arr[row][col]);
581 | // //            }
582 | // //        }
583 | // //    }
584 | // //    return ans;
585 | // //}
586 | 
587 | 
588 | 
589 | 
590 | // // 2d matrix
591 | 
592 | // //class Solution {
593 | // //public:
594 | // //    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
595 | // //        // if(matrix.size()==0 || matrix[0].size()==0){
596 | // //        //     return matrix;
597 | // //        // }
598 | // //        vector<int> ans;
599 | // //        int m = matrix.size();
600 | // //        int n = matrix[0].size();
601 | // //        int row=0, col=0;        
602 | // //        bool up = true;
603 | // //
604 | // //        while(row<m && col<n){
605 | // //            if(up){
606 | // //                while(row>0 && col<n-1){
607 | // //                    ans.push_back(matrix[row][col]);
608 | // //                    row--;
609 | // //                    col++;
610 | // //                }
611 | // //                 ans.push_back(matrix[row][col]);
612 | // //                 if(col==n-1){
613 | // //                     row++;
614 | // //                 }
615 | // //                 else{
616 | // //                     col++;
617 | // //                 }
618 | // //            }
619 | // //            else{
620 | // //                while(col>0 && row<m-1){
621 | // //                 ans.push_back(matrix[row][col]);
622 | // //                 row++;
623 | // //                 col--;   
624 | // //                }
625 | // //                ans.push_back(matrix[row][col]);
626 | // //                if(row==m-1){
627 | // //                    col++;
628 | // //                }
629 | // //                else{
630 | // //                    row++;
631 | // //                }
632 | // //            }
633 | // //            up = !up; // Fix: Toggle the boolean variable 'up'
634 | // //        }
635 | // //        return ans;
636 | // //    }
637 | // //};
638 | 
639 | 
640 | 
641 | 
642 | // // Modular Exponentiation
643 | // //#include <bits/stdc++.h>
644 | // //
645 | // //int modularExponentiation(int x, int n, int m) {
646 | // //	int res = 1;
647 | // //	while(n>0){
648 | // //		if(n&1){
649 | // //			res = (1LL*(res) * (x)%m)%m;
650 | // //		}
651 | // //		x = (1LL * (x)%m * (x)%m) %m;
652 | // //		n = n>>1;
653 | // //	}
654 | // //	return res;
655 | // //}
656 | 


--------------------------------------------------------------------------------
/D6-Array.cpp:
--------------------------------------------------------------------------------
  1 | //42. Trapping Rain Water
  2 | class Solution {
  3 | public:
  4 |     int trap(vector<int>& height) {
  5 |         int n = height.size();
  6 |         int left[n];
  7 |         int right[n];
  8 |         left[0] = height[0];
  9 | 
 10 |         for(int i=1; i<n; i++){
 11 |             left[i] = max(left[i-1], height[i]);
 12 |         }
 13 |         right[n-1] = height[n-1];
 14 |         
 15 |         for(int i=n-2; i>=0; i--){
 16 |             right[i] = max(right[i+1], height[i]);
 17 |         }
 18 |         int ssum=0;
 19 |         for(int i=0; i<n; i++){
 20 |             ssum += (min(left[i], right[i]) - height[i]);
 21 |         }
 22 |         return ssum;
 23 |     }
 24 | };
 25 | 
 26 | class Solution {
 27 | public:
 28 |     int trap(vector<int>& height) {
 29 |         int min = height[0];
 30 |         vector<int> left;
 31 |         for(int i=0; i<height.size(); i++){
 32 |             min = max(min, height[i]);
 33 |             left.push_back(min);
 34 |         }   
 35 |         int Max = height[height.size()];
 36 |         vector<int> right;
 37 |         for(int i=height.size(); i>-0; i--){
 38 |             Max = max(Max, height[i]);
 39 |             right.push_back(Max);
 40 |         }   
 41 |         vector<int> sumarr;
 42 |         for(int i=0; i<height.size(); i++){
 43 |             int Sum = max(left[i],right[i]);
 44 |             int ans = Sum - height[i];
 45 |             sumarr.push_back(ans);
 46 |         }
 47 |         int ssum = 0;
 48 |         for(int i=0; i<sumarr.size(); i++){
 49 |             ssum += sumarr[i];
 50 |         }
 51 |         return ssum;
 52 |     }
 53 | };
 54 | 
 55 | //215. Kth Largest Element in an Array
 56 | 
 57 | class Solution {
 58 | public:
 59 |     int findKthLargest(vector<int>& nums, int k) {
 60 |         sort(nums.begin(), nums.end());
 61 |         int n = nums.size();
 62 |         return nums[n-k];
 63 |     }
 64 | };
 65 | 
 66 | 
 67 | class Solution {
 68 | public:
 69 |     int findKthLargest(vector<int>& nums, int k) {
 70 |         sort(nums.begin(), nums.end());
 71 |         int max=0;
 72 |         int size = nums.size();
 73 |         if(size==1){
 74 |                 return 1;
 75 |         }
 76 |         int till = size-k;
 77 |         for(int i=0; i<till; i++){
 78 |             if(nums[till]){
 79 |                 max=nums[till];
 80 |             }
 81 |         }
 82 |         return max;
 83 |     }
 84 | };
 85 | 
 86 | 
 87 | 
 88 | // Minimum Number of Pushes to Type Word II 
 89 | class Solution {
 90 | public:
 91 |     int minimumPushes(string word) {
 92 |         int arr[26] = {0}; // Initialize array with zeros
 93 |         
 94 |         for(char ch: word) {
 95 |             arr[ch - 'a']++;
 96 |         }
 97 |         
 98 |         // Convert C-style array to vector for using sort function
 99 |         vector<int> frequencies(arr, arr + 26);
100 |         sort(frequencies.begin(), frequencies.end());
101 |         
102 |         int count = 0;
103 |         int minKeyPress = 0;
104 |         
105 |         for(int i = 25; i >= 0; i--) {
106 |             if(frequencies[i] == 0) break;
107 |             int val = frequencies[i] * (count / 8 + 1);
108 |             minKeyPress += val;
109 |             count++; 
110 |         }
111 |         
112 |         return minKeyPress;
113 |     }
114 | };
115 | 
116 | class Solution {
117 | public:
118 |     int minimumPushes(string word) {
119 |         int arr[26];
120 |         for(char ch: word){
121 |             arr[ch-'a']++;
122 |         }
123 |         sort(arr[].begin(), arr[].end());
124 | 
125 |         int count=0;
126 |         int minkeypress=0;
127 | 
128 |         for(int i=25; i>=0; i--){
129 |             if(arr[i]==0) break;
130 |             int val = arr[i]*(count/8 + 1);
131 |             minkeypress += val;
132 |             count++; 
133 |         }
134 |         return minkeypress;
135 |     }
136 | };
137 | 
138 | 
139 | #include <unordered_map>
140 | #include <string>
141 | 
142 | class Solution {
143 | public:
144 |     int minimumPushes(std::string word) {
145 |         std::unordered_map<char, int> keyMap = {
146 |             {'a', 2}, {'b', 3}, {'c', 4}, {'d', 5}, {'e', 6}, {'f', 2}, {'g', 2},
147 |             {'h', 3}, {'i', 3}, {'j', 4}, {'k', 4}, {'l', 5}, {'m', 5}, {'n', 6},
148 |             {'o', 6}, {'p', 7}, {'q', 7}, {'r', 7}, {'s', 7}, {'t', 8}, {'u', 8},
149 |             {'v', 8}, {'w', 9}, {'x', 9}, {'y', 9}, {'z', 9}
150 |         };
151 |         
152 |         int totalPushes = 0;
153 |         for (char c : word) {
154 |             totalPushes += keyMap[c];
155 |         }
156 |         
157 |         return totalPushes;
158 |     }
159 | };
160 | 
161 | 
162 | class Solution {
163 | public:
164 |     int minimumPushes(string word) {
165 |         int two = 0, three = 0, four=0, five=0, six=0, seven=0, eight=0, nine=0;
166 |         for( char c: word){
167 |             if(word[c]=='a' || word[c]=='f' || word[c]=='g'){
168 |                 two++;
169 |             }
170 |             if(word[c]=='b' || word[c]=='h' || word[c]=='i'){
171 |                 three++;
172 |             }
173 |             if(word[c]=='c' || word[c]=='j' || word[c]=='k'){
174 |                 four++;
175 |             }
176 |             if(word[c]=='d' || word[c]=='l' || word[c]=='m'){
177 |                 five++;
178 |             }
179 |             if(word[c]=='e' || word[c]=='n' || word[c]=='o'){
180 |                 six++;
181 |             }
182 |             if(word[c]=='p' || word[c]=='q' || word[c]=='r' || word[c]=='s'){
183 |                 seven++;
184 |             }
185 |             if(word[c]=='t' || word[c]=='u' || word[c]=='v'){
186 |                 eight++;
187 |             }
188 |             if(word[c]=='w' || word[c]=='x' || word[c]=='y' || word[c]=='z'){
189 |                 nine++;
190 |             }   
191 |         }
192 |         int ans = two+three+four+five+six+seven+eight+nine;
193 |         return ans;
194 |     }
195 | };
196 | 
197 | 
198 | //2053. Kth Distinct String in an Array
199 | 
200 | class Solution {
201 | public:
202 |     string kthDistinct(vector<string>& arr, int k) {
203 |         unordered_map<string, int> mp;
204 |         int i;
205 | 
206 |         for(i=0; i<arr.size(); i++){
207 |             mp[arr[i]]++;
208 |         }
209 | 
210 |         for(i=0; i<arr.size(); i++){
211 |             if(mp[arr[i]]==1){
212 |                 k--;
213 |                 if(k==0)
214 |                     return arr[i];
215 |             }
216 |         }
217 |         return "";
218 |     }
219 | };
220 | 
221 | 
222 | 
223 | class Solution {
224 | public:
225 |     string kthDistinct(vector<string>& arr, int k) {
226 |         vector<string>& ans;
227 |         int  j=0, count=0;
228 |         for(int i=0; i<arr.size(); i++){
229 |             for(j=i+1; j<arr.size(); j++){
230 |                 // if(arr[i]==arr[j]){
231 |                 //     k--;
232 |                 //     if(k==0){
233 |                 //         ans = arr[j];
234 |                 //     }
235 |                 count++;
236 |                 }
237 |                 if(count>0){
238 |                     ans = arr[i];
239 |                 }
240 |             }
241 |             j=0;
242 |         }
243 |         // if(k==0){
244 |         //     return ans;
245 |         // }
246 |         return ans;
247 |     }
248 | };
249 | 
250 | 
251 | 
252 | 
253 | 
254 | 
255 | 
256 | //1508. Range Sum of Sorted Subarray Sums
257 | //SOLUTION-1
258 | class Solution {
259 | public:
260 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
261 |         const unsigned int M = 1000000007;
262 |         vector<int> sums;
263 |         
264 |         // Generate all subarray sums
265 |         for(int i = 0; i < n; i++) {
266 |             int current_sum = 0;
267 |             for(int j = i; j < n; j++) {
268 |                 current_sum = (current_sum + nums[j]) % M;
269 |                 sums.push_back(current_sum);
270 |             }
271 |         }
272 | 
273 |         // Sort the subarray sums
274 |         sort(sums.begin(), sums.end());
275 |         
276 |         // Calculate the sum of elements from `left-1` to `right-1`
277 |         long long result = 0;
278 |         for(int i = left - 1; i < right; i++) {
279 |             result = (result + sums[i]) % M;
280 |         }
281 |         
282 |         return (int)result;
283 |     }
284 | };
285 | 
286 | 
287 | //SOLUTION-2
288 | class Solution {
289 | public:
290 |     int rangeSum(vector<int>& nums, int n, int left, int right) {
291 |         long long sum = 0;
292 |         const unsigned int M = 1000000007;
293 |         vector<int> csum;
294 |         vector<int> sums;
295 |         for(int i=0; i<n ; i++){
296 |             sum = (sum+nums[i])%M;
297 |             csum.push_back(sum);
298 |         }
299 | 
300 |         for(int i=0; i<n; i++){
301 |             sums.push_back(csum[i]);
302 |             for(int j=i+1; j<n; j++){
303 |                 sums.push_back(csum[j]-csum[i]);
304 |             }
305 |         }
306 |         sort(sums.begin(), sums.end());
307 |         sum=0;
308 |         for(int i=left-1; i<=right-1; i++){
309 |             sum += sums[i];
310 |         }
311 |         return sum;
312 |     }
313 | };
314 | 
315 | //33. Search in Rotated Sorted Array
316 | class Solution {
317 | public:
318 |     int search(vector<int>& nums, int target) {
319 |         int low=0; 
320 |         int high = nums.size() -1;
321 | 
322 |         while( low <= high){
323 |             int mid = (low + high) / 2;
324 | 
325 |             if(nums[mid] == target) return mid;
326 | 
327 |             if(nums[low] <= nums[mid]){
328 |                 if(nums[low] <= target && target <= nums[mid]){
329 |                     high = mid - 1;
330 |                 }else{
331 |                     low = mid + 1;
332 |                 }
333 |             }else{
334 |                 if(nums[mid] <= target && target <= nums[high]){
335 |                     low = mid + 1;
336 |                 }else{
337 |                     high = mid - 1;
338 |                 }
339 |             }
340 |         }
341 |         return -1;
342 |     }
343 | };
344 | 
345 | 
346 | 
347 | //1, 3, 4, 7, 9, 9 12, 56
348 | 
349 | int min = LLONG_MAX;
350 | 
351 | for(int i=0; i<n-m-1; i++){  //i+m-1<n -> i<n-m+1
352 |     int diff = min(arr[i+m-1] - arr[i]);
353 | }
354 | return min;
355 | 
356 | 
357 | 
358 | 
359 | 
360 | //contains Duplicate
361 | class Solution {
362 | public:
363 |     bool containsDuplicate(vector<int>& nums) {
364 |         unordered_set<int >s(nums.begin(), nums.end());
365 |         return nums.size() != s.size();
366 |     }
367 | };
368 | 
369 | 
370 | class Solution {
371 | public:
372 |     bool containsDuplicate(vector<int>& nums) {
373 |         sort(nums.begin(), nums.end());
374 |         int n = nums.size();
375 |         for(int i=1; i<n; i++){
376 |             if(nums[i-1] == nums[i]){
377 |                 return true;
378 |             }
379 |         }
380 |         return false;
381 |     }
382 | };
383 | 
384 | 
385 | //Minimum Swaps to Group All 1's Together
386 | class Solution {
387 | public:
388 |     int minSwaps(vector<int>& nums) {
389 |         int n = nums.size();
390 |         int o=0, z=0;
391 | 
392 |         for(int i=0; i<n; i++){
393 |             o += (nums[i]==1);
394 |             z += (nums[i]==0);
395 |         }
396 | 
397 |         nums.insert(nums.end(), nums.begin(), nums.end());
398 | 
399 |         int ans = n;
400 |         int i=0, j=0, one=0;
401 | 
402 |         while(j<2*n){
403 |             one += (nums[j]==1);
404 | 
405 |             if(j-i+1 == o){
406 |                 ans = min(ans, o-one);
407 |                 one -= (nums[i]==1);
408 |                 i++;
409 |             }
410 |             j++;
411 |         }
412 |         return(ans==n ? 0:ans);
413 |     }
414 | };
415 | 
416 | //Count Senior number of citizen
417 | 
418 | int count = 0;
419 | 
420 | for(String s: arr){
421 |     int a = (s[11]-'O' * 10)+(s[12]-'O');
422 |     if(a>60){
423 |         count++;
424 |     }
425 |     return count;
426 | }
427 | 
428 | 
429 | 
430 | 
431 | 
432 | // 53. Maximum Subarray
433 | // Approach 1: Brute Force
434 | // for(int i=0 ->n){
435 | // for(int j=0 ->n){
436 | //     for(int k=i -> j){
437 | //         sum = sum + arr[k];
438 | //     }
439 | // }
440 | // }
441 | 
442 | // for(int i=0 ->n){
443 | //     sum
444 | // for(int j=0 ->n){
445 | //     for(int k=i -> j){
446 | //         sum = sum + arr[k];
447 | //     }
448 | // }
449 | // }
450 | 
451 | 
452 | 
453 | class Solution {
454 | public:
455 |     int maxSubArray(vector<int>& nums) {
456 |         int sum = 0;
457 |         int maxi = nums[0];
458 | 
459 | 
460 |         for(int i=0; i<nums.size(); i++){
461 |             //Step-1
462 |             sum = sum + nums[i];
463 |             //Step-2
464 |             maxi = max(maxi, sum);
465 |             //Step-3
466 |             if(sum<0)
467 |                 sum=0;
468 |         }
469 |         return maxi;
470 |     }
471 | };
472 | 
473 | 
474 | 
475 | // DSA Sheet Sloving String Q-1: Maximum and minimum of an array using minimum number of comparisons
476 | // Approch-1: set max and min from 1st two element of array
477 | 
478 | #include <iostream>
479 | using namespace std;
480 | 
481 | int main() {
482 |     int n = 0;
483 |     int arr[n];
484 |     int max, min;
485 |     cin>>n;
486 |     for(int i=0; i<n; i++){
487 |         cin>>arr[i];
488 |     }
489 |     if(n==0){
490 |         max = arr[0];
491 |         min = arr[0];
492 |     }
493 |     if(n==1){
494 |         if(arr[0]>arr[1]){
495 |             max = arr[0];
496 |             min = arr[1];
497 |         }
498 |         else{
499 |             max = arr[1];
500 |             min = arr[0];
501 |         }
502 |     }
503 |     else{
504 |         if(arr[0]>arr[1]){
505 |             max = arr[0];
506 |             min = arr[1];
507 |         }
508 |         else{
509 |             max = arr[1];
510 |             min = arr[0];
511 |         }
512 |         for(int i=2; i<n; i++){
513 |             if(max<arr[i]){
514 |                 max = arr[i];
515 |             }
516 |             if(min>arr[i]){
517 |                 min = arr[i];
518 |             }
519 |         }
520 |     }
521 |     cout<<"Max" << max<<endl;
522 |     cout<<"Min" << min<<endl;
523 | 
524 |     return 0;
525 | }
526 | 
527 | 
528 | // DSA Sheet Sloving String Q-2: Array Reverse
529 | // Online C++ compiler to run C++ program online
530 | #include <iostream>
531 | using namespace std;
532 | 
533 | int main() {
534 |     
535 |     int n, i, j, temp;
536 |     int arr[n];
537 |     
538 |     cin>>n;
539 |     
540 |     for(int k=0; k<n; k++){
541 |         cin >> arr[k];
542 |     }
543 |     
544 |     
545 |     for(int i=0, j=n-1; i<n/2; i++,j--){
546 |         temp = arr[i];
547 |         arr[j] = arr[i];
548 |         arr[j] = temp;
549 |     }
550 |     
551 |     for(int k=0; k<n; k++){
552 |         cout << arr[k];
553 |     }
554 |     
555 |     
556 |     return 0;
557 | }
558 | 
559 | 
560 | 
561 | 
562 | // #include <iostream>
563 | // using namespace std;
564 | 
565 | // /* run this program using the console pauser or add your own getch, system("pause") or input loop */
566 | 
567 | // void printSum(int arr[][3], int row, int col){
568 | // 	for(int row=0; row<3; row++){
569 | // 		int sum = 0;
570 | // 		for(int col=0; col<3; col++){
571 | // 					sum += arr[row][col];	
572 | // 		}
573 | // 		cout<<sum<<" ";
574 | // 	}
575 | // }
576 | 
577 | // void printcolSum(int arr[][3], int row, int col){
578 | // 	for(int row=0; row<3; row++){
579 | // 		int sum = 0;
580 | // 		for(int col=0; col<3; col++){
581 | // 					sum += arr[col][row];	
582 | // 		}
583 | // 		cout<<sum<<" ";
584 | // 	}
585 | // }
586 | 
587 | 
588 | // bool isPresent(int arr[][4], int target, int row, int col){
589 | // 	for(int row=0; row<3; row++){
590 | // 		for(int col=0; col<4; col++){
591 | 			
592 | // 			if(arr[row][col] == target){
593 | // 				return 1;
594 | // 			}
595 | 			
596 | // 		}
597 | // 	}
598 | // 	return 0;
599 | // }
600 | 
601 | 
602 | // int LargetRowSum(int arr[][3], int row, int col){
603 | // 	int maxi = INT_MIN;
604 | // 	int rowIndex = -1;
605 | // 	for( int row=0; row<3; row++){
606 | // 		int sum = 0;
607 | // 		for(int col=0; col<3; col++){
608 | // 			sum += arr[row][col];
609 | // 		}
610 | // 		if(sum > maxi){
611 | // 			maxi = sum;
612 | // 			rowIndex = row;
613 | // 		}
614 | // 	}
615 | // 	return rowIndex;
616 | // }
617 | 
618 | 
619 | // int main(int argc, char** argv) {
620 | 	
621 | // //	int arr1[3][4] = {{1,11,111,1111}, {2,22,222,2222}, {3,33,333,3333}};
622 | // 	int arr2[3][3];
623 | 	
624 | // 	for(int row=0; row<3; row++){
625 | // 		for(int col=0; col<3; col++){
626 | // 			cin>>arr2[row][col];
627 | // 		}
628 | // 	}
629 | 	
630 | // 	for(int row=0; row<3; row++){
631 | // 		for(int col=0; col<3; col++){
632 | // 			cout<<arr2[row][col]<<" ";
633 | // 		}
634 | // 		cout<<endl;
635 | // 	}
636 | 	
637 | 
638 | // //Sieve of Eratosthenes
639 | 	
640 | // //	class Solution {
641 | // //public:
642 | // //    int countPrimes(int n) {
643 | // //        int count = 0;
644 | // //       vector<bool> prime(n+1, true);
645 | // //       prime[0] = prime[1] = false;
646 | // //
647 | // //       for(int i=2; i<n; i++){
648 | // //           if(prime[i]){
649 | // //               count++;
650 | // //               for(int j=2*i; j<n; j=j+i){
651 | // //                   prime[j] = 0;
652 | // //              }
653 | // //           }
654 | // //       }
655 | // //        return count;
656 | // //    }
657 | // //};
658 | 	
659 | 	
660 | // //	class Solution {
661 | // //    bool isPrime(int n){
662 | // //        if(n<=1){
663 | // //            return false;
664 | // //        }
665 | // //        for(int i=2; i<n; i++){
666 | // //            if(n%i==0){
667 | // //                return false;
668 | // //            }
669 | // //        }
670 | // //        return true;
671 | // //    }
672 | // //public:
673 | // //    int countPrimes(int n) {
674 | // //        int count = 0;
675 | // //        for(int i=2; i<n; i++){
676 | // //            if(isPrime(i)){
677 | // //                count++;
678 | // //            }
679 | // //        }
680 | // //        return count;
681 | // //    }
682 | // //};
683 | 	
684 | 	
685 | // //	int target;
686 | // //	cin>>target;
687 | 	
688 | // //	if(isPresent(arr1, target, 3, 4)){	
689 | // //		cout<<"Element Found";
690 | // //	}	
691 | // //	else{
692 | // //		cout<<"Element Not Found";
693 | // //	}
694 | 
695 | // 	cout<<"Row Wise Sum = ";
696 | // 	printSum(arr2, 3, 3);
697 | // 	cout<<endl;
698 | // //	cout<<"Colum Wise Sum = ";
699 | // //	printcolSum(arr2, 3, 3);
700 | // //	cout<<endl;
701 | 	
702 | // 	cout<<"The Largest Sum is "<<LargetRowSum(arr2, 3,  3);	
703 | 	
704 | // 	return 0;
705 | // }
706 | 
707 | 
708 | // //54. Spiral Matrix
709 | // //class Solution {
710 | // //public:
711 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
712 | // //        int row = matrix.size();
713 | // //        int col = matrix[0].size();
714 | // //        vector<int> ans;
715 | // //        int count = 0;
716 | // //        int total = row*col;
717 | // //        int startingRow = 0;
718 | // //        int startingCol = 0;
719 | // //        int endingRow = row-1;
720 | // //        int endingCol = col-1;
721 | // //
722 | // //        while(count<total){
723 | // //
724 | // //            for(int i=startingCol; count<total && i<=endingCol; i++){
725 | // //                ans.push_back(matrix[startingRow][i]);
726 | // //                count++;
727 | // //            }
728 | // //            startingRow++;
729 | // //
730 | // //            for(int i=startingRow; count<total &&i<=endingRow; i++){
731 | // //                ans.push_back(matrix[i][endingCol]);
732 | // //                count++;
733 | // //            }
734 | // //            endingCol--;
735 | // //
736 | // //            for(int i=endingCol; count<total && i>=startingCol; i--){
737 | // //                ans.push_back(matrix[endingRow][i]);
738 | // //                count++;
739 | // //            }
740 | // //            endingRow--;
741 | // //
742 | // //            for(int i=endingRow; count<total && i>=startingRow; i--){
743 | // //                ans.push_back(matrix[i][startingCol]);
744 | // //                count++;
745 | // //            }
746 | // //            startingCol++;
747 | // //        }
748 | // //        return ans;
749 | // //    }
750 | // //};
751 | // //class Solution {
752 | // //public:
753 | // //    vector<int> spiralOrder(vector<vector<int>>& matrix) {
754 | // //        int n=matrix.size(),m=matrix[0].size();
755 | // //        int left=0,top=0;
756 | // //        int bottom=n-1,right=m-1;
757 | // //        vector<int>ans;
758 | // //        while(left<=right&&top<=bottom)
759 | // //        {
760 | // //            for(int i=left;i<=right;i++)
761 | // //            {
762 | // //                ans.push_back(matrix[top][i]);
763 | // //            }
764 | // //            top++;
765 | // //            for(int i=top;i<=bottom;i++)
766 | // //            {
767 | // //                ans.push_back(matrix[i][right]);
768 | // //            }
769 | // //            right--;
770 | // //            if(top<=bottom)
771 | // //            {
772 | // //                for(int i=right;i>=left;i--)
773 | // //                {
774 | // //                    ans.push_back(matrix[bottom][i]);
775 | // //                }
776 | // //                bottom--;
777 | // //            }
778 | // //            if(left<=right)
779 | // //            {
780 | // //                for(int i=bottom;i>=top;i--)
781 | // //                {
782 | // //                    ans.push_back(matrix[i][left]);
783 | // //                }
784 | // //                left++;
785 | // //            }
786 | // //        }
787 | // //        return ans;
788 | // //    }
789 | // //};
790 | 
791 | // //Rotate Image by 90 degree
792 | // //class Solution {
793 | // //public:
794 | // //    void rotate(vector<vector<int>>& matrix) {
795 | // //        int n = matrix.size();
796 | // //        for(int i=0; i<(n+1)/2;i++){
797 | // //            for(int j=0; j<n/2; j++){
798 | // //                int temp = matrix[n-1-j][i];
799 | // //                matrix[n-1-j][i] = matrix[n-1-i][n-j-1];
800 | // //                matrix[n-1-i][n-j-1] = matrix[j][n-1-i];
801 | // //                matrix[j][n-1-i] = matrix[i][j];
802 | // //                matrix[i][j] = temp;
803 | // //            }
804 | // //        }
805 | // //    }
806 | // //    
807 | // //};
808 | 
809 | 
810 | 
811 | 
812 | 
813 | 
814 | 
815 | 
816 | 
817 | 
818 | 
819 | 
820 | 
821 | // //Print Like a Wave
822 | // //#include <bits/stdc++.h> 
823 | // //vector<int> wavePrint(vector<vector<int>> arr, int nRows, int mCols)
824 | // //{
825 | // //    vector<int> ans;
826 | // //
827 | // //    for(int col=0; col<mCols; col++){
828 | // //        if(col&1){
829 | // //            for(int row=nRows-1; row>=0; row--){
830 | // //                ans.push_back(arr[row][col]);
831 | // //            }
832 | // //        }
833 | // //        else{
834 | // //            for(int row=0; row<nRows; row++){
835 | // //                ans.push_back(arr[row][col]);
836 | // //            }
837 | // //        }
838 | // //    }
839 | // //    return ans;
840 | // //}
841 | 
842 | 
843 | 
844 | 
845 | // // 2d matrix
846 | 
847 | // //class Solution {
848 | // //public:
849 | // //    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
850 | // //        // if(matrix.size()==0 || matrix[0].size()==0){
851 | // //        //     return matrix;
852 | // //        // }
853 | // //        vector<int> ans;
854 | // //        int m = matrix.size();
855 | // //        int n = matrix[0].size();
856 | // //        int row=0, col=0;        
857 | // //        bool up = true;
858 | // //
859 | // //        while(row<m && col<n){
860 | // //            if(up){
861 | // //                while(row>0 && col<n-1){
862 | // //                    ans.push_back(matrix[row][col]);
863 | // //                    row--;
864 | // //                    col++;
865 | // //                }
866 | // //                 ans.push_back(matrix[row][col]);
867 | // //                 if(col==n-1){
868 | // //                     row++;
869 | // //                 }
870 | // //                 else{
871 | // //                     col++;
872 | // //                 }
873 | // //            }
874 | // //            else{
875 | // //                while(col>0 && row<m-1){
876 | // //                 ans.push_back(matrix[row][col]);
877 | // //                 row++;
878 | // //                 col--;   
879 | // //                }
880 | // //                ans.push_back(matrix[row][col]);
881 | // //                if(row==m-1){
882 | // //                    col++;
883 | // //                }
884 | // //                else{
885 | // //                    row++;
886 | // //                }
887 | // //            }
888 | // //            up = !up; // Fix: Toggle the boolean variable 'up'
889 | // //        }
890 | // //        return ans;
891 | // //    }
892 | // //};
893 | 
894 | 
895 | 
896 | 
897 | // // Modular Exponentiation
898 | // //#include <bits/stdc++.h>
899 | // //
900 | // //int modularExponentiation(int x, int n, int m) {
901 | // //	int res = 1;
902 | // //	while(n>0){
903 | // //		if(n&1){
904 | // //			res = (1LL*(res) * (x)%m)%m;
905 | // //		}
906 | // //		x = (1LL * (x)%m * (x)%m) %m;
907 | // //		n = n>>1;
908 | // //	}
909 | // //	return res;
910 | // //}
911 | 
912 | 
913 | 
914 | #include <iostream>
915 | using namespace std;
916 | 
917 | int main() {
918 |     int t;
919 |     cin >> t;  // Read number of test cases
920 |     
921 |     while (t--) {
922 |         int a1, a2, b1, b2;
923 |         cin >> a1 >> a2 >> b1 >> b2;
924 |         
925 |         int suneeWins = 0;
926 |         
927 |         // Compare the values in each possible way to determine Sunee's wins
928 |         if ((a1 > b1 && a2 > b2) || (a1 > b2 && a2 > b1)) {
929 |             suneeWins = 1;
930 |         }
931 |         
932 |         cout << suneeWins << endl;
933 |     }
934 |     
935 |     return 0;
936 | }
937 | 
938 | 
939 | #include <iostream>
940 | using namespace std;
941 | 
942 | int main() {
943 |     int t;
944 |     cin >> t;  // Read number of test cases
945 |     
946 |     while(t--) {
947 |         int n;
948 |         cin >> n;  // Read the two-digit positive integer
949 |         int sum = (n / 10) + (n % 10);  // Calculate the sum of the digits
950 |         cout << sum << endl;  // Output the result
951 |     }
952 | 
953 |         return 0;
954 |     }
955 | 
956 | 
957 | #include <iostream>
958 | using namespace std;
959 | 
960 | 
961 | int main() {
962 |     int t;
963 |     cin >> t;  // Read number of test cases
964 |     
965 |     while(t--){
966 |         int a1, a2, b1, b2;
967 |         cin>>a1>>a2>>b1>>b2;
968 |         
969 |         int suneeWins = 0;
970 |         
971 |         if(a1>b1 && a2>b2){
972 |             suneeWins++;
973 |         }
974 |         if(a1>b2 && a2>b1){
975 |             suneeWins++;
976 |         }
977 |         if(a2>b1 && a1>b2){
978 |             suneeWins++;
979 |         }
980 |         
981 |         cout<<suneeWins<<endl;
982 |     }
983 |     
984 |     
985 |     return 0;
986 | }
987 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | **DSA LeetCode 365-Day Streak Challenge** 🚀
 2 | 
 3 | Welcome to my 365-day journey of conquering Data Structures and Algorithms on LeetCode! 👨‍💻
 4 | 
 5 | ### 📖 What's This Challenge About?
 6 | 
 7 | For the next 365 days, I'm committed to daily sessions of diving into LeetCode problems, sharpening my problem-solving skills, and mastering various data structures and algorithms. 🏋️‍♂️
 8 | 
 9 | ### 🚨 Why LeetCode?
10 | 
11 | LeetCode is not just a platform; it's my daily workout ground for coding muscles. It offers a vast collection of real-world coding challenges that help me enhance my problem-solving skills and algorithmic thinking.
12 | 
13 | ### 📈 What to Expect?
14 | 
15 | - **Daily Commitment**: Each day, I'll be pushing code related to a LeetCode problem.
16 | - **Progress Tracking**: I'll maintain a log of the problems solved and the concepts learned.
17 | - **Learning Resources**: Feel free to check out the resources I find helpful along the way.
18 | 
19 | ### 🛠️ Tech Stack:
20 | 
21 | - **Language**: C++
22 | - **Version Control**: Git
23 | - **Documentation**: Detailed explanations and thought process with each solution.
24 | 
25 | ### 📚 Learning Together:
26 | 
27 | I'm open to collaboration and learning together! If you have suggestions, improvements, or just want to discuss a particular problem, feel free to open an issue or pull request.
28 | 
29 | ### 🏆 Goal:
30 | 
31 | The ultimate goal is not just the completion of 100 days but the continuous improvement and understanding of efficient problem-solving approaches.
32 | 
33 | ### 🎯 Let's Connect:
34 | 
35 | Connect with me on [LinkedIn](https://www.linkedin.com/in/mustafahassan2001/) and let's learn and grow together! 🌐
36 | 
37 | **Happy Coding! 🚀**
38 | 


--------------------------------------------------------------------------------