├── Arrays
    ├── README.md
    ├── add_to_array_form_of_int.cpp
    ├── build_array_from_permutation.cpp
    ├── can_matrix_obtained_by_turning.cpp
    ├── cells_with_odd_values.cpp
    ├── concatenation_of_Array.cpp
    ├── count_elements_matching_rule.cpp
    ├── create_target_array_in_given_order.cpp
    ├── find_n_unique_integers_sum_upto_0.cpp
    ├── first_and_last_occurence.cpp
    ├── flipping_an_image.cpp
    ├── highest_altitude.cpp
    ├── jump_game.cpp
    ├── kids_with_greatest_no_of_candies.cpp
    ├── matrix_diagonal_sum.cpp
    ├── matrix_transpose.cpp
    ├── maximum_population_year.cpp
    ├── no_of_good_pairs.cpp
    ├── no_of_no_witth_even_no_of_digits.cpp
    ├── no_smaller_than_curr_no.cpp
    ├── pangram_String.cpp
    ├── product_of_array_except_self.cpp
    ├── richest_customber_wealth.cpp
    ├── rotate_array.cpp
    ├── running_sum_of_1d_Array.cpp
    ├── set_zeroes.cpp
    ├── shuffle_the_Array.cpp
    ├── spiral_matrix.cpp
    └── two_sum.cpp
├── README.md
├── Searching
    ├── README.md
    ├── arranging_coin.cpp
    ├── binary_search.cpp
    ├── check_if_n_and_its_double_exist.cpp
    ├── count_negatives.cpp
    ├── fair_candy_swap.cpp
    ├── find_first_and_last_position_of_element_in_sorted_array.cpp
    ├── first_bad_version.cpp
    ├── guess_no_higher_lower.cpp
    ├── intersection_of_two_arrays_i.cpp
    ├── intersection_of_two_arrays_ii.cpp
    ├── kth_missing_positive_no.cpp
    ├── min_in_rotated_arr.cpp
    ├── peak_ele.cpp
    ├── peak_in_mountain_array.cpp
    ├── search_in_rotated_array.cpp
    ├── search_in_rotated_array_ii.cpp
    ├── search_insert_position.cpp
    ├── single_element_in_sorted_array.cpp
    ├── smallest_letter_greater_than_target.cpp
    ├── special_array_with_x_elements_greater_than_or_equal_x.cpp
    ├── sqrt.cpp
    ├── two_sum_ii_input_array_is_sorted.cpp
    └── valid_perfect_square.cpp
├── Sorting
    ├── README.md
    ├── contains_duplicate.cpp
    ├── intersection_of_two_arrays_i.cpp
    ├── majority_ele.cpp
    ├── maximum_product_of_3_no.cpp
    ├── merge_sorted_array.cpp
    ├── missing_no.cpp
    ├── third_maximum_no.cpp
    └── two_sum_ii_input_array_is_sorted.cpp
├── String
    ├── README.md
    ├── anagram.cpp
    ├── excel_sheet_col_no.cpp
    ├── excel_sheet_col_title.cpp
    ├── first_unique_char.cpp
    ├── no_of_segments_in_string.cpp
    ├── palindrome.cpp
    ├── reverse_string.cpp
    └── rotate_string.cpp
└── pattern


/Arrays/README.md:
--------------------------------------------------------------------------------
 1 | # Arrays interview questions from Leetcode
 2 | 
 3 | ### Easy
 4 | | S.No. | Question | Solution |
 5 | |----| --------------- | -------- |
 6 | |1. | [Build Array from Permutation](https://leetcode.com/problems/build-array-from-permutation/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/build_array_from_permutation.cpp)|
 7 | |2. | [Concatenation of Array](https://leetcode.com/problems/concatenation-of-array/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/concatenation_of_Array.cpp)|
 8 | |3. | [Running Sum of 1d Array](https://leetcode.com/problems/running-sum-of-1d-array/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/running_sum_of_1d_Array.cpp)|
 9 | |4. | [Richest Customer Wealth](https://leetcode.com/problems/richest-customer-wealth/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/richest_customber_wealth.cpp)|
10 | |5. | [Shuffle the Array](https://leetcode.com/problems/shuffle-the-array/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/shuffle_the_Array.cpp)|
11 | |6. | [Kids With the Greatest Number of Candies](https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/kids_with_greatest_no_of_candies.cpp)|
12 | |7. | [Number of Good Pairs](https://leetcode.com/problems/number-of-good-pairs/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/no_of_good_pairs.cpp)|
13 | |8. | [How Many Numbers Are Smaller Than the Current Number](https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/cells_with_odd_values.cpp)|
14 | |9. | [Create Target Array in the Given Order](https://leetcode.com/problems/create-target-array-in-the-given-order/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/create_target_array_in_given_order.cpp)|
15 | |10. | [Check if the Sentence Is Pangram](https://leetcode.com/problems/check-if-the-sentence-is-pangram/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/pangram_String.cpp)|
16 | |11. | [Count Items Matching a Rule](https://leetcode.com/problems/count-items-matching-a-rule/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/count_elements_matching_rule.cpp)|
17 | |12. | [Find the Highest Altitude](https://leetcode.com/problems/find-the-highest-altitude/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/highest_altitude.cpp)|
18 | |13. | [Flipping an Image](https://leetcode.com/problems/flipping-an-image/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/flipping_an_image.cpp)|   
19 | |14. | [Cells with Odd Values in a Matrix](https://leetcode.com/problems/cells-with-odd-values-in-a-matrix/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/cells_with_odd_values.cpp)|
20 | |15. | [Matrix Diagonal Sum](https://leetcode.com/problems/matrix-diagonal-sum/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/matrix_diagonal_sum.cpp)|
21 | |16. | [Find Numbers with Even Number of Digits](https://leetcode.com/problems/find-numbers-with-even-number-of-digits/)|[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/no_of_no_witth_even_no_of_digits.cpp)|
22 | |17. | [Transpose Matrix](https://leetcode.com/problems/transpose-matrix/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/matrix_transpose.cpp)|
23 | |18. | [Add to Array-Form of Integer](https://leetcode.com/problems/add-to-array-form-of-integer/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/add_to_array_form_of_int.cpp)|
24 | |19. | [Maximum Population Year](https://leetcode.com/problems/maximum-population-year/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/maximum_population_year.cpp)|
25 | |20. | [Determine Whether Matrix Can Be Obtained By Rotation](https://leetcode.com/problems/determine-whether-matrix-can-be-obtained-by-rotation/) |[Solution](/Arrays/can_matrix_obtained_by_turning.cpp)|
26 | |21. | [Two Sum](https://leetcode.com/problems/two-sum/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/two_sum.cpp)|
27 | |22. | [Find N Unique Integers Sum up to Zero](https://leetcode.com/problems/find-n-unique-integers-sum-up-to-zero/) |[Solution](https://github.com/geeky01adarsh/DSA-Interview-Questions/blob/main/Arrays/find_n_unique_integers_sum_upto_0.cpp)|
28 | 
29 | ### Medium
30 | | S.No. | Question | Solution |
31 | |----| --------------- | -------- |
32 | |1. | [Spiral Matrix](https://leetcode.com/problems/spiral-matrix/) |[Solution](/Arrays/spiral_matrix.cpp)|
33 | |2. | [Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/) |[Solution](set_zeroes.cpp)|
34 | |3. | [Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/) |[Solution](product_of_array_except_self.cpp)|
35 | |4. | [Find First and Last Position of Element in Sorted Array](https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/) |[Solution](first_and_last_occurence.cpp)|
36 | |5. | [Jump Game](https://leetcode.com/problems/jump-game/) |[Solution](jump_game.cpp)|
37 | |6. | [Rotate Array](https://leetcode.com/problems/rotate-array/) |[Solution](rotate_array.cpp)|
38 | 


--------------------------------------------------------------------------------
/Arrays/add_to_array_form_of_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> addToArrayForm(vector<int>& num, int k) {
 5 |         int carry=k;
 6 |         reverse(num.begin(),num.end());
 7 |         
 8 |         for(int i=0;i<num.size();i++ )
 9 |         {
10 |             int sum=num[i]+carry;
11 |             num[i]=sum%10;
12 |             carry=sum/10;
13 |             
14 |         }
15 |         if(carry!=0)
16 |         {
17 |             while(carry)
18 |             {
19 |                 num.push_back(carry%10);
20 |                 carry=carry/10;
21 |             }
22 |         }
23 |         reverse(num.begin(),num.end());
24 |         return num;
25 |     }
26 | 
27 | int main()
28 | {
29 |     int t;
30 |     cin >> t;
31 |     while (t--)
32 |     {
33 |         int n, k;
34 |         cin >> n >> k;
35 |         vector<int> nums;
36 |         for (int i = 0; i < n; i++)
37 |         {
38 |             int temp;
39 |             cin >> temp;
40 |             nums.push_back(temp);
41 |         }
42 |         vector<int> v = addToArrayForm(nums, k);
43 |         for(auto i:v)
44 |             cout<<i<<" ";
45 |         cout<<endl;
46 |     }
47 | }


--------------------------------------------------------------------------------
/Arrays/build_array_from_permutation.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | vector<int> buildArray(vector<int> &nums)
 6 | {
 7 |     vector<int> ans;
 8 |     for (int i = 0; i < nums.size(); i++)
 9 |     {
10 |         ans.push_back(nums[nums[i]]);
11 |     }
12 |     return ans;
13 | }
14 | 
15 | int main()
16 | {
17 |     int t;
18 |     cin >> t;
19 |     while (t--)
20 |     {
21 |         int n;
22 |         cin >> n;
23 |         vector<int> v;
24 |         for (int i = 0; i < n; i++)
25 |         {
26 |             int temp;
27 |             cin >> temp;
28 |             v.push_back(temp);
29 |         }
30 |         v = buildArray(v);
31 |         for (auto i : v)
32 |             cout << i << " ";
33 |         cout << endl;
34 |     }
35 | }


--------------------------------------------------------------------------------
/Arrays/can_matrix_obtained_by_turning.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void turn(vector<vector<int>> &vec)
 5 | {
 6 |     int p = vec.size();
 7 |     vector<vector<int>> result;
 8 |     for (int i = 0; i < p; i++)
 9 |     {
10 |         vector<int> v;
11 |         for (int j = p - 1; j >= 0; j--)
12 |         {
13 |             v.push_back(vec[j][i]);
14 |         }
15 |         result.push_back(v);
16 |     }
17 |     vec = result;
18 | }
19 | 
20 | bool findRotation(vector<vector<int>> &mat, vector<vector<int>> &target)
21 | {
22 |     if (mat == target)
23 |         return true;
24 |     int num = 3;
25 |     while (num)
26 |     {
27 |         turn(mat);
28 |         if (mat == target)
29 |             return true;
30 |         num--;
31 |     }
32 |     return false;
33 | }
34 | 
35 | int main()
36 | {
37 |     int t;
38 |     cin >> t;
39 |     while (t--)
40 |     {
41 |         int r;
42 |         cin >> r;
43 |         vector<vector<int>> nums, target;
44 |         for (int i = 0; i < r; i++)
45 |         {
46 |             vector<int> v;
47 |             for (int j = 0; j < r; j++)
48 |             {
49 |                 int temp;
50 |                 cin >> temp;
51 |                 v.push_back(temp);
52 |             }
53 |             nums.push_back(v);
54 |         }
55 |         for (int i = 0; i < r; i++)
56 |         {
57 |             vector<int> v;
58 |             for (int j = 0; j < r; j++)
59 |             {
60 |                 int temp;
61 |                 cin >> temp;
62 |                 v.push_back(temp);
63 |             }
64 |             target.push_back(v);
65 |         }
66 | 
67 |         cout << findRotation(nums, target) << endl;
68 |     }
69 | }


--------------------------------------------------------------------------------
/Arrays/cells_with_odd_values.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int oddCells(int m, int n, vector<vector<int>> &indices)
 5 | {
 6 |     vector<int> row(m, 0), col(n, 0);
 7 | 
 8 |     for (int i = 0; i < indices.size(); i++)
 9 |     {
10 |         row[indices[i][0]]++;
11 |         col[indices[i][1]]++;
12 |     }
13 |     int ans = 0;
14 |     for (int i = 0; i < m; i++)
15 |     {
16 |         for (int j = 0; j < n; j++)
17 |         {
18 |             if (row[i] + col[j] & 1)
19 |                 ans++;
20 |         }
21 |     }
22 |     return ans;
23 | }
24 | 
25 | int main()
26 | {
27 |     int t;
28 |     cin >> t;
29 |     while (t--)
30 |     {
31 |         int r; 
32 |         cin>>r;
33 |         int m, n;
34 |         cin >> m >> n;
35 |         vector<vector<int>> nums;
36 |         for (int i = 0; i < r; i++)
37 |         {
38 |             vector<int> v;
39 |             for (int j = 0; j < 2; j++)
40 |             {
41 |                 int temp;
42 |                 cin >> temp;
43 |                 v.push_back(temp);
44 |             }
45 |             nums.push_back(v);
46 |         }
47 | 
48 |         cout<<oddCells(m, n, nums)<<endl;
49 |     }
50 | }


--------------------------------------------------------------------------------
/Arrays/concatenation_of_Array.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> getConcatenation(vector<int> &nums)
 5 | {
 6 |     vector<int> ans;
 7 |     for (int i = 0; i < nums.size(); i++)
 8 |         ans.push_back(nums[i]);
 9 |     for (int i = 0; i < nums.size(); i++)
10 |         ans.push_back(nums[i]);
11 |     return ans;
12 | }
13 | 
14 | int main()
15 | {
16 |     int t;
17 |     cin >> t;
18 |     while (t--)
19 |     {
20 |         int n;
21 |         cin >> n;
22 |         vector<int> nums;
23 |         for (int i = 0; i < n; i++)
24 |         {
25 |             int temp;
26 |             cin >> temp;
27 |             nums.push_back(temp);
28 |         }
29 |         vector<int> v = getConcatenation(nums);
30 |         for(auto i:v)
31 |             cout<<i<<" ";
32 |         cout<<endl;
33 |     }
34 | }


--------------------------------------------------------------------------------
/Arrays/count_elements_matching_rule.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int countMatches(vector<vector<string>>& items, string ruleKey, string ruleValue) {
 5 |         int count =0; 
 6 |         for(int i=0; i<items.size(); i++){
 7 |             if(ruleKey=="type")
 8 |                 if(items[i][0]==ruleValue)
 9 |                     count++;
10 |             if(ruleKey == "color")
11 |                 if(items[i][1]==ruleValue)
12 |                     count++;
13 |             if(ruleKey == "name")
14 |                 if(items[i][2]==ruleValue)
15 |                     count++;
16 |         }
17 |         return count;
18 |     }
19 | 
20 | int main(){
21 |     int t;
22 |     cin>>t;
23 |     while(t--){
24 |         int n;
25 |         cin>>n;
26 |         string ruleKey, ruleValue;
27 |         cin>>ruleKey>>ruleValue;
28 |         vector<vector<string>> items;
29 |         for(int i=0; i<n; i++){
30 |             vector<string> s;
31 |             for(int j=0; j<3; j++){
32 |                 string temp;
33 |                 cin>>temp;
34 |                 s.push_back(temp);
35 |             }
36 |             items.push_back(s);
37 |         }
38 |         cout<<countMatches(items, ruleKey, ruleValue)<<endl;
39 |     }
40 |     return 0;
41 | }


--------------------------------------------------------------------------------
/Arrays/create_target_array_in_given_order.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> createTargetArray(vector<int> &nums, vector<int> &index)
 5 | {
 6 |     int n = index.size();
 7 |     vector<int> targetArray;
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         targetArray.insert(targetArray.begin() + index[i], nums[i]);
11 |     }
12 |     return targetArray;
13 | }
14 | 
15 | int main()
16 | {
17 |     int t;
18 |     cin >> t;
19 |     while (t--)
20 |     {
21 |         int n;
22 |         cin >> n;
23 |         vector<int> nums, index;
24 |         for (int i = 0; i < n; i++)
25 |         {
26 |             int temp;
27 |             cin >> temp;
28 |             nums.push_back(temp);
29 |         }
30 |         for (int i = 0; i < n; i++)
31 |         {
32 |             int temp;
33 |             cin >> temp;
34 |             index.push_back(temp);
35 |         }
36 |         vector<int> v = createTargetArray(nums, index);
37 |         for (auto i : v)
38 |             cout << i << " ";
39 |         cout << endl;
40 |     }
41 | }


--------------------------------------------------------------------------------
/Arrays/find_n_unique_integers_sum_upto_0.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> sumZero(int n)
 5 | {
 6 |     vector<int> ans;
 7 |     int itr = 0;
 8 |     if(n==0) return {0};
 9 |     if (n % 2)
10 |         for (int i = 0; i <= n / 2; i++)
11 |         {
12 |             ans.push_back(itr);
13 |             if (i)
14 |             {
15 |                 ans.push_back(0 - itr);
16 |             }
17 |             itr++;
18 |         }
19 |     else
20 |     {
21 |         itr = 1;
22 |         for (int i = 0; i < n / 2; i++)
23 |         {
24 | 
25 |             ans.push_back(0 - itr);
26 |             ans.push_back(itr);
27 |             itr++;
28 |         }
29 |     }
30 |     return ans;
31 | }
32 | 
33 | int main()
34 | {
35 |     int t;
36 |     cin >> t;
37 |     while (t--)
38 |     {
39 |         int n;
40 |         cin >> n;
41 |         vector<int> v =sumZero(n);
42 |         for(auto i:v){
43 |             cout<<i<<" ";
44 |         }
45 |         cout<<endl;
46 |     }
47 |     return 0;
48 | }


--------------------------------------------------------------------------------
/Arrays/first_and_last_occurence.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> searchRange(vector<int> &nums, int target)
 5 | {
 6 |     int start = 0, end = nums.size(), mid, left, right;
 7 |     while (start < end)
 8 |     {
 9 |         mid = (start + end) / 2;
10 |         if (nums[mid] >= target)
11 |             end = mid;
12 |         else
13 |             start = mid + 1;
14 |     }
15 |     left = start;
16 |     start = 0, end = nums.size();
17 |     while (start < end)
18 |     {
19 |         mid = (start + end) / 2;
20 |         if (nums[mid] > target)
21 |             end = mid;
22 |         else
23 |             start = mid + 1;
24 |     }
25 |     right = start;
26 |     return left == right ? vector<int>{-1, -1} : vector<int>{left, right - 1};
27 | }
28 | 
29 | int main()
30 | {
31 |     int t;
32 |     cin >> t;
33 |     while (t--)
34 |     {
35 |         int n,target;
36 |         cin >> n>>target;
37 |         vector<int> nums;
38 |         for (int i = 0; i < n; i++)
39 |         {
40 |             int temp;
41 |             cin >> temp;
42 |             nums.push_back(temp);
43 |         }
44 |         vector<int> ans = searchRange(nums,target);
45 |         for(auto i:ans){
46 |             cout<<i<<" ";
47 |         }
48 |         cout<<endl;
49 |     }
50 |     return 0;
51 | }


--------------------------------------------------------------------------------
/Arrays/flipping_an_image.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<vector<int>> flipAndInvertImage(vector<vector<int>> &image)
 5 | {
 6 |     int n = image.size();
 7 |     for (int i = 0; i < n; i++)
 8 |     {
 9 |         reverse(image[i].begin(), image[i].end());
10 |     }
11 |     for (int i = 0; i < n; i++)
12 |     {
13 |         for (int j = 0; j < n; j++)
14 |         {
15 |             if (image[i][j])
16 |                 image[i][j] = 0;
17 |             else
18 |                 image[i][j] = 1;
19 |         }
20 |     }
21 |     return image;
22 | }
23 | 
24 | int main()
25 | {
26 |     int t;
27 |     cin >> t;
28 |     while (t--)
29 |     {
30 |         int n;
31 |         cin >> n;
32 |         vector<vector<int>> nums;
33 |         for (int i = 0; i < n; i++)
34 |         {
35 |             vector<int> v;
36 |             for (int j = 0; j < n; j++)
37 |             {
38 |                 int temp;
39 |                 cin >> temp;
40 |                 v.push_back(temp);
41 |             }
42 |             nums.push_back(v);
43 |         }
44 |         nums = flipAndInvertImage(nums);
45 |         for(int i=0; i<n; i++){
46 |             for(int j=0; j<n; j++){
47 |                 cout<<nums[i][j]<<" ";
48 |             }
49 |             cout<<endl;
50 |         }
51 |     }
52 | }


--------------------------------------------------------------------------------
/Arrays/highest_altitude.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int largestAltitude(vector<int> &gain)
 5 | {
 6 |     int highest_altitude = max(0, gain[0]);
 7 |     int curr_peak = gain[0];
 8 |     for (int i = 1; i < gain.size(); i++)
 9 |     {
10 |         curr_peak += gain[i];
11 |         highest_altitude = max(highest_altitude, curr_peak);
12 |     }
13 |     return highest_altitude;
14 | }
15 | 
16 | int main()
17 | {
18 |     int t;
19 |     cin >> t;
20 |     while (t--)
21 |     {
22 |         int n;
23 |         cin >> n;
24 |         vector<int> nums;
25 |         for (int i = 0; i < n; i++)
26 |         {
27 |             int temp;
28 |             cin >> temp;
29 |             nums.push_back(temp);
30 |         }
31 |         cout << largestAltitude(nums) << endl;
32 |     }
33 | }


--------------------------------------------------------------------------------
/Arrays/jump_game.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | bool canJump(vector<int> &nums)
 5 | {
 6 |     int currend = 0, currfar = 0, n = nums.size();
 7 |     for (int i = 0; i < n - 1; i++)
 8 |     {
 9 |         currfar = max(currfar, nums[i] + i);
10 |         if (i == currend)
11 |             currend = currfar;
12 |         if (currend >= n - 1)
13 |         {
14 |             break;
15 |         }
16 |     }
17 |     if (currend < n - 1)
18 |         return 0;
19 |     return 1;
20 | }
21 | 
22 | int main()
23 | {
24 |     int t;
25 |     cin >> t;
26 |     while (t--)
27 |     {
28 |         int n;
29 |         cin >> n;
30 |         vector<int> nums;
31 |         for (int i = 0; i < n; i++)
32 |         {
33 |             int temp;
34 |             cin >> temp;
35 |             nums.push_back(temp);
36 |         }
37 |         cout << canJump(nums) << endl;
38 |     }
39 |     return 0;
40 | }


--------------------------------------------------------------------------------
/Arrays/kids_with_greatest_no_of_candies.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<bool> kidsWithCandies(vector<int> &candies, int extraCandies)
 5 | {
 6 |     vector<bool> ans;
 7 |     int maxi = 0, n = candies.size();
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         maxi = max(candies[i], maxi);
11 |     }
12 |     for (int j = 0; j < n; j++)
13 |     {
14 |         if (candies[j] + extraCandies >= maxi)
15 |             ans.push_back(1);
16 |         else
17 |             ans.push_back(0);
18 |     }
19 |     return ans;
20 | }
21 | 
22 | int main()
23 | {
24 |     int t;
25 |     cin >> t;
26 |     while (t--)
27 |     {
28 |         int n, extraCandies;
29 |         cin >> n >> extraCandies;
30 |         vector<int> candies;
31 |         for (int i = 0; i < n; i++)
32 |         {
33 |             int temp;
34 |             cin >> temp;
35 |             candies.push_back(temp);
36 |         }
37 |         vector<bool> v = kidsWithCandies(candies, extraCandies);
38 |         for (auto i : v)
39 |             cout << i << " ";
40 |         cout << endl;
41 |     }
42 | }


--------------------------------------------------------------------------------
/Arrays/matrix_diagonal_sum.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int diagonalSum(vector<vector<int>> &mat)
 6 | {
 7 |     int sum = 0;
 8 |     int n = mat.size();
 9 |     for (int i = 0; i < n; i++)
10 |     {
11 |         sum += mat[i][i];
12 |     }
13 |     int j = n - 1;
14 |     for (int i = 0; i < n; i++)
15 |     {
16 |         sum += mat[j--][i];
17 |     }
18 |     if (n % 2)
19 |     {
20 |         sum -= mat[n / 2][n / 2];
21 |     }
22 | 
23 |     return sum;
24 | }
25 | 
26 | int main()
27 | {
28 |     int t;
29 |     cin >> t;
30 |     while (t--)
31 |     {
32 |         int r;
33 |         cin >> r;
34 |         vector<vector<int>> nums;
35 |         for (int i = 0; i < r; i++)
36 |         {
37 |             vector<int> v;
38 |             for (int j = 0; j < r; j++)
39 |             {
40 |                 int temp;
41 |                 cin >> temp;
42 |                 v.push_back(temp);
43 |             }
44 |             nums.push_back(v);
45 |         }
46 | 
47 |         cout << diagonalSum(nums) << endl;
48 |     }
49 | }


--------------------------------------------------------------------------------
/Arrays/matrix_transpose.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<vector<int>> transpose(vector<vector<int>> &matrix)
 5 | {
 6 |     if (matrix.size() == matrix[0].size())
 7 |     {
 8 |         for (int i = 0; i < matrix.size(); i++)
 9 |         {
10 |             for (int j = i; j < matrix[i].size(); j++)
11 |             {
12 |                 swap(matrix[i][j], matrix[j][i]);
13 |             }
14 |         }
15 |         return matrix;
16 |     }
17 |     vector<vector<int>> ans;
18 |     // int k=0;
19 |     for (int i = 0; i < matrix[0].size(); i++)
20 |     {
21 |         vector<int> v(matrix.size(), 0);
22 |         int k = 0;
23 |         for (int j = 0; j < matrix.size(); j++)
24 |         {
25 | 
26 |             v[j] = matrix[k++][i];
27 |         }
28 |         ans.push_back(v);
29 |     }
30 |     return ans;
31 | }
32 | 
33 | int main()
34 | {
35 |     int t;
36 |     cin >> t;
37 |     while (t--)
38 |     {
39 |         int n, m;
40 |         cin >> n >> m;
41 |         vector<vector<int>> nums;
42 |         for (int i = 0; i < n; i++)
43 |         {
44 |             vector<int> v;
45 |             for (int j = 0; j < m; j++)
46 |             {
47 |                 int temp;
48 |                 cin >> temp;
49 |                 v.push_back(temp);
50 |             }
51 |             nums.push_back(v);
52 |         }
53 |         nums = transpose(nums);
54 |         for (int i = 0; i < m; i++)
55 |         {
56 |             for (int j = 0; j < n; j++)
57 |                 cout << nums[i][j] << " ";
58 |             cout << endl;
59 |         }
60 |     }
61 | }


--------------------------------------------------------------------------------
/Arrays/maximum_population_year.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int maximumPopulation(vector<vector<int>> logs){
 5 |     vector<int> years(2051,0);
 6 |     for(int i=0; i<logs.size(); i++){
 7 |         years[logs[i][0]]++;
 8 |         years[logs[i][1]]--;
 9 |     }
10 |     for(int i=1950; i<2051; i++){
11 |         years[i]+=years[i-1];
12 |     }
13 |     int max_po = INT_MIN;
14 |     int ind;
15 |     for(int i=2051; i>=1950; i--){
16 |         if(years[i]>=max_po){
17 |             ind = i;
18 |             max_po = years[i];
19 |         }
20 |     }
21 |     return ind;
22 | }
23 | 
24 | int main()
25 | {
26 |     int t;
27 |     cin >> t;
28 |     while (t--)
29 |     {
30 |         int n;
31 |         cin >> n;
32 |         vector<vector<int>> nums;
33 |         for (int i = 0; i < n; i++)
34 |         {
35 |             int temp1, temp2;
36 |             cin >> temp1>>temp2;
37 |             nums.push_back({temp1, temp2});
38 |         }
39 |         cout<<maximumPopulation(nums)<<endl;
40 |     }
41 | }


--------------------------------------------------------------------------------
/Arrays/no_of_good_pairs.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int numIdenticalPairs(vector<int> &nums)
 5 | {
 6 |     int good_pairs = 0;
 7 |     int n = nums.size();
 8 |     for (int i = 0; i < n - 1; i++)
 9 |     {
10 |         for (int j = i + 1; j < n; j++)
11 |         {
12 |             if (nums[i] == nums[j])
13 |                 good_pairs++;
14 |         }
15 |     }
16 |     return good_pairs;
17 | }
18 | 
19 | int main()
20 | {
21 |     int t;
22 |     cin >> t;
23 |     while (t--)
24 |     {
25 |         int n;
26 |         cin >> n;
27 |         vector<int> nums;
28 |         for (int i = 0; i < n; i++)
29 |         {
30 |             int temp;
31 |             cin >> temp;
32 |             nums.push_back(temp);
33 |         }
34 |         cout<<numIdenticalPairs(nums)<<endl;
35 |     }
36 | }


--------------------------------------------------------------------------------
/Arrays/no_of_no_witth_even_no_of_digits.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int findNumbers(vector<int> &nums)
 5 | {
 6 |     int count = 0;
 7 |     for (int i = 0; i < nums.size(); i++)
 8 |     {
 9 |         if (nums[i] >= 10 && nums[i] <= 99)
10 |             count++;
11 |         else if (nums[i] >= 1000 && nums[i] <= 9999)
12 |             count++;
13 |         else if (nums[i] >= 100000 && nums[i] <= 999999)
14 |             count++;
15 |     }
16 |     return count;
17 | }
18 | 
19 | int main()
20 | {
21 |     int t;
22 |     cin >> t;
23 |     while (t--)
24 |     {
25 |         int n;
26 |         cin >> n;
27 |         vector<int> nums;
28 |         for (int i = 0; i < n; i++)
29 |         {
30 |             int temp;
31 |             cin >> temp;
32 |             nums.push_back(temp);
33 |         }
34 |         cout<<findNumbers(nums)<<endl;
35 |     }
36 | }


--------------------------------------------------------------------------------
/Arrays/no_smaller_than_curr_no.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> smallerNumbersThanCurrent(vector<int> &nums)
 5 | {
 6 |     vector<int> ans;
 7 |     for (int i = 0; i < nums.size(); i++)
 8 |     {
 9 |         int curr_sum = 0;
10 |         for (int j = 0; j < nums.size(); j++)
11 |         {
12 |             if (nums[j] < nums[i])
13 |             {
14 |                 curr_sum++;
15 |             }
16 |         }
17 |         ans.push_back(curr_sum);
18 |     }
19 |     return ans;
20 | }
21 | 
22 | int main()
23 | {
24 |     int t;
25 |     cin >> t;
26 |     while (t--)
27 |     {
28 |         int n;
29 |         cin >> n;
30 |         vector<int> nums;
31 |         for (int i = 0; i < n; i++)
32 |         {
33 |             int temp;
34 |             cin >> temp;
35 |             nums.push_back(temp);
36 |         }
37 |         vector<int> v = smallerNumbersThanCurrent(nums);
38 |         for (auto i : v)
39 |             cout << i << " ";
40 |         cout << endl;
41 |     }
42 | }


--------------------------------------------------------------------------------
/Arrays/pangram_String.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | bool checkIfPangram(string s) {
 5 |         
 6 |         set<char> st;
 7 |         for(int i=0; i<s.size(); i++)
 8 |             st.insert(s[i]);
 9 |         if(st.size()==26)
10 |             return 1;
11 |         return 0;
12 |     }
13 | 
14 | int  main(){
15 |     int t; cin>>t;
16 |     while(t--){
17 |         string s;
18 |         cin>>s;
19 |         cout<<checkIfPangram(s)<<endl;
20 |     }
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Arrays/product_of_array_except_self.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> productExceptSelf(vector<int> &nums)
 5 | {
 6 |     int n = nums.size();
 7 |     vector<int> fromBegin(n);
 8 |     fromBegin[0] = 1;
 9 |     vector<int> fromLast(n);
10 |     fromLast[0] = 1;
11 | 
12 |     for (int i = 1; i < n; i++)
13 |     {
14 |         fromBegin[i] = fromBegin[i - 1] * nums[i - 1];
15 |         fromLast[i] = fromLast[i - 1] * nums[n - i];
16 |     }
17 | 
18 |     vector<int> res(n);
19 |     for (int i = 0; i < n; i++)
20 |     {
21 |         res[i] = fromBegin[i] * fromLast[n - 1 - i];
22 |     }
23 |     return res;
24 | }
25 | 
26 | int main()
27 | {
28 |     int t;
29 |     cin >> t;
30 |     while (t--)
31 |     {
32 |         int n;
33 |         cin >> n;
34 |         vector<int> nums;
35 |         for (int i = 0; i < n; i++)
36 |         {
37 |             int temp;
38 |             cin >> temp;
39 |             nums.push_back(temp);
40 |         }
41 |         vector<int> v = productExceptSelf(nums);
42 |         for (auto i : v)
43 |             cout << i << " ";
44 |         cout << endl;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/Arrays/richest_customber_wealth.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int maximumWealth(vector<vector<int>> &accounts)
 5 | {
 6 |     int ans = INT_MIN;
 7 |     for (int i = 0; i < accounts.size(); i++)
 8 |     {
 9 |         int curr_sum = 0;
10 |         for (int j = 0; j < accounts[i].size(); j++)
11 |         {
12 |             curr_sum += accounts[i][j];
13 |         }
14 |         ans = max(ans, curr_sum);
15 |     }
16 |     return ans;
17 | }
18 | 
19 | int main()
20 | {
21 |     int t;
22 |     cin >> t;
23 |     while (t--)
24 |     {
25 |         int n, m;
26 |         cin >> n >> m;
27 |         vector<vector<int>> accounts;
28 |         for (int i = 0; i < n; i++)
29 |         {
30 |             vector<int> temp;
31 |             for (int j = 0; j < m; j++)
32 |             {
33 |                 int tp;
34 |                 cin >> tp;
35 |                 temp.push_back(tp);
36 |             }
37 |             accounts.push_back(temp);
38 |         }
39 |         cout<<maximumWealth(accounts)<<endl;
40 |     }
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/Arrays/rotate_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void rotate(vector<int> &nums, int k)
 5 | {
 6 |     k %= nums.size();
 7 |     if (k == 0)
 8 |         return;
 9 |     reverse(nums.begin(), nums.end());
10 |     reverse(nums.begin(), nums.begin() + k);
11 |     reverse(nums.begin() + k, nums.end());
12 | }
13 | 
14 | int main()
15 | {
16 |     int t;
17 |     cin >> t;
18 |     while (t--)
19 |     {
20 |         int n, k;
21 |         cin >> n >> k;
22 |         vector<int> nums;
23 |         for (int i = 0; i < n; i++)
24 |         {
25 |             int temp;
26 |             cin >> temp;
27 |             nums.push_back(temp);
28 |         }
29 |         rotate(nums, k);
30 |         for (auto i : nums)
31 |             cout << i << " ";
32 |         cout << endl;
33 |     }
34 |     return 0;
35 | }


--------------------------------------------------------------------------------
/Arrays/running_sum_of_1d_Array.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> runningSum(vector<int> &nums)
 5 | {
 6 |     vector<int> sum;
 7 |     sum.push_back(nums[0]);
 8 |     for (int i = 1; i < nums.size(); i++)
 9 |     {
10 |         sum.push_back(nums[i] + sum[i - 1]);
11 |     }
12 |     return sum;
13 | }
14 | 
15 | int main()
16 | {
17 |     int t;
18 |     cin >> t;
19 |     while (t--)
20 |     {
21 |         int n;
22 |         cin >> n;
23 |         vector<int> nums;
24 |         for (int i = 0; i < n; i++)
25 |         {
26 |             int temp;
27 |             cin >> temp;
28 |             nums.push_back(temp);
29 |         }
30 |         vector<int> v = runningSum(nums);
31 |         for (auto i : v)
32 |             cout << i << " ";
33 |         cout << endl;
34 |     }
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/Arrays/set_zeroes.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void setZeroes(vector<vector<int>> &matrix)
 5 | {
 6 |     int n = matrix.size(), m = matrix[0].size();
 7 |     for (int i = 0; i < n; i++)
 8 |     {
 9 |         for (int j = 0; j < m; j++)
10 |         {
11 |             if (matrix[i][j] == 0)
12 |             {
13 |                 // Set all the elements that are not zero as -9999
14 |                 for (int k = 0; k < m; k++)
15 |                 {
16 |                     if (matrix[i][k] != 0)
17 |                     {
18 |                         matrix[i][k] = -9999;
19 |                     }
20 |                 }
21 |                 break;
22 |             }
23 |         }
24 |     }
25 | 
26 |     // Traverse column wise
27 |     for (int j = 0; j < m; j++)
28 |     {
29 |         for (int i = 0; i < n; i++)
30 |         {
31 |             if (matrix[i][j] == 0)
32 |             {
33 |                 // Set all the elements that are not zero as -9999
34 |                 for (int k = 0; k < n; k++)
35 |                 {
36 |                     if (matrix[k][j] != 0)
37 |                     {
38 |                         matrix[k][j] = -9999;
39 |                     }
40 |                 }
41 |             }
42 |         }
43 |     }
44 | 
45 |     // Update all -9999 as 0
46 |     for (int i = 0; i < n; i++)
47 |     {
48 |         for (int j = 0; j < m; j++)
49 |         {
50 |             if (matrix[i][j] == -9999)
51 |             {
52 |                 matrix[i][j] = 0;
53 |             }
54 |         }
55 |     }
56 | }
57 | 
58 | int main()
59 | {
60 |     int n, m;
61 |     cin >> n >> m;
62 |     vector<vector<int>> v;
63 |     for (int i = 0; i < n; i++)
64 |     {
65 |         vector<int> x;
66 |         for (int j = 0; j < m; j++)
67 |         {
68 |             int temp;
69 |             cin >> temp;
70 |             x.push_back(temp);
71 |         }
72 |         v.push_back(x);
73 |     }
74 |     setZeroes(v);
75 |     for (int i = 0; i < n; i++)
76 |     {
77 |         for (int j = 0; j < m; j++)
78 |             cout << v[i][j] << " ";
79 |         cout << endl;
80 |     }
81 |     return 0;
82 | }


--------------------------------------------------------------------------------
/Arrays/shuffle_the_Array.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> shuffle(vector<int> &nums, int n)
 5 | {
 6 |     vector<int> ans;
 7 |     for (int i = 0; i < n; i++)
 8 |     {
 9 |         ans.push_back(nums[i]);
10 |         ans.push_back(nums[i + n]);
11 |     }
12 |     return ans;
13 | }
14 | 
15 | int main()
16 | {
17 |     int t;
18 |     cin >> t;
19 |     while (t--)
20 |     {
21 |         int n;
22 |         cin>>n;
23 |         vector<int> nums;
24 |         for(int i=0; i<2*n; i++){
25 |             int temp; cin>>temp;
26 |             nums.push_back(temp);
27 |         }
28 |         vector<int> v= shuffle(nums, n);
29 |         for(auto i:v){
30 |             cout<<i<<" ";
31 |         }
32 |         cout<<endl;
33 |     }
34 | }


--------------------------------------------------------------------------------
/Arrays/spiral_matrix.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> spiralOrder(vector<vector<int>> &mat)
 5 | {
 6 |     vector<int> arr;
 7 |     int n = mat.size(), m = mat[0].size(), dir = 1;
 8 |     int left = 0, right = mat[0].size() - 1, down = mat.size() - 1, up = 0, i;
 9 |     while (arr.size() != m * n)
10 |     {
11 |         if (dir == 1)
12 |         {
13 |             for (i = left; i <= right; i++)
14 |             {
15 |                 arr.push_back(mat[left][i]);
16 |             }
17 |             left++;
18 |             dir = 2;
19 |         }
20 |         else if (dir == 2)
21 |         {
22 |             for (i = up + 1; i <= down; i++)
23 |             {
24 |                 arr.push_back(mat[i][right]);
25 |             }
26 |             right--;
27 |             dir = 3;
28 |         }
29 |         else if (dir == 3)
30 |         {
31 |             for (i = right; i >= up; i--)
32 |             {
33 |                 arr.push_back(mat[down][i]);
34 |             }
35 |             down--;
36 |             dir = 4;
37 |         }
38 |         else if (dir == 4)
39 |         {
40 |             for (i = down; i >= left; i--)
41 |             {
42 |                 arr.push_back(mat[i][up]);
43 |             }
44 |             dir = 1;
45 |             up++;
46 |         }
47 |     }
48 |     return arr;
49 | }
50 | 
51 | int main()
52 | {
53 |     int t;
54 |     cin >> t;
55 |     while (t--)
56 |     {
57 |         int n, m;
58 |         cin >> n >> m;
59 |         vector<vector<int>> nums;
60 |         for (int i = 0; i < n; i++)
61 |         {
62 |             vector<int> v;
63 |             for (int j = 0; j < m; j++)
64 |             {
65 |                 int temp;
66 |                 cin >> temp;
67 |                 v.push_back(temp);
68 |             }
69 |             nums.push_back(v);
70 |         }
71 |         vector<int> v;
72 | 
73 |         v = spiralOrder(nums);
74 |         for (auto i : v)
75 |             cout << i << " ";
76 |         cout << endl;
77 |     }
78 | }


--------------------------------------------------------------------------------
/Arrays/two_sum.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> twoSum(vector<int> &nums, int x)
 5 | {
 6 |     vector<int> ans;
 7 |     for (int i = 0; i < nums.size(); i++)
 8 |     {
 9 |         for (int j = 0; j < nums.size(); j++)
10 |         {
11 |             if (nums[i] + nums[j] == x && i != j)
12 |             {
13 |                 ans.push_back(i);
14 |                 ans.push_back(j);
15 |                 return ans;
16 |             }
17 |         }
18 |     }
19 |     return ans;
20 | }
21 | 
22 | int main()
23 | {
24 |     int t;
25 |     cin >> t;
26 |     while (t--)
27 |     {
28 |         int n, k;
29 |         cin >> n >> k;
30 |         vector<int> nums;
31 |         for (int i = 0; i < n; i++)
32 |         {
33 |             int temp;
34 |             cin >> temp;
35 |             nums.push_back(temp);
36 |         }
37 |         vector<int> v = twoSum(nums, k);
38 |         for (auto i : v)
39 |             cout << i << " ";
40 |         cout << endl;
41 |     }
42 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # DSA based questions for interviews
 2 | ## All questions are the most rated questions on Leetcode provided by Kunal Kushwaha and are hereby provided along with solution along with the solution.
 3 | 
 4 | 
 5 | | S.No. | Topic                      | Status|
 6 | |-------|----------------------------|-------|
 7 | | 01.   | [Array](/Arrays)           | 28/28 |
 8 | | 02.   | [Searching](/Searching)    | 21/38 |
 9 | | 03.   | [Sorting](/Sorting)        | 07/38 |
10 | | 04.   | [Strings](/String)         | 08/29 |
11 | 


--------------------------------------------------------------------------------
/Searching/README.md:
--------------------------------------------------------------------------------
 1 | # Problems:
 2 | 
 3 | ## Easy
 4 | |S.no.|Question|Solution|
 5 | |---|------------|------------|
 6 | |1|[Square Root](https://leetcode.com/problems/sqrtx/)|[Solution](sqrt.cpp)|
 7 | |2| [First Bad Version](https://leetcode.com/problems/first-bad-version/)|[Solution](first_bad_version.cpp)|
 8 | |3| [Two Sum II - Input array is sorted](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/)|[Solution](two_sum_ii_input_array_is_sorted.cpp)|
 9 | |4| [Valid Perfect Square](https://leetcode.com/problems/valid-perfect-square/)|[Solution](valid_perfect_square.cpp)|
10 | |5| [Arranging Coins(Easy)](https://leetcode.com/problems/arranging-coins/)|[Solution](arranging_coin.cpp)|
11 | |6| [Find Smallest Letter Greater Than Target](https://leetcode.com/problems/find-smallest-letter-greater-than-target/)|[Solution](smallest_letter_greater_than_target.cpp)|
12 | |7| [Kth Missing Positive Number](https://leetcode.com/problems/kth-missing-positive-number/)|[Solution](kth_missing_positive_no.cpp)|
13 | |8| [Search Insert Position](https://leetcode.com/problems/search-insert-position/)|[Solution](search_insert_position.cpp)|
14 | |9| [Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/)|[Solution](peak_in_mountain.cpp)|
15 | |10| [Count Negative Numbers in a Sorted Matrix](https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/)|[Solution](count_negatives.cpp)|
16 | |11| [Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/)|[Solution](intersection_of_two_arrays_i.cpp)|
17 | |12| [Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/)|[Solution](intersection_of_two_arrays_ii.cpp)|
18 | |13| [Fair Candy Swap](https://leetcode.com/problems/fair-candy-swap/)|[Solution](fair_candy_swap.cpp)|
19 | |14| [Check If N and Its Double Exist](https://leetcode.com/problems/check-if-n-and-its-double-exist/)|[Solution](check_if_n_and_its_double_exist.cpp)|
20 | |15| [Special Array With X Elements Greater Than or Equal X](https://leetcode.com/problems/special-array-with-x-elements-greater-than-or-equal-x/)|[Solution](special_array_with_x_elements_greater_than_or_equal_x.cpp)|
21 | |16| [Binary Search](https://leetcode.com/problems/binary-search/)|[Solution](binary_search.cpp)|
22 | |17| [Guess Number Higher or Lower](https://leetcode.com/problems/guess-number-higher-or-lower/)|[Solution](guess_no_higher_lower.cpp)|
23 | 
24 | 
25 | ## Medium
26 | |S.no.|Question|Solution|
27 | |---|------------|------------|
28 | |1| [Find First and Last Position of Element in Sorted Array](https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/)|[Solution](find_first_and_last_position_of_element_in_sorted_array.cpp)|
29 | |2| [Single Element in a Sorted Array](https://leetcode.com/problems/single-element-in-a-sorted-array/)|[Solution](single_element_in_sorted_array.cpp)|
30 | |3| [Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array/)|[Solution](search_in_rotated_array.cpp)|
31 | |4| [Search in Rotated Sorted Array II](https://leetcode.com/problems/search-in-rotated-sorted-array-ii/)|[Solution](search_in_rotated_array_ii.cpp)|
32 | |5| [Find Minimum in Rotated Sorted Array](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/)|[Solution](min_in_rotated_arr.cpp)|
33 | |6| [Find Peak Element](https://leetcode.com/problems/find-peak-element/)|[Solution](peak_ele.cpp)|
34 | |7| [Find Right Interval](https://leetcode.com/problems/find-right-interval/)|Pending|
35 | |8| [Reach a Number](https://leetcode.com/problems/reach-a-number/)|Pending|
36 | |9| [Maximum Value at a Given Index in a Bounded Array](https://leetcode.com/problems/maximum-value-at-a-given-index-in-a-bounded-array/)|Pending|
37 | |10| [Koko Eating Bananas](https://leetcode.com/problems/koko-eating-bananas/)|Pending|
38 | |11| [Minimum Absolute Sum Difference](https://leetcode.com/problems/minimum-absolute-sum-difference/)|Pending|
39 | |12| [Search a 2D Matrix](https://leetcode.com/problems/search-a-2d-matrix/)|Pending|
40 | |13| [Find a Peak Element II](https://leetcode.com/problems/find-a-peak-element-ii/)|Pending|
41 | |14| [Frequency of the Most Frequent Element](https://leetcode.com/problems/frequency-of-the-most-frequent-element/)|Pending|
42 | |15| [Find the Duplicate Number](https://leetcode.com/problems/find-the-duplicate-number/)|Pending|
43 | 
44 | ## Hard
45 | |S.no.|Question|Solution|
46 | |---|------------|------------|
47 | |1| [Median of Two Sorted Arrays](https://leetcode.com/problems/median-of-two-sorted-arrays/)|Pending|
48 | |2| [Find Minimum in Rotated Sorted Array II](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/)|Pending|
49 | |3| [Aggressive cows](https://www.spoj.com/problems/AGGRCOW/)|Pending|
50 | |4| [Book allocation](https://www.geeksforgeeks.org/allocate-minimum-number-pages/)|Pending|
51 | |5| [Split Array Largest Sum](https://leetcode.com/problems/split-array-largest-sum/)|Pending|
52 | |6| [Find in Mountain Array](https://leetcode.com/problems/find-in-mountain-array/)|Pending|
53 | |7| [Count smaller number after Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/)|Pending|


--------------------------------------------------------------------------------
/Searching/arranging_coin.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int arrangeCoins(int n)
 5 | {
 6 |     for (long long i = 0; i < n; i++)
 7 |     {
 8 |         if (i * (i + 1) / 2 == n)
 9 |             return i;
10 |         if (i * (i + 1) / 2 > n)
11 |             return i - 1;
12 |     }
13 |     return 1;
14 | }
15 | 
16 | int main()
17 | {
18 |     int n;
19 |     cin >> n;
20 |     cout << arrangeCoins(n) << endl;
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Searching/binary_search.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int search(vector<int> &nums, int target)
 5 | {
 6 |     int low = 0, high = nums.size() - 1;
 7 |     while (low <= high)
 8 |     {
 9 |         int mid = (high - low) / 2 + low;
10 |         if (nums[mid] == target)
11 |             return mid;
12 |         else if (nums[mid] > target)
13 |             high = mid - 1;
14 |         else
15 |             low = mid + 1;
16 |     }
17 |     return -1;
18 | }
19 | 
20 | int main()
21 | {
22 |     int n, target;
23 |     cin >> n >> target;
24 |     vector<int> v;
25 | 
26 |     for (int i = 0; i < n; i++)
27 |     {
28 |         int temp;
29 |         cin >> temp;
30 |         v.push_back(temp);
31 |     }
32 |     cout << search(v, target) << endl;
33 | }
34 | 


--------------------------------------------------------------------------------
/Searching/check_if_n_and_its_double_exist.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | bool checkIfExist(vector<int> &arr)
 5 | {
 6 |     unordered_map<int, int> map;
 7 |     for (int i = 0; i < arr.size(); i++)
 8 |     {
 9 |         map[arr[i]]++;
10 |         if (arr[i] == 0 && map[arr[i]] == 1)
11 |             continue;
12 |         if (map.count(2 * arr[i]) > 0 || ((arr[i] % 2 == 0) && map.count(arr[i] / 2) > 0))
13 |             return true;
14 |     }
15 |     return false;
16 | }
17 | 
18 | int main()
19 | {
20 |     int n;
21 |     cin >> n;
22 |     vector<int> v;
23 |     for (int i = 0; i < n; i++)
24 |     {
25 |         int temp;
26 |         cin >> temp;
27 |         v.push_back(temp);
28 |     }
29 |     cout << checkIfExist(v) << endl;
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/Searching/count_negatives.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int countNegatives(vector<vector<int>> &grid)
 5 | {
 6 |     int count = 0;
 7 |     for (int i = grid[0].size() - 1; i >= 0; i--)
 8 |     {
 9 |         for (int j = grid.size() - 1; j >= 0; j--)
10 |         {
11 |             if (grid[j][i] < 0)
12 |                 count++;
13 |             else
14 |                 break;
15 |         }
16 |     }
17 |     return count;
18 | }
19 | 
20 | int main()
21 | {
22 |     int n, m;
23 |     cin >> n >> m;
24 |     vector<vector<int>> v;
25 |     for (int i = 0; i < n; i++)
26 |     {
27 |         vector<int> temp;
28 |         for (int j = 0; j < m; j++)
29 |         {
30 |             int x;
31 |             cin >> x;
32 |             temp.push_back(x);
33 |         }
34 |         v.push_back(temp);
35 |     }
36 |     cout << countNegatives(v) << endl;
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/Searching/fair_candy_swap.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> fairCandySwap(vector<int> &A, vector<int> &B)
 5 | {
 6 |     // Note that the problem statement says that Alice and Bob need to exchange one candy each, no more or no less.
 7 |     // Assume x needs to be removed and y needs to be added to A to equalize, so:
 8 |     //  Sum(A) - x + y = Sum(B) - y + x
 9 |     //  therefore, Sum(A) - Sum(B) = -2y + 2x
10 |     //  therefore, x = ((Sum(A) - Sum(B)) / 2) + y
11 |     //  lets call ((Sum(A) - Sum(B)) / 2), delta
12 | 
13 |     int sumA = 0;
14 |     int sumB = 0;
15 | 
16 |     for (auto e : A)
17 |         sumA += e;
18 | 
19 |     for (auto e : B)
20 |         sumB += e;
21 | 
22 |     int delta = (sumA - sumB) / 2;
23 | 
24 |     unordered_set<int> searchA;
25 |     for (auto x : A)
26 |         searchA.insert(x);
27 | 
28 |     for (auto y : B)
29 |     {
30 |         if (searchA.count(delta + y) > 0)
31 |         {
32 |             return vector<int>{delta + y, y};
33 |         }
34 |     }
35 | 
36 |     return {};
37 | }
38 | 
39 | int main()
40 | {
41 |     int n, m;
42 |     cin >> n >> m;
43 |     vector<int> x, y;
44 |     for (int i = 0; i < n; i++)
45 |     {
46 |         int temp;
47 |         cin >> temp;
48 |         x.push_back(temp);
49 |     }
50 |     for (int i = 0; i < m; i++)
51 |     {
52 |         int temp;
53 |         cin >> temp;
54 |         y.push_back(temp);
55 |     }
56 |     vector<int> ans = fairCandySwap(x, y);
57 |     for (auto i : ans)
58 |         cout << i << " ";
59 |     cout << endl;
60 | }


--------------------------------------------------------------------------------
/Searching/find_first_and_last_position_of_element_in_sorted_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> searchRange(vector<int> &nums, int target)
 5 | {
 6 |     int start = 0, end = nums.size(), mid, left, right;
 7 |     while (start < end)
 8 |     {
 9 |         mid = (start + end) / 2;
10 |         if (nums[mid] >= target)
11 |             end = mid;
12 |         else
13 |             start = mid + 1;
14 |     }
15 |     left = start;
16 |     start = 0, end = nums.size();
17 |     while (start < end)
18 |     {
19 |         mid = (start + end) / 2;
20 |         if (nums[mid] > target)
21 |             end = mid;
22 |         else
23 |             start = mid + 1;
24 |     }
25 |     right = start;
26 |     return left == right ? vector<int>{-1, -1} : vector<int>{left, right - 1};
27 | }
28 | 
29 | int main()
30 | {
31 |     int n, target;
32 |     cin >> n >> target;
33 |     vector<int> v;
34 |     for (int i = 0; i < n; i++)
35 |     {
36 |         int temp;
37 |         cin >> temp;
38 |         v.push_back(temp);
39 |     }
40 |     vector<int> ans = searchRange(v, target);
41 |     cout<<ans[0]<<" "<<ans[1]<<endl;
42 |     return 0;
43 | }


--------------------------------------------------------------------------------
/Searching/first_bad_version.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<bool> check;
 5 | 
 6 | bool isBadVersion(int n){
 7 |     return check[n];
 8 | }
 9 | 
10 | int firstBadVersion(int n)
11 | {
12 |     int low = 0, high = n;
13 |     while (low <= high)
14 |     {
15 |         int mid = low + (high - low) / 2;
16 |         if (!isBadVersion(mid))
17 |         {
18 |             if (!isBadVersion(mid + 1))
19 |                 low = mid + 1;
20 |             else
21 |                 return mid + 1;
22 |         }
23 |         else
24 |             high = mid - 1;
25 |     }
26 |     return -1;
27 | }
28 | 
29 | int main(){
30 |     int n, x;
31 |     cin>>n>>x;
32 |     for(int i=0; i<n; i++){
33 |         if(i<x) check.push_back(0);
34 |         else check.push_back(1);
35 |     }
36 | 
37 |     cout << firstBadVersion(n)<<endl;
38 |     return 0;
39 | }


--------------------------------------------------------------------------------
/Searching/guess_no_higher_lower.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | // api call will be different
 5 | int guess(int n)
 6 | {
 7 |     if (n > 6)
 8 |         return -1;
 9 |     else if (n == 6)
10 |         return 0;
11 |     else
12 |         return 1;
13 | }
14 | 
15 | int guessNumber(int n)
16 | {
17 |     int maxNumber = n, minNumber = 1;
18 |     while (minNumber<=maxNumber)
19 |     {
20 |         int meanNumber = (maxNumber - minNumber) / 2 + minNumber;
21 |         int res = guess(meanNumber);
22 |         if (res == 0)
23 |             return meanNumber;
24 |         else if (res == 1)
25 |             minNumber = meanNumber + 1;
26 |         else
27 |             maxNumber = meanNumber - 1;
28 |     }
29 |     return -1;
30 | }
31 | 
32 | int main()
33 | {
34 |     int n;
35 |     cin >> n;
36 |     cout<<guessNumber(n)<<endl;
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/Searching/intersection_of_two_arrays_i.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> intersection(vector<int> &nums1, vector<int> &nums2)
 5 | {
 6 |     sort(nums1.begin(), nums1.end());
 7 |     sort(nums2.begin(), nums2.end());
 8 |     int n = nums1.size(), m = nums2.size();
 9 |     vector<int> ans;
10 |     int i = 0, j = 0;
11 |     while (i < n && j < m)
12 |     {
13 |         if (nums1[i] == nums2[j])
14 |         {
15 |             if (ans.empty())
16 |                 ans.push_back(nums1[i]);
17 |             else if (!ans.empty() && ans[ans.size() - 1] != nums1[i])
18 |                 ans.push_back(nums1[i]);
19 |             i++;
20 |             j++;
21 |         }
22 |         else if (nums1[i] > nums2[j])
23 |             j++;
24 |         else
25 |             i++;
26 |     }
27 |     return ans;
28 | }
29 | 
30 | int main()
31 | {
32 |     int t;
33 |     cin >> t;
34 |     while (t--)
35 |     {
36 |         int n, m;
37 |         cin >> m >> n;
38 |         vector<int> nums1;
39 |         vector<int> nums2;
40 |         for (int i = 0; i < m; i++)
41 |         {
42 |             int temp;
43 |             cin >> temp;
44 |             nums1.push_back(temp);
45 |         }
46 |         for (int i = 0; i < n; i++)
47 |         {
48 |             int temp;
49 |             cin >> temp;
50 |             nums2.push_back(temp);
51 |         }
52 |         vector<int> ans = intersection(nums1, nums2);
53 |         for (auto i : ans)
54 |             cout << i << " ";
55 |         cout << endl;
56 |     }
57 |     return 0;
58 | }


--------------------------------------------------------------------------------
/Searching/intersection_of_two_arrays_ii.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> intersect(vector<int> &nums1, vector<int> &nums2)
 5 | {
 6 |     vector<int> ans;
 7 |     sort(nums1.begin(), nums1.end());
 8 |     sort(nums2.begin(), nums2.end());
 9 |     int i = 0, j = 0;
10 |     while (i < nums1.size() && j < nums2.size())
11 |     {
12 |         if (nums1[i] == nums2[j])
13 |         {
14 |             ans.push_back(nums1[i]);
15 |             i++;
16 |             j++;
17 |         }
18 |         else if (nums1[i] > nums2[j])
19 |             j++;
20 |         else
21 |             i++;
22 |     }
23 |     return ans;
24 | }
25 | 
26 | int main()
27 | {
28 |     int t;
29 |     cin >> t;
30 |     while (t--)
31 |     {
32 |         int n, m;
33 |         cin >> m >> n;
34 |         vector<int> nums1;
35 |         vector<int> nums2;
36 |         for (int i = 0; i < m; i++)
37 |         {
38 |             int temp;
39 |             cin >> temp;
40 |             nums1.push_back(temp);
41 |         }
42 |         for (int i = 0; i < n; i++)
43 |         {
44 |             int temp;
45 |             cin >> temp;
46 |             nums2.push_back(temp);
47 |         }
48 |         vector<int> ans = intersect(nums1, nums2);
49 |         for (auto i : ans)
50 |             cout << i << " ";
51 |         cout << endl;
52 |     }
53 |     return 0;
54 | }


--------------------------------------------------------------------------------
/Searching/kth_missing_positive_no.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int findKthPositive(vector<int> &A, int k)
 5 | {
 6 |     int l = 0, r = A.size(), m;
 7 |     while (l < r)
 8 |     {
 9 |         m = (l + r) / 2;
10 |         if (A[m] - 1 - m < k)
11 |             l = m + 1;
12 |         else
13 |             r = m;
14 |     }
15 |     return l + k;
16 | }
17 | 
18 | int main()
19 | {
20 |     int t;
21 |     cin >> t;
22 |     while (t--)
23 |     {
24 |         int n, target;
25 |         cin >> n >> target;
26 |         vector<int> v;
27 |         for (int i = 0; i < n; i++)
28 |         {
29 |             int temp;
30 |             cin >> temp;
31 |             v.push_back(temp);
32 |         }
33 |         cout << findKthPositive(v, target) << endl;
34 |     }
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/Searching/min_in_rotated_arr.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int findMin(vector<int> &num)
 5 | {
 6 |     if (num.empty())
 7 |         return 0;
 8 |     int low = 0;
 9 |     int high = num.size() - 1;
10 |     int mid;
11 | 
12 |     while (low < high)
13 |     {
14 |         mid = (low + high) / 2;
15 |         if (num[low] > num[mid])
16 |         {
17 |             low++;
18 |             high = mid;
19 |         }
20 |         else if (num[mid] > num[high])
21 |         {
22 |             low = ++mid;
23 |         }
24 |         else
25 |             high = mid;
26 |     }
27 | 
28 |     return num[low];
29 | }
30 | 
31 | int main()
32 | {
33 |     int n, target;
34 |     cin >> n;
35 |     vector<int> v;
36 |     for (int i = 0; i < n; i++)
37 |     {
38 |         int temp;
39 |         cin >> temp;
40 |         v.push_back(temp);
41 |     }
42 |     cout << findMin(v) << endl;
43 |     return 0;
44 | }


--------------------------------------------------------------------------------
/Searching/peak_ele.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int findPeakElement(vector<int> &num)
 5 | {
 6 |     int low = 0, high = num.size() - 1;
 7 |     while (low < high - 1)
 8 |     {
 9 |         int mid = (low + high) / 2;
10 |         if (num[mid] > num[mid - 1] && num[mid] > num[mid + 1])
11 |             return mid;
12 |         else if (num[mid] > num[mid + 1])
13 |             high = mid - 1;
14 |         else
15 |             low = mid + 1;
16 |     }
17 |     return num[low] > num[high] ? low : high;
18 | }
19 | 
20 | int main()
21 | {
22 |     int n, target;
23 |     cin >> n;
24 |     vector<int> v;
25 |     for (int i = 0; i < n; i++)
26 |     {
27 |         int temp;
28 |         cin >> temp;
29 |         v.push_back(temp);
30 |     }
31 |     cout << findPeakElement(v) << endl;
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/Searching/peak_in_mountain_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int peakIndexInMountainArray(vector<int> &arr)
 5 | {
 6 |     // linear search
 7 |     // for(int i=0; i<arr.size()-1; i++){
 8 |     //     if(arr[i]>arr[i+1]) return i;
 9 |     // }
10 |     // return arr.size()-1;
11 | 
12 |     // binary search
13 |     int l = 0, r = arr.size() - 1, mid;
14 |     while (l < r)
15 |     {
16 |         mid = (l + r) / 2;
17 |         if (arr[mid] < arr[mid + 1])
18 |             l = mid + 1;
19 |         else
20 |             r = mid;
21 |     }
22 |     return l;
23 | }
24 | 
25 | int main()
26 | {
27 |     int n;
28 |     cin >> n;
29 |     vector<int> v;
30 |     for (int i = 0; i < n; i++)
31 |     {
32 |         int temp;
33 |         cin >> temp;
34 |         v.push_back(temp);
35 |     }
36 |     cout<<peakIndexInMountainArray(v)<<endl;
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/Searching/search_in_rotated_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int search(vector<int> &nums, int target)
 5 | {
 6 |     int r = nums.size() - 1;
 7 |     int l = 0;
 8 |     while (l <= r)
 9 |     {
10 |         int m = l + (r - l) / 2;
11 |         if (nums[m] == target)
12 |             return m;
13 |         else if (nums[l] <= nums[m])
14 |         {
15 |             if (target >= nums[l] && target <= nums[m])
16 |             {
17 |                 r = m - 1;
18 |             }
19 |             else
20 |                 l = m + 1;
21 |         }
22 |         else
23 |         {
24 |             if (target >= nums[m] && target <= nums[r])
25 |             {
26 |                 l = m + 1;
27 |             }
28 |             else
29 |                 r = m - 1;
30 |         }
31 |     }
32 |     return -1;
33 | }
34 | 
35 | int main()
36 | {
37 |     int n, tar;
38 |     cin >> n >> tar;
39 |     vector<int> v;
40 |     for (int i = 0; i < n; i++)
41 |     {
42 |         int temp;
43 |         cin >> temp;
44 |         v.push_back(temp);
45 |     }
46 |     cout << search(v, tar) << endl;
47 |     return 0;
48 | }


--------------------------------------------------------------------------------
/Searching/search_in_rotated_array_ii.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | bool search(vector<int> &nums, int target)
 5 | {
 6 |     int start = 0;
 7 |     int end = nums.size() - 1;
 8 |     int mid;
 9 |     while (start <= end)
10 |     {
11 |         mid = (start + end) / 2;
12 |         if (nums[mid] == target)
13 |         {
14 |             return true;
15 |         }
16 |         if (nums[start] == nums[mid])
17 |         {
18 |             start++;
19 |             continue;
20 |         }
21 |         if (nums[end] == nums[mid])
22 |         {
23 |             end--;
24 |             continue;
25 |         }
26 | 
27 |         if (nums[start] < nums[mid]) //left array is sorted
28 |         {
29 |             if (nums[start] <= target && target < nums[mid])
30 |             {
31 |                 end = mid - 1;
32 |             }
33 |             else
34 |             {
35 |                 start = mid + 1;
36 |             }
37 |         }
38 |         else if (nums[mid] < nums[end]) //right array is sorted
39 |         {
40 |             if (nums[end] >= target && target > nums[mid])
41 |             {
42 |                 start = mid + 1;
43 |             }
44 |             else
45 |             {
46 |                 end = mid - 1;
47 |             }
48 |         }
49 |     }
50 |     return false;
51 | }
52 | 
53 | int main()
54 | {
55 |     int n, tar;
56 |     cin >> n >> tar;
57 |     vector<int> v;
58 |     for (int i = 0; i < n; i++)
59 |     {
60 |         int temp;
61 |         cin >> temp;
62 |         v.push_back(temp);
63 |     }
64 |     cout << search(v, tar) << endl;
65 |     return 0;
66 | }


--------------------------------------------------------------------------------
/Searching/search_insert_position.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int searchInsert(vector<int> nums, int target)
 5 | {
 6 |     int low = 0, high = nums.size() - 1;
 7 | 
 8 |     while (low <= high)
 9 |     {
10 |         int mid = low + (high - low) / 2;
11 | 
12 |         if (nums[mid] < target)
13 |             low = mid + 1;
14 |         else
15 |             high = mid - 1;
16 |     }
17 | 
18 |     return high + 1;
19 | }
20 | 
21 | int main()
22 | {
23 |     int n;
24 |     cin >> n;
25 |     vector<int> v;
26 |     for (int i = 0; i < n; i++)
27 |     {
28 |         int temp;
29 |         cin >> temp;
30 |         v.push_back(temp);
31 |     }
32 |     int target;
33 |     cin>>target;
34 |     cout<<searchInsert(v, target);
35 | }


--------------------------------------------------------------------------------
/Searching/single_element_in_sorted_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int singleNonDuplicate(vector<int>& nums) {
 5 |         if(nums.size()==1) return nums[0];
 6 |         int low =0, high =nums.size()-1;
 7 |         if(nums[0]!=nums[1]) return nums[0];
 8 |         if(nums[nums.size()-1]!=nums[nums.size()-2]) return nums[nums.size()-1];
 9 |         while(low<=high){
10 |             int mid = (low+high)/2;
11 |             if(nums[mid-1]==nums[mid]){
12 |                 if(mid%2==0){
13 |                     high = mid-2;
14 |                 }
15 |                 else 
16 |                     low=mid+1;
17 |             }
18 |             else if(nums[mid+1]==nums[mid]){
19 |                 if((mid+1)%2)
20 |                     low=mid+2;
21 |                 else 
22 |                     high= mid-1;
23 |             }
24 |             else return nums[mid];
25 |                 
26 |         }
27 |         return -1;
28 |     }
29 | 
30 | int main()
31 | {
32 |     int n, target;
33 |     cin >> n;
34 |     vector<int> v;
35 |     for (int i = 0; i < n; i++)
36 |     {
37 |         int temp;
38 |         cin >> temp;
39 |         v.push_back(temp);
40 |     }
41 |     cout<<singleNonDuplicate(v)<<endl;
42 |     return 0;
43 | }


--------------------------------------------------------------------------------
/Searching/smallest_letter_greater_than_target.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | char nextGreatestLetter(vector<char> &letters, char target)
 5 | {
 6 |     if (letters.back() <= target)
 7 |         return letters.front();
 8 |     int low = 0, high = letters.size() - 1;
 9 |     while (low < high)
10 |     {
11 |         auto mid = (low + high) / 2;
12 |         if (target < letters[mid])
13 |             high = mid;
14 |         else
15 |             low = mid + 1;
16 |     }
17 |     return letters[low];
18 | }
19 | 
20 | int main()
21 | {
22 |     int t;
23 |     cin>>t;
24 |     while(t--){
25 |         int n;
26 |         cin>>n;
27 |         char target;
28 |         cin>>target;
29 |         vector<char> v;
30 |         for(int i=0; i<n; i++){
31 |             char temp;
32 |             cin>>temp;
33 |             v.push_back(temp);
34 |         }
35 |         cout<<nextGreatestLetter(v, target)<<endl;
36 |     }
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/Searching/special_array_with_x_elements_greater_than_or_equal_x.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int specialArray(vector<int> &nums)
 5 | {
 6 |     // with complexity O(n log(n))
 7 |     //      sort(nums.begin(), nums.end());  // O(NlogN)
 8 |     // const int N = nums.size();
 9 |     // if (nums[0] >= N) return N;
10 |     // int l = 1, r = N - 1;
11 |     // while (l <= r) { // O(LogN) * O(1)
12 |     //     int m = l + (r - l) / 2;
13 |     //     if (nums[m] >= (N - m) && nums[m - 1] < (N - m)) return (N - m);
14 |     //     else if (nums[m] >= (N - m)) r = m - 1;
15 |     //     else l = m + 1;
16 |     // }
17 |     // return -1;
18 | 
19 |     // counting sort
20 |     int count[102] = {0}, N = nums.size();
21 |     for (int n : nums)
22 |         count[min(n, N)]++;
23 |     for (int i = N; i >= 0; i--)
24 |     {
25 |         count[i] = count[i + 1] + count[i];
26 |         if (count[i] == i)
27 |             return i;
28 |     }
29 |     return -1;
30 | }
31 | 
32 | int main()
33 | {
34 |     int n;
35 |     cin>>n;
36 |     vector<int> v;
37 |     for(int i=0; i<n; i++){
38 |         int temp; cin>>temp;
39 |         v.push_back(temp);
40 |     }
41 |     cout<<specialArray(v)<<endl;
42 |     return 0;
43 | }


--------------------------------------------------------------------------------
/Searching/sqrt.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int mySqrt(int x)
 5 | {
 6 |     int low = 0, high = x;
 7 |     long mid;
 8 |     while (low <= high)
 9 |     {
10 |         mid = low + (high - low) / 2;
11 |         if (mid * mid <= x)
12 |             low = mid + 1;
13 |         else
14 |             high = mid - 1;
15 |     }
16 |     return low - 1;
17 | }
18 | 
19 | int main()
20 | {
21 |     int t;
22 |     cin >> t;
23 |     while (t--)
24 |     {
25 |         int n;
26 |         cin >> n;
27 |         cout<<mySqrt(n)<<endl;
28 |     }
29 |     return 0;
30 | }


--------------------------------------------------------------------------------
/Searching/two_sum_ii_input_array_is_sorted.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int binary_search(vector<int> arr, int n, int target, int i)
 5 | {
 6 |     int low = 0, high = n - 1;
 7 |     while (low <= high)
 8 |     {
 9 |         int mid = low + (high - low) / 2;
10 |         if (arr[mid] == target)
11 |         {
12 |             if (mid != i)
13 |                 return mid;
14 |             else if (arr[mid - 1] == target)
15 |                 return mid - 1;
16 |             else
17 |                 return mid + 1;
18 |         }
19 |         else if (arr[mid] > target)
20 |             high = mid - 1;
21 |         else
22 |             low = mid + 1;
23 |     }
24 |     return -1;
25 | }
26 | 
27 | vector<int> twoSum(vector<int> &num, int target)
28 | {
29 |     int n = num.size();
30 |     for (int i = 0; i < n; i++)
31 |     {
32 |         int temp = binary_search(num, n, target - num[i], i);
33 |         if (temp != -1)
34 |             return {i + 1, temp + 1};
35 |     }
36 |     return {-1, -1};
37 | }
38 | 
39 | int main()
40 | {
41 |     int t;
42 |     cin >> t;
43 |     while (t--)
44 |     {
45 |         int n, target;
46 |         cin >> n >> target;
47 |         vector<int> v;
48 |         for (int i = 0; i < n; i++)
49 |         {
50 |             int temp;
51 |             cin >> temp;
52 |             v.push_back(temp);
53 |         }
54 |         vector<int> ans = twoSum(v, target);
55 |         cout << ans[0] << " " << ans[1] << endl;
56 |     }
57 |     return 0;
58 | }


--------------------------------------------------------------------------------
/Searching/valid_perfect_square.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | bool isPerfectSquare(int num)
 5 | {
 6 |     int low = 1, high = num;
 7 |     while (low <= high)
 8 |     {
 9 |         long long mid = low + (high - low) / 2;
10 |         if ((mid * mid) == num)
11 |             return 1;
12 |         else if (mid * mid > num)
13 |             high = mid - 1;
14 |         else
15 |             low = mid + 1;
16 |     }
17 |     return 0;
18 | }
19 | 
20 | int main(){
21 |     int t;
22 |     cin>>t;
23 |     while(t--){
24 |         int n;
25 |         cin>>n;
26 |         cout<<isPerfectSquare(n)<<endl;
27 |     }
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/Sorting/README.md:
--------------------------------------------------------------------------------
 1 | # Questions
 2 | 
 3 | ## Easy
 4 | |S.no.|Question|Solution|
 5 | |---|------------|------------|
 6 | |01.|[Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/)|[Solution](merge_sorted_array.cpp)|
 7 | |02.| [Majority Element](https://leetcode.com/problems/majority-element/)|[Solution](majority_ele.cpp)|
 8 | |03.| [Contains Duplicate](https://leetcode.com/problems/contains-duplicate/)|[Solution](contains_duplicate.cpp)|
 9 | |04.| [Missing Number](https://leetcode.com/problems/missing-number/)|[Solution](missing_no.cpp)|
10 | |05.| [Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/)|[Solution](intersection_of_two_arrays_i.cpp)|
11 | |06.| [Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/)|[Solution](intersection_of_two_arrays_ii.cpp)|
12 | |07.| [Third Maximum Number](https://leetcode.com/problems/third-maximum-number/)|[Solution](third_maximum_no.cpp)|
13 | |08.| [Assign Cookies](https://leetcode.com/problems/assign-cookies/)|Pending|
14 | |09.| [Array Partition I](https://leetcode.com/problems/array-partition-i/)|Pending|
15 | |10.| [Maximum Product of Three Numbers](https://leetcode.com/problems/maximum-product-of-three-numbers/)|[Solution](maximum_product_of_3_no.cpp)|
16 | |11.| [Sort Array By Parity](https://leetcode.com/problems/sort-array-by-parity/)|Pending|
17 | |12.| [Sort Array By Parity II](https://leetcode.com/problems/sort-array-by-parity-ii/)|Pending|
18 | |13.| [Largest Perimeter Triangle](https://leetcode.com/problems/largest-perimeter-triangle/)|Pending|
19 | |14.| [Squares of a Sorted Array](https://leetcode.com/problems/squares-of-a-sorted-array/)|Pending|
20 | |15.| [Matrix Cells in Distance Order](https://leetcode.com/problems/matrix-cells-in-distance-order/)|Pending|
21 | |16.| [Height Checker](https://leetcode.com/problems/height-checker/)|Pending|
22 | |17.| [Relative Sort Array](https://leetcode.com/problems/relative-sort-array/)|Pending|
23 | |18.| [Minimum Absolute Difference](https://leetcode.com/problems/minimum-absolute-difference/)|Pending|
24 | |19.| [Rank Transform of an Array](https://leetcode.com/problems/rank-transform-of-an-array/)|Pending|
25 | |20.| [Sort Integers by The Number of 1 Bits](https://leetcode.com/problems/sort-integers-by-the-number-of-1-bits/)|Pending|
26 | |21.| [How Many Numbers Are Smaller Than the Current Number](https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/)|Pending|
27 | |22.| [Maximum Product of Two Elements in an Array](https://leetcode.com/problems/maximum-product-of-two-elements-in-an-array/)|Pending|
28 | |23.| [Average Salary Excluding the Minimum and Maximum Salary](https://leetcode.com/problems/average-salary-excluding-the-minimum-and-maximum-salary/)|Pending|
29 | |24.| [Make Two Arrays Equal by Reversing Sub-arrays](https://leetcode.com/problems/make-two-arrays-equal-by-reversing-sub-arrays/)|Pending|
30 | |25.| [Can Make Arithmetic Progression From Sequence](https://leetcode.com/problems/can-make-arithmetic-progression-from-sequence/)|Pending|
31 | |26.| [Sort Array by Increasing Frequency](https://leetcode.com/problems/sort-array-by-increasing-frequency/)|Pending|
32 | |27.| [Special Array With X Elements Greater Than or Equal X](https://leetcode.com/problems/special-array-with-x-elements-greater-than-or-equal-x/)|Pending|
33 | |28.| [Find All Numbers Disappeared in an Array](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/) |Pending|
34 | 
35 | 
36 | ## Medium
37 | |S.no.|Question|Solution|
38 | |---|------------|------------|
39 | |01.| [3Sum](https://leetcode.com/problems/3sum/)|Pending|
40 | |02.| [3Sum Closest](https://leetcode.com/problems/3sum-closest/)|Pending|
41 | |03.| [4Sum](https://leetcode.com/problems/4sum/)|Pending|
42 | |04.| [Group Anagrams](https://leetcode.com/problems/group-anagrams/)|Pending|
43 | |05.| [Merge Intervals](https://leetcode.com/problems/merge-intervals/)|Pending|
44 | |06.| [Sort Colors](https://leetcode.com/problems/sort-colors/)|Pending|
45 | |07.| [Insertion Sort List](https://leetcode.com/problems/insertion-sort-list/)|Pending|
46 | |08.| [Sort List](https://leetcode.com/problems/sort-list/)|Pending|
47 | |09.| [Largest Number](https://leetcode.com/problems/largest-number/)|Pending|
48 | |10.| [Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/)|Pending|
49 | 


--------------------------------------------------------------------------------
/Sorting/contains_duplicate.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | bool containsDuplicate(vector<int> &nums)
 5 | {
 6 |     // approch 1 using unordered set and stl
 7 |     // return nums.size() > unordered_set<int>(nums.begin(), nums.end()).size();
 8 |     
 9 |     //  approach 2- efficient approach
10 |     sort(nums.begin(), nums.end());
11 |     for (int i = 1; i < nums.size(); i++)
12 |     {
13 |         if (nums[i] == nums[i - 1])
14 |             return 1;
15 |     }
16 |     return 0;
17 | }
18 | 
19 | int main()
20 | {
21 |     int t;
22 |     cin >> t;
23 |     while (t--)
24 |     {
25 |         int n;
26 |         cin >> n;
27 |         vector<int> nums;
28 |         for (int i = 0; i < n; i++)
29 |         {
30 |             int temp;
31 |             cin >> temp;
32 |             nums.push_back(temp);
33 |         }
34 |         cout << containsDuplicate(nums) << endl;
35 |     }
36 |     return 0;
37 | }


--------------------------------------------------------------------------------
/Sorting/intersection_of_two_arrays_i.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> intersection(vector<int> &nums1, vector<int> &nums2)
 5 | {
 6 |     sort(nums1.begin(), nums1.end());
 7 |     sort(nums2.begin(), nums2.end());
 8 |     int n = nums1.size(), m = nums2.size();
 9 |     vector<int> ans;
10 |     int i = 0, j = 0;
11 |     while (i < n && j < m)
12 |     {
13 |         if (nums1[i] == nums2[j])
14 |         {
15 |             if (ans.empty())
16 |                 ans.push_back(nums1[i]);
17 |             else if (!ans.empty() && ans[ans.size() - 1] != nums1[i])
18 |                 ans.push_back(nums1[i]);
19 |             i++;
20 |             j++;
21 |         }
22 |         else if (nums1[i] > nums2[j])
23 |             j++;
24 |         else
25 |             i++;
26 |     }
27 |     return ans;
28 | }
29 | 
30 | int main()
31 | {
32 |     int t;
33 |     cin >> t;
34 |     while (t--)
35 |     {
36 |         int n, m;
37 |         cin >> m >> n;
38 |         vector<int> nums1;
39 |         vector<int> nums2;
40 |         for (int i = 0; i < m; i++)
41 |         {
42 |             int temp;
43 |             cin >> temp;
44 |             nums1.push_back(temp);
45 |         }
46 |         for (int i = 0; i < n; i++)
47 |         {
48 |             int temp;
49 |             cin >> temp;
50 |             nums2.push_back(temp);
51 |         }
52 |         vector<int> ans = intersection(nums1, nums2);
53 |         for (auto i : ans)
54 |             cout << i << " ";
55 |         cout << endl;
56 |     }
57 |     return 0;
58 | }


--------------------------------------------------------------------------------
/Sorting/majority_ele.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int majorityElement(vector<int> &nums)
 5 | {
 6 |     sort(nums.begin(), nums.end());
 7 |     int chk = nums.size() / 2;
 8 |     if (nums.size() == 1)
 9 |         return nums[0];
10 |     if (nums.size() == 2)
11 |     {
12 |         return nums[0];
13 |     }
14 |     for (int i = 0; i < nums.size() - 1; i++)
15 |     {
16 |         int temp = 0;
17 |         while (nums[i] == nums[i + 1])
18 |         {
19 |             temp++;
20 |             i++;
21 |         }
22 | 
23 |         if (temp >= chk)
24 |             return nums[i - 1];
25 |     }
26 |     return -1;
27 | }
28 | 
29 | int main()
30 | {
31 |     int t;
32 |     cin >> t;
33 |     while (t--)
34 |     {
35 |         int n;
36 |         cin >> n;
37 |         vector<int> nums;
38 |         for (int i = 0; i < n; i++)
39 |         {
40 |             int temp;
41 |             cin >> temp;
42 |             nums.push_back(temp);
43 |         }
44 |         cout << majorityElement(nums) << endl;
45 |     }
46 |     return 0;
47 | }


--------------------------------------------------------------------------------
/Sorting/maximum_product_of_3_no.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int maximumProduct(vector<int> &nums)
 5 | {
 6 |     sort(nums.begin(), nums.end());
 7 |     int n = nums.size();
 8 |     int temp1 = nums[n - 1] * nums[n - 2] * nums[n - 3];
 9 |     int temp2 = nums[0] * nums[1] * nums[n - 1];
10 |     return max(temp1, temp2);
11 | }
12 | 
13 | int main()
14 | {
15 |     int t;
16 |     cin >> t;
17 |     while (t--)
18 |     {
19 |         int n;
20 |         cin >> n;
21 |         vector<int> nums;
22 |         for (int i = 0; i < n; i++)
23 |         {
24 |             int temp;
25 |             cin >> temp;
26 |             nums.push_back(temp);
27 |         }
28 |         cout << maximumProduct(nums) << endl;
29 |     }
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/Sorting/merge_sorted_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | using namespace std;
 5 | 
 6 | void merge(vector<int> &nums1, int m, vector<int> &nums2, int n)
 7 | {
 8 |     int i = m - 1, j = n - 1, tar = n + m - 1;
 9 | 
10 |     while (j >= 0)
11 |     {
12 |         if (i >= 0 && nums1[i] > nums2[j])
13 |             nums1[tar--] = nums1[i--];
14 |         else
15 |             nums1[tar--] = nums2[j--];
16 |     }
17 | }
18 | 
19 | int main()
20 | {
21 |     int t;
22 |     cin >> t;
23 |     while (t--)
24 |     {
25 |         int n, m;
26 |         cin >> m >> n;
27 |         vector<int> nums1(m + n, 0);
28 |         vector<int> nums2(n, 0);
29 |         for (int i = 0; i < m + n; i++)
30 |         {
31 |             int temp;
32 |             cin >> temp;
33 |             nums1[i] = temp;
34 |         }
35 |         for (int i = 0; i < n; i++)
36 |         {
37 |             int temp;
38 |             cin >> temp;
39 |             nums2[i] = temp;
40 |         }
41 |         merge(nums1, m, nums2, n);
42 |         for (auto i : nums1)
43 |             cout << i << " ";
44 |         cout << endl;
45 |     }
46 |     return 0;
47 | }


--------------------------------------------------------------------------------
/Sorting/missing_no.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int missingNumber(vector<int> &nums)
 5 | {
 6 |     int n = nums.size();
 7 |     int sum = (n * (n + 1)) / 2;
 8 |     int temp = 0;
 9 |     for (int i = 0; i < n; i++)
10 |         temp += nums[i];
11 |     return sum - temp;
12 | }
13 | 
14 | int main()
15 | {
16 |     int t;
17 |     cin >> t;
18 |     while (t--)
19 |     {
20 |         int n;
21 |         cin >> n;
22 |         vector<int> nums;
23 |         for (int i = 0; i < n; i++)
24 |         {
25 |             int temp;
26 |             cin >> temp;
27 |             nums.push_back(temp);
28 |         }
29 |         cout << missingNumber(nums) << endl;
30 |     }
31 |     return 0;
32 | }


--------------------------------------------------------------------------------
/Sorting/third_maximum_no.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int thirdMax(vector<int> &nums)
 5 | {
 6 |     set<int> top3;
 7 |     for (int num : nums)
 8 |     {
 9 |         top3.insert(num);
10 |         if (top3.size() > 3)
11 |             top3.erase(top3.begin());
12 |     }
13 |     return top3.size() == 3 ? *top3.begin() : *top3.rbegin();
14 | }
15 | 
16 | int main()
17 | {
18 |     int t;
19 |     cin >> t;
20 |     while (t--)
21 |     {
22 |         int n;
23 |         cin >> n;
24 |         vector<int> nums;
25 |         for (int i = 0; i < n; i++)
26 |         {
27 |             int temp;
28 |             cin >> temp;
29 |             nums.push_back(temp);
30 |         }
31 |         cout << thirdMax(nums) << endl;
32 |     }
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Sorting/two_sum_ii_input_array_is_sorted.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int binary_search(vector<int> arr, int n, int target, int i)
 5 | {
 6 |     int low = 0, high = n - 1;
 7 |     while (low <= high)
 8 |     {
 9 |         int mid = low + (high - low) / 2;
10 |         if (arr[mid] == target)
11 |         {
12 |             if (mid != i)
13 |                 return mid;
14 |             else if (arr[mid - 1] == target)
15 |                 return mid - 1;
16 |             else
17 |                 return mid + 1;
18 |         }
19 |         else if (arr[mid] > target)
20 |             high = mid - 1;
21 |         else
22 |             low = mid + 1;
23 |     }
24 |     return -1;
25 | }
26 | 
27 | vector<int> twoSum(vector<int> &num, int target)
28 | {
29 |     int n = num.size();
30 |     for (int i = 0; i < n; i++)
31 |     {
32 |         int temp = binary_search(num, n, target - num[i], i);
33 |         if (temp != -1)
34 |             return {i + 1, temp + 1};
35 |     }
36 |     return {-1, -1};
37 | }
38 | 
39 | int main()
40 | {
41 |     int t;
42 |     cin >> t;
43 |     while (t--)
44 |     {
45 |         int n, target;
46 |         cin >> n >> target;
47 |         vector<int> v;
48 |         for (int i = 0; i < n; i++)
49 |         {
50 |             int temp;
51 |             cin >> temp;
52 |             v.push_back(temp);
53 |         }
54 |         vector<int> ans = twoSum(v, target);
55 |         cout << ans[0] << " " << ans[1] << endl;
56 |     }
57 |     return 0;
58 | }


--------------------------------------------------------------------------------
/String/README.md:
--------------------------------------------------------------------------------
 1 | # Problems:
 2 | 
 3 | ## Easy
 4 | |S.no.|Question|Solution|
 5 | |---|------------|------------|
 6 | |01.|[Valid Palindrome](https://leetcode.com/problems/valid-palindrome/)|[Solution](palindrome.cpp)|
 7 | |02.|[Valid Anagram](https://leetcode.com/problems/valid-anagram/)|[Solution](anagram.cpp)|
 8 | |03.|[Reverse String](https://leetcode.com/problems/reverse-string/)|[Solution](reverse_string.cpp)|
 9 | |04.|[Excel Sheet Column Number](https://leetcode.com/problems/excel-sheet-column-number/)|[Solution](excel_sheet_col_no.cpp)|
10 | |05.|[Excel Sheet Column Title](https://leetcode.com/problems/excel-sheet-column-title/)|[Solution](excel_sheet_col_title.cpp)|
11 | |06.|[Number of Segments in a String](https://leetcode.com/problems/number-of-segments-in-a-string/)|[Solution](no_of_segments_in_string.cpp)|
12 | |07.|[First Unique Character in a String](https://leetcode.com/problems/first-unique-character-in-a-string/)|[Solution](first_unique_char.cpp)|
13 | |08.|[Rotate String](https://leetcode.com/problems/rotate-string/)|[Solution](rotate_string.cpp)|
14 | |09.|[Unique Morse Code Words](https://leetcode.com/problems/unique-morse-code-words/)|Pending|
15 | |10.|[Long Pressed Name/Faulty Keyboard](https://leetcode.com/problems/long-pressed-name/)|Pending|
16 | |11.|[Valid Palindrome II](https://leetcode.com/problems/valid-palindrome-ii/)|Pending|
17 | |12.|[Add Strings](https://leetcode.com/problems/add-strings/)|Pending|
18 | |13.|[Repeated Substring Pattern](https://leetcode.com/problems/repeated-substring-pattern/)|Pending|
19 | |14.|[Count Items Matching a Rule](https://leetcode.com/problems/count-items-matching-a-rule/)|Pending|
20 | |15.|[Goal Parser Interpretation](https://leetcode.com/problems/goal-parser-interpretation/)|Pending|
21 | |16.|[Decrypt String from Alphabet to Integer Mapping](https://leetcode.com/problems/decrypt-string-from-alphabet-to-integer-mapping/)|Pending|
22 | |17.|[Thousand Separator](https://leetcode.com/problems/thousand-separator/)|Pending|
23 | |18.|[Consecutive Characters](https://leetcode.com/problems/consecutive-characters/)|Pending|
24 | |19.|[Roman to integer](https://leetcode.com/problems/roman-to-integer/)|Pending|
25 | |20.|[Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/)|Pending|
26 | |21.|[Length of Last Word](https://leetcode.com/problems/length-of-last-word/)|Pending|
27 | |22.|[Make the String Great](https://leetcode.com/problems/make-the-string-great/)|Pending|
28 | 
29 | ## Medium
30 | |S.no.|Question|Solution|
31 | |---|------------|------------|
32 | |01.|[Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/)|Pending|
33 | |02.|[Remove Duplicate Letters](https://leetcode.com/problems/remove-duplicate-letters/)|Pending|
34 | |03.|[Minimum Length of String After Deleting Similar Ends](https://leetcode.com/problems/minimum-length-of-string-after-deleting-similar-ends/)|Pending|
35 | |04.|[Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/)|Pending|
36 | |05.|[String Compression](https://leetcode.com/problems/string-compression/)|Pending|
37 | |06.|[Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring/)|Pending|
38 | 
39 | ## Hard
40 | |S.no.|Question|Solution|
41 | |---|------------|------------|
42 | |01.|[Orderly Queue](https://leetcode.com/problems/orderly-queue/)|Pending|
43 | 
44 | 


--------------------------------------------------------------------------------
/String/anagram.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | #include <algorithm>
 4 | 
 5 | using namespace std;
 6 | 
 7 | bool isAnagram(string s, string t)
 8 | {
 9 |     // using arrayas we only have 26 chars
10 |     if (s.length() != t.length())
11 |         return false;
12 |     int n = s.length();
13 |     int counts[26] = {0};
14 |     for (int i = 0; i < n; i++)
15 |     {
16 |         counts[s[i] - 'a']++;
17 |         counts[t[i] - 'a']--;
18 |     }
19 |     for (int i = 0; i < 26; i++)
20 |         if (counts[i])
21 |             return false;
22 |     return true;
23 | 
24 |     // using sorting algo
25 |     // sort(s.begin(), s.end());
26 |     // sort(t.begin(), t.end());
27 |     // return s==t;
28 | }
29 | 
30 | int main()
31 | {
32 |     string s, t;
33 |     cin>>s>>t;
34 |     cout << isAnagram(s,t) << endl;
35 | }


--------------------------------------------------------------------------------
/String/excel_sheet_col_no.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int titleToNumber(string s) {
 5 |         if(s.size()==1) return (s[0]-'A')+1;
 6 |         int ans = 0;
 7 |         int n = s.size();
 8 |         long long prev=26; 
 9 |         for(int i=n-2; i>=0; i--){
10 |             ans += ((s[i]-'A')+1)*prev;
11 |             prev*=26;
12 |         }
13 |         ans += (s[n-1]-'A')+1;
14 |         return ans;
15 |     }
16 | 
17 | int main(){
18 |     string s;
19 |     cin>>s;
20 |     cout<<titleToNumber(s)<<endl;
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/String/excel_sheet_col_title.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | string convertToTitle(int columnNumber)
 5 | {
 6 |     string result = "";
 7 |     while (columnNumber > 0)
 8 |     {
 9 |         int remainder = columnNumber % 26;
10 |         if (remainder == 0)
11 |         {
12 |             result = 'Z' + result;
13 |             remainder = 26;
14 |         }
15 |         else
16 |         {
17 |             char c = 'A' + (remainder - 1);
18 |             result = c + result;
19 |         }
20 |         columnNumber = (columnNumber - remainder) / 26;
21 |     }
22 |     return result;
23 | }
24 | 
25 | int main()
26 | {
27 |     int n;
28 |     cin>>n;
29 |     cout<<convertToTitle(n)<<endl;
30 | }


--------------------------------------------------------------------------------
/String/first_unique_char.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int firstUniqChar(string s) {
 5 |         vector<int> v(26,0);
 6 | 		for(char c : s) v[c - 'a']++;
 7 | 		for(int i = 0; i < s.length(); i++){
 8 | 			if(v[s[i] - 'a'] == 1) return i;
 9 | 		}
10 | 		return -1;
11 |     }
12 | 
13 | int main(){
14 |     string s;
15 |     cin>>s;
16 |     cout<<firstUniqChar(s)<<endl;
17 |     return 0;
18 | }


--------------------------------------------------------------------------------
/String/no_of_segments_in_string.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int countSegments(string s)
 5 | {
 6 |     if (!s.size())
 7 |         return 0;
 8 |     if (s.size() == 1 and s[0] == ' ')
 9 |         return 0;
10 |     int count = 0;
11 |     bool ck = 0;
12 |     if (s[0] != ' ')
13 |         count++;
14 |     for (int i = 0; i < s.size() - 1; i++)
15 |     {
16 |         if (s[i] == ' ')
17 |         {
18 |             ck = 1;
19 |             if (s[i + 1] != ' ')
20 |             {
21 |                 count++;
22 |             }
23 |         }
24 |     }
25 |     if (count == 1 && ck)
26 |         return --count;
27 |     return count;
28 | }
29 | 
30 | 
31 | int main(){
32 |     string s;
33 |     getline(cin,s);
34 |     cin.ignore();
35 |     cout<<countSegments(s);
36 |     return 0;
37 | }


--------------------------------------------------------------------------------
/String/palindrome.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | #include <algorithm>
 4 | 
 5 | using namespace std;
 6 | 
 7 | bool isPalindrome(string s)
 8 | {
 9 |     for (int i = 0, j = s.size() - 1; i < j; i++, j--)
10 |     {
11 |         while (isalnum(s[i]) == false && i < j)
12 |             i++;
13 |         while (isalnum(s[j]) == false && i < j)
14 |             j--;
15 |         if (toupper(s[i]) != toupper(s[j]))
16 |             return false;
17 |     }
18 | 
19 |     return true;
20 | }
21 | 
22 | int main()
23 | {
24 |     string s;
25 |     getline(cin,s);
26 |     cin.ignore();
27 |     cout<<isPalindrome(s)<<endl;
28 | }


--------------------------------------------------------------------------------
/String/reverse_string.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void reverseString(vector<char> &s)
 5 | {
 6 |     int i = 0, n = s.size() - 1;
 7 |     while (i < n)
 8 |     {
 9 |         swap(s[i++], s[n--]);
10 |     }
11 | }
12 | 
13 | int main()
14 | {
15 |     int n;
16 |     cin >> n;
17 |     vector<char> s;
18 |     for (int i = 0; i < n; i++)
19 |     {
20 |         char ch;
21 |         cin >> ch;
22 |         s.push_back(ch);
23 |     }
24 |     reverseString(s);
25 |     for (auto i : s)
26 |         cout << i << " ";
27 |     cout << endl;
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/String/rotate_string.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | bool rotateString(string s, string goal)
 5 | {
 6 |     if (s.length() != goal.length()) 
 7 |     // if length of two string are different they can't be  rotation of each other.
 8 |         return false;
 9 |     string ans = s + s; 
10 |     // SIMPLY CONCATENATE THE S STRING WITH ITSELF.
11 | 
12 |     if (ans.find(goal) != string ::npos) 
13 |     // NOW FIND THE GOAL STRING is present in our conacatenated string or not if present return true else false.
14 |         return true;
15 |     return false;
16 | }
17 | 
18 | int main()
19 | {
20 |     string s, g;
21 |     cin >> s >> g;
22 |     cout<<rotateString(s,g)<<endl;
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/pattern:
--------------------------------------------------------------------------------
   1 | #include<iostream>
   2 | using namespace std;
   3 | 
   4 | void pattern1()
   5 | {   
   6 | 
   7 | /*
   8 |     1. 
   9 |     *****
  10 |     *****
  11 |     *****
  12 |     *****
  13 |     *****
  14 | */
  15 | 
  16 |     int n;
  17 |     cout<<"Enter a number: ";
  18 |     cin>>n;
  19 | 
  20 |     for(int i = 0; i < n; ++i)
  21 |     {
  22 |         for(int j = 0; j < n; ++j)
  23 |         {
  24 |             cout<<"*";
  25 |         }
  26 |         cout<<endl;
  27 |     }
  28 | }
  29 | 
  30 | void pattern2()
  31 | {
  32 | 
  33 | /*
  34 | -------------------------------------------------
  35 | 2.  *
  36 |     **
  37 |     ***
  38 |     ****
  39 |     *****
  40 | */
  41 |     int n;
  42 |     cout<<"Enter a number: ";
  43 |     cin>>n;
  44 | 
  45 |     for(int i = 1; i <= n; ++i)
  46 |     {
  47 |         for(int j = 0; j <= i; j++)
  48 |         {
  49 |             cout<<"*";
  50 |         }
  51 |         cout<<endl;
  52 |     }
  53 | 
  54 | }
  55 | 
  56 | void pattern3()
  57 | {
  58 | 
  59 | /*
  60 | --------------------------------------------------
  61 | 
  62 | 3.  *****
  63 |     ****
  64 |     ***
  65 |     **
  66 |     *
  67 | */
  68 | 
  69 |     int n;
  70 |     cout<<"Enter a number: ";
  71 |     cin>>n;
  72 | 
  73 |     for(int row = 1; row <= n; ++row)
  74 |     {
  75 |         for(int col = 1; col <= n-row+1; col++)
  76 |         {
  77 |             cout<<"* ";
  78 |         }
  79 |         cout<<endl;
  80 |     }
  81 |     
  82 | }
  83 | 
  84 | void pattern4()
  85 | {
  86 | 
  87 | /*
  88 | --------------------------------------------------
  89 | 4.  1
  90 |     1 2
  91 |     1 2 3
  92 |     1 2 3 4
  93 |     1 2 3 4 5
  94 | */
  95 | 
  96 |     int n;
  97 |     cout<<"Enter a number: ";
  98 |     cin>>n;
  99 | 
 100 |     for(int row = 1; row <= n; ++row)
 101 |     {
 102 |         for(int col = 1; col <= row; col++)
 103 |         {
 104 |             cout<<col<<" ";
 105 |         }
 106 |         cout<<endl;
 107 |     }
 108 |     
 109 | }
 110 | 
 111 | void pattern5()
 112 | {
 113 | 
 114 | /*
 115 | --------------------------------------------------
 116 | 5.  *
 117 |     **
 118 |     ***
 119 |     ****
 120 |     *****
 121 |     ****
 122 |     ***
 123 |     **
 124 |     *
 125 | */
 126 | 
 127 |     int n;
 128 |     cout<<"Enter a number: ";
 129 |     cin>>n;
 130 | 
 131 |     for(int row = 1; row <= (2*n) - 1; ++row)
 132 |     {
 133 |         int c = row > n ? n - (row - n) : row;
 134 |         {
 135 |             for (int col = 1; col <= c; ++col)
 136 |             {
 137 |                 cout<<"* ";
 138 |             }
 139 |             cout<<endl;
 140 |         }
 141 |     }
 142 |     
 143 | }
 144 | 
 145 | void pattern6()
 146 | {
 147 | 
 148 | /*
 149 | --------------------------------------------------
 150 | 6.       *
 151 |         **
 152 |        ***
 153 |       ****
 154 |      *****
 155 | */
 156 | 
 157 | 
 158 |     int n;
 159 |     cout<<"Enter a number: ";
 160 |     cin>>n;
 161 | 
 162 |     for(int row = 1; row <= n; ++row)
 163 |     {
 164 |         for (int noOfSpace = 0; noOfSpace < n-row; noOfSpace++)
 165 |         {
 166 |             cout<<" ";
 167 |         }
 168 |         for (int col = 1; col <= row; ++col)
 169 |         {
 170 |             cout<<"*";
 171 |         }
 172 |          cout<<endl;
 173 |     
 174 |     }
 175 | 
 176 | }
 177 | 
 178 | void pattern7()
 179 | {
 180 | 
 181 | /*
 182 | --------------------------------------------------
 183 | 7.   *****
 184 |       ****
 185 |        ***
 186 |         **
 187 |          *
 188 | */
 189 | 
 190 | 
 191 |     int n;
 192 |     cout<<"Enter a number: ";
 193 |     cin>>n;
 194 | 
 195 |     for(int row = 1; row <= n; ++row)
 196 |     {
 197 |         for (int noOfSpace = 0; noOfSpace < n - (n - row + 1); noOfSpace++)
 198 |         {
 199 |             cout<<" ";
 200 |         }
 201 |         for (int col = 1; col <= n - row + 1; ++col)
 202 |         {
 203 |             cout<<"*";
 204 |         }
 205 |          cout<<endl;
 206 |     
 207 |     }
 208 |     
 209 | }
 210 | 
 211 | void pattern8()
 212 | {
 213 | 
 214 | /*
 215 | --------------------------------------------------
 216 | 8.      *
 217 |        ***
 218 |       *****
 219 |      *******
 220 |     *********
 221 | */
 222 | 
 223 | 
 224 |     int n;
 225 |     cout<<"Enter a number: ";
 226 |     cin>>n;
 227 | 
 228 |     for(int row = 1; row <= n; ++row)
 229 |     {
 230 |         for (int noOfSpace = 0; noOfSpace < n - row; noOfSpace++)
 231 |         {
 232 |             cout<<" ";
 233 |         }
 234 |         int a = 2*(row - 1) + 1;
 235 |         for (int col = 1; col <= a; ++col)
 236 |         {
 237 |             cout<<"*";
 238 |         }
 239 |          cout<<endl;
 240 |     
 241 |     }
 242 |    
 243 | }
 244 | 
 245 | void pattern9()
 246 | {
 247 | 
 248 | /*
 249 | --------------------------------------------------
 250 | 9.  *********
 251 |      *******
 252 |       *****
 253 |        ***
 254 |         *
 255 | */
 256 | 
 257 | 
 258 |     int n;
 259 |     cout<<"Enter a number: ";
 260 |     cin>>n;
 261 | 
 262 |     for(int row = 1; row <= n; ++row)
 263 |     {
 264 |         for (int noOfSpace = 0; noOfSpace < n - (n - row + 1); noOfSpace++)
 265 |         {
 266 |             cout<<" ";
 267 |         }
 268 |         int a = 2*((n - 1) - row + 1) + 1;
 269 |         for (int col = 1; col <= a; ++col)
 270 |         {
 271 |             cout<<"*";
 272 |         }
 273 |          cout<<endl;
 274 |     
 275 |     }
 276 |     
 277 | }
 278 | 
 279 | void pattern10()
 280 | {
 281 | 
 282 | /*
 283 | --------------------------------------------------
 284 | 10.      *
 285 |         * *
 286 |        * * *
 287 |       * * * *
 288 |      * * * * *
 289 | */
 290 | 
 291 | 
 292 |     int n;
 293 |     cout<<"Enter a number: ";
 294 |     cin>>n;
 295 | 
 296 |     for(int row = 1; row <= n; ++row)
 297 |     {
 298 |         for (int noOfSpace = 0; noOfSpace < n-row; noOfSpace++)
 299 |         {
 300 |             cout<<" ";
 301 |         }
 302 |         for (int col = 1; col <= row; ++col)
 303 |         {
 304 |             cout<<"* ";
 305 |         }
 306 |          cout<<endl;
 307 |     
 308 |     }
 309 | 
 310 | }
 311 | 
 312 | void pattern11()
 313 | {
 314 | /*
 315 | --------------------------------------------------
 316 | 11.  * * * * *
 317 |       * * * *
 318 |        * * *
 319 |         * *
 320 |          *
 321 | */
 322 | 
 323 | 
 324 |     int n;
 325 |     cout<<"Enter a number: ";
 326 |     cin>>n;
 327 | 
 328 |     for(int row = 1; row <= n; ++row)
 329 |     {
 330 |         for (int noOfSpace = 0; noOfSpace < n - (n - row + 1); noOfSpace++)
 331 |         {
 332 |             cout<<" ";
 333 |         }
 334 |         for (int col = 1; col <= n - row + 1; ++col)
 335 |         {
 336 |             cout<<"* ";
 337 |         }
 338 |          cout<<endl;
 339 |     
 340 |     }
 341 |     
 342 | }
 343 | 
 344 | void pattern12()
 345 | {
 346 | 
 347 | /*
 348 | --------------------------------------------------
 349 | 12.  * * * * *
 350 |       * * * *
 351 |        * * *
 352 |         * *
 353 |          *
 354 |          *
 355 |         * *
 356 |        * * *
 357 |       * * * *
 358 |      * * * * *
 359 | */
 360 | 
 361 | 
 362 |     int n;
 363 |     cout<<"Enter a number: ";
 364 |     cin>>n;
 365 | 
 366 |     for(int row = 1; row <= 2*n; ++row)
 367 |     {
 368 |         int noOfcol = row>n ? row - n : n - row + 1;
 369 |         for (int noOfSpace = 0; noOfSpace < n - noOfcol; noOfSpace++)
 370 |         {
 371 |             cout<<" ";
 372 |         }
 373 |         for (int col = 1; col <= noOfcol; ++col)
 374 |         {
 375 |             cout<<"* ";
 376 |         }
 377 |          cout<<endl;
 378 |     
 379 |     }
 380 |     
 381 | }
 382 | 
 383 | void pattern13()
 384 | {
 385 | 
 386 | /*
 387 | --------------------------------------------------
 388 | 13.      *
 389 |         * *
 390 |        *   *
 391 |       *     *
 392 |      *********
 393 | */
 394 | 
 395 | 
 396 |     int n;
 397 |     cout<<"Enter a number: ";
 398 |     cin>>n;
 399 | 
 400 |     for(int row = 1; row <= n; ++row)
 401 |     {
 402 |         for (int noOfSpace = 0; noOfSpace < n - row; noOfSpace++)
 403 |         {
 404 |             cout<<" ";
 405 |         }
 406 |         int a = 2*(row - 1) + 1;
 407 |         for (int col = 1; col <= a; ++col)
 408 |         {
 409 |             row == n ? cout<<"*" : col == 1 || col == a ? cout<<"*" : cout<<" ";
 410 |         }
 411 |         cout<<endl;
 412 |     }
 413 |     
 414 | }
 415 | 
 416 | void pattern14()
 417 | {
 418 | 
 419 | /*
 420 | --------------------------------------------------
 421 | 14.  *********
 422 |       *     *
 423 |        *   *
 424 |         * *
 425 |          *
 426 | */
 427 | 
 428 | 
 429 |     int n;
 430 |     cout<<"Enter a number: ";
 431 |     cin>>n;
 432 | 
 433 |     for(int row = 1; row <= n; ++row)
 434 |     {
 435 |         for (int noOfSpace = 0; noOfSpace < n - (n - row + 1); noOfSpace++)
 436 |         {
 437 |             cout<<" ";
 438 |         }
 439 |         int a = 2*((n - 1) - row + 1) + 1;
 440 |         for (int col = 1; col <= a; ++col)
 441 |         {
 442 |             row == 1 ? cout<<"*" : col == 1 || col == a ? cout<<"*" : cout<<" "; 
 443 |         }
 444 |         cout<<endl;
 445 |     }
 446 |     
 447 | }
 448 | 
 449 | void pattern15()
 450 | {
 451 | 
 452 | /*
 453 | -------------------------------------------------
 454 | 15.      *
 455 |         * *
 456 |        *   *
 457 |       *     *
 458 |      *       *
 459 |       *     *
 460 |        *   *
 461 |         * *
 462 |          *
 463 | */
 464 | 
 465 | 
 466 |     int n;
 467 |     cout<<"Enter a number: ";
 468 |     cin>>n;
 469 | 
 470 |     for(int row = 1; row <= (2*n) - 1; ++row)
 471 |     {
 472 |         int noOfcol = row > n ? 2*(n - (row - n)) - 1 : 2*row - 1;
 473 |         int a = row > n ? row - n : n - row;
 474 |         for (int noOfSpace = 0; noOfSpace < a; noOfSpace++)
 475 |         {
 476 |             cout<<" ";
 477 |         }
 478 |         for (int col = 1; col <= noOfcol; ++col)
 479 |         {
 480 |             col == 1 || col == noOfcol ? cout<<"*" : cout<<" ";
 481 |         }
 482 |         cout<<endl;
 483 |     }
 484 |     
 485 | }
 486 | 
 487 | void pattern16()
 488 | {
 489 | 
 490 | /*
 491 | --------------------------------------------------
 492 | 16.           1
 493 |             1   1
 494 |           1   2   1
 495 |         1   3   3   1
 496 |       1   4   6   4   1
 497 | */
 498 | 
 499 | 
 500 | }
 501 | 
 502 | void pattern17()
 503 | {
 504 | 
 505 | /*-------------------------------------------------
 506 | 17.      1
 507 |         212
 508 |        32123
 509 |       4321234
 510 |        32123
 511 |         212
 512 |          1
 513 | 
 514 | */
 515 | 
 516 | 
 517 |     int n;
 518 |     cout<<"Enter a number: ";
 519 |     cin>>n;
 520 | 
 521 |     for(int row = 1; row <= n; ++row)
 522 |     {
 523 |         for (int space = 0; space < (n - row); space++){
 524 |             cout<<" ";
 525 |         }
 526 |         for (int col = row; col >= 1; --col){
 527 |             cout<<col;
 528 |         }
 529 |         for (int col = 2; col <= row; ++col){
 530 |             cout<<col;
 531 |         }
 532 |         cout<<endl;
 533 |     }
 534 |     for(int row = n-1; row >= 1; --row)
 535 |     {
 536 |         for (int space = 0; space < (n - row); space++){
 537 |             cout<<" ";
 538 |         }
 539 |         for (int col = row; col >= 1; --col){
 540 |             cout<<col;
 541 |         }
 542 |         for (int col = 2; col <= row; ++col){
 543 |             cout<<col;
 544 |         }
 545 |         cout<<endl;
 546 |     }
 547 |     
 548 | }
 549 | 
 550 | void pattern18()
 551 | {
 552 |     
 553 | /*
 554 | --------------------------------------------------
 555 | 18.   **********
 556 |       ****  ****
 557 |       ***    ***
 558 |       **      **
 559 |       *        *
 560 |       *        *
 561 |       **      **
 562 |       ***    *** 
 563 |       ****  ****
 564 |       **********
 565 | */
 566 | 
 567 | 
 568 |     int n;
 569 |     cout<<"Enter a number: ";
 570 |     cin>>n;
 571 | 
 572 |     for(int row = 1; row <= n; ++row)
 573 |     {
 574 |         for (int col = 1; col <= n - row + 1; ++col)
 575 |         {
 576 |             cout<<"*";
 577 |         }
 578 |         for (int col = 0; col < 2*(row - 1); ++col)
 579 |         {
 580 |             cout<<" ";
 581 |         }
 582 |         for (int col = 1; col <= n-row+1; ++col)
 583 |         {
 584 |             cout<<"*";
 585 |         }
 586 |         cout<<endl;
 587 |     }
 588 | 
 589 |     for(int row = n; row >= 1; --row)
 590 |     {
 591 |         for (int col = 1; col <= n - row + 1; ++col)
 592 |         {
 593 |             cout<<"*";
 594 |         }
 595 |         for (int col = 0; col < 2*row - 2; col++)
 596 |         {
 597 |             cout<<" ";
 598 |         }
 599 |         for (int col = 1; col <= n-row+1; ++col)
 600 |         {
 601 |             cout<<"*";
 602 |         }
 603 |         cout<<endl;
 604 |     }
 605 |     
 606 | 
 607 | }
 608 | 
 609 | void pattern19()
 610 | {
 611 | 
 612 | /*
 613 | --------------------------------------------------
 614 | 19.    *        *
 615 |        **      **
 616 |        ***    ***
 617 |        ****  ****
 618 |        **********
 619 |        ****  ****
 620 |        ***    ***
 621 |        **      **
 622 |        *        *
 623 | */
 624 | 
 625 | 
 626 |     int n;
 627 |     cout<<"Enter a number: ";
 628 |     cin>>n;
 629 | 
 630 |     for(int row = 1; row <= n; ++row)
 631 |     {
 632 |         for (int col = 1; col <= row; ++col)
 633 |         {
 634 |             cout<<"*";
 635 |         }
 636 |         for (int col = 0; col < 2*(n - row); ++col)
 637 |         {
 638 |             cout<<" ";
 639 |         }
 640 |         for (int col = 1; col <= row; ++col)
 641 |         {
 642 |             cout<<"*";
 643 |         }
 644 |         cout<<endl;
 645 |     }
 646 |     for(int row = n-1; row >= 1; --row)
 647 |     {
 648 |         for (int col = 1; col <= row; ++col)
 649 |         {
 650 |             cout<<"*";
 651 |         }
 652 |         for (int col = 0; col < 2*(n - row); ++col)
 653 |         {
 654 |             cout<<" ";
 655 |         }
 656 |         for (int col = 1; col <= row; ++col)
 657 |         {
 658 |             cout<<"*";
 659 |         }
 660 |         cout<<endl;
 661 |     }
 662 |     
 663 | }
 664 | 
 665 | void pattern20()
 666 | {
 667 | 
 668 | /*
 669 | --------------------------------------------------
 670 | 20.    ****
 671 |        *  *
 672 |        *  *
 673 |        *  *
 674 |        ****
 675 | */
 676 | 
 677 | 
 678 |     int n;
 679 |     cout<<"Enter a number: ";
 680 |     cin>>n;
 681 | 
 682 |     for(int row = 1; row <= n; ++row)
 683 |     {
 684 |         for (int col = 1; col <= n - 1; ++col)
 685 |         {
 686 |             col == 1 || col == n - 1 || row == 1 || row == n ? cout<<"*" : cout<<" ";
 687 |         }
 688 |         cout<<endl;
 689 |     }
 690 |     
 691 | }
 692 | 
 693 | void pattern21()
 694 | {
 695 | 
 696 | /*
 697 | --------------------------------------------------
 698 | 21.    1
 699 |        2  3
 700 |        4  5  6
 701 |        7  8  9  10
 702 |        11 12 13 14 15
 703 | */
 704 | 
 705 | 
 706 | 
 707 |     int n;
 708 | 
 709 |     int AtEveryIndex = 1;
 710 |     cout<<"Enter a number: ";
 711 |     cin>>n;
 712 |     for(int row = 1; row <= n; ++row)
 713 |     {
 714 |         for (int col = 1; col <= row; ++col)
 715 |         {
 716 |             cout<<AtEveryIndex<<"  ";
 717 |             ++AtEveryIndex;
 718 |         }
 719 |         cout<<endl;
 720 |     }
 721 |     
 722 | }
 723 | 
 724 | void pattern22()
 725 | {
 726 | 
 727 | /*
 728 | -------------------------------------------------
 729 | 22.    1
 730 |        0 1
 731 |        1 0 1
 732 |        0 1 0 1
 733 |        1 0 1 0 1
 734 | */
 735 | 
 736 | 
 737 |     int n;
 738 |     cout<<"Enter a number: ";
 739 |     cin>>n;
 740 |     for(int row = 1; row <= n; ++row)
 741 |     {
 742 |         for (int col = 1; col <= row; ++col)
 743 |         {
 744 |             row % 2 == 1 && col % 2 == 1 || row % 2 == 0 && col % 2 == 0 ? cout<<"1 " : cout<<"0 ";
 745 |         }
 746 |         cout<<endl;
 747 |     }
 748 |     
 749 | }
 750 | 
 751 | void pattern23()
 752 | {
 753 | 
 754 | /*
 755 | --------------------------------------------------
 756 | 23.        *      *
 757 |          *   *  *   *
 758 |        *      *      *
 759 | */
 760 | 
 761 | }
 762 | 
 763 | void pattern24()
 764 | {
 765 | 
 766 | /*--------------------------------------------------
 767 | 24.    *        *
 768 |        **      **
 769 |        * *    * *
 770 |        *  *  *  *
 771 |        *   **   *
 772 |        *   **   *
 773 |        *  *  *  *
 774 |        * *    * *
 775 |        **      **
 776 |        *        *
 777 | */
 778 | 
 779 | 
 780 |     int n;
 781 |     cout<<"Enter a number: ";
 782 |     cin>>n;
 783 | 
 784 |     for(int row = 1; row <= n; ++row)
 785 |     {
 786 |         for (int col = 1; col <= row; ++col)
 787 |         {
 788 |             col == 1 || col == row ? cout<<"*" : cout<<" ";
 789 |         }
 790 |         for (int col = 0; col < 2*(n - row); ++col)
 791 |         {
 792 |             cout<<" ";
 793 |         }
 794 |         for (int col = 1; col <= row; ++col)
 795 |         {
 796 |             col == 1 || col == row ? cout<<"*" : cout<<" ";
 797 |         }
 798 |         cout<<endl;
 799 |     }
 800 |     for(int row = n; row >= 1; --row)
 801 |     {
 802 |         for (int col = 1; col <= row; ++col)
 803 |         {
 804 |             col == 1 || col == row ? cout<<"*" : cout<<" ";
 805 |         }
 806 |         for (int col = 0; col < 2*(n - row); ++col)
 807 |         {
 808 |             cout<<" ";
 809 |         }
 810 |         for (int col = 1; col <= row; ++col)
 811 |         {
 812 |             col == 1 || col == row ? cout<<"*" : cout<<" ";
 813 |         }
 814 |         cout<<endl;
 815 |     }
 816 |     
 817 | }
 818 | 
 819 | void pattern25()
 820 | {
 821 | 
 822 | /*
 823 | --------------------------------------------------
 824 | 25.       *****
 825 |          *   *
 826 |         *   *
 827 |        *   *
 828 |       *****
 829 | */
 830 | 
 831 | 
 832 |     int n;
 833 |     cout<<"Enter a number: ";
 834 |     cin>>n;
 835 |     for(int row = 1; row <= n; ++row)
 836 |     {
 837 |         for(int space = 1; space <= n - row; space++)
 838 |         {
 839 |             cout<<" ";
 840 |         }
 841 |         for (int col = 1; col <= n - 1; ++col)
 842 |         {
 843 |             col == 1 || col == n - 1 || row == 1 || row == n ? cout<<"*" : cout<<" ";
 844 |         }
 845 |         cout<<endl;
 846 |     }
 847 |     
 848 | }
 849 | 
 850 | void pattern26()
 851 | {
 852 | 
 853 | /*
 854 | --------------------------------------------------
 855 | 26.   1 1 1 1 1 1
 856 |       2 2 2 2 2
 857 |       3 3 3 3
 858 |       4 4 4
 859 |       5 5
 860 |       6
 861 | */
 862 | 
 863 |     int n, a = 1;
 864 |     cout<<"Enter a number: ";
 865 |     cin>>n;
 866 | 
 867 |     for(int row = 1; row <= n; ++row)
 868 |     {
 869 |         for (int col = 1; col <= n - row + 1; ++col)
 870 |         {
 871 |             cout<<a<<" ";
 872 |         }
 873 |         ++a;
 874 |         cout<<endl;
 875 |     }
 876 | 
 877 | }
 878 | 
 879 | void pattern27()
 880 | {
 881 | 
 882 | /*--------------------------------------------------
 883 | 27.   1 2 3 4  17 18 19 20
 884 |         5 6 7  14 15 16
 885 |           8 9  12 13
 886 |             10 11
 887 | */
 888 | 
 889 | }
 890 | 
 891 | void pattern28()
 892 | {
 893 | 
 894 | /*
 895 | -------------------------------------------------
 896 | 28.      *
 897 |         * *
 898 |        * * *
 899 |       * * * *
 900 |      * * * * *
 901 |       * * * *
 902 |        * * *
 903 |         * *
 904 |          *
 905 | */
 906 | 
 907 | 
 908 |     int n;
 909 |     cout<<"Enter a number: ";
 910 |     cin>>n;
 911 | 
 912 |     for(int row = 1; row <= (2*n) - 1; ++row)
 913 |     {
 914 |         int c = row > n ? n - (row - n) : row;
 915 |         // int a = row > n ? row - n : n - row;
 916 |         int a = n - c;
 917 |         for (int noOfSpace = 0; noOfSpace < a; noOfSpace++)
 918 |         {
 919 |             cout<<" ";
 920 |         }
 921 |         for (int col = 1; col <= c; ++col)
 922 |         {
 923 |             cout<<"* ";
 924 |         }
 925 |          cout<<endl;
 926 |     
 927 |     }
 928 |     
 929 | }
 930 | 
 931 | void pattern29()
 932 | {
 933 | 
 934 | /*
 935 | --------------------------------------------------
 936 | 29.      
 937 |        *        *
 938 |        **      **
 939 |        ***    ***
 940 |        ****  ****
 941 |        **********
 942 |        **********
 943 |        ****  ****
 944 |        ***    ***
 945 |        **      **
 946 |        *        *
 947 | */
 948 | 
 949 | 
 950 |     int n;
 951 |     cout<<"Enter a number: ";
 952 |     cin>>n;
 953 | 
 954 |     for(int row = 1; row <= n; ++row)
 955 |     {
 956 |         for (int col = 1; col <= row; ++col)
 957 |         {
 958 |             cout<<"*";
 959 |         }
 960 |         for (int col = 0; col < 2*(n - row); ++col)
 961 |         {
 962 |             cout<<" ";
 963 |         }
 964 |         for (int col = 1; col <= row; ++col)
 965 |         {
 966 |             cout<<"*";
 967 |         }
 968 |         cout<<endl;
 969 |     }
 970 |     for(int row = n; row >= 1; --row)
 971 |     {
 972 |         for (int col = 1; col <= row; ++col)
 973 |         {
 974 |             cout<<"*";
 975 |         }
 976 |         for (int col = 0; col < 2*(n - row); ++col)
 977 |         {
 978 |             cout<<" ";
 979 |         }
 980 |         for (int col = 1; col <= row; ++col)
 981 |         {
 982 |             cout<<"*";
 983 |         }
 984 |         cout<<endl;
 985 |     }
 986 |     
 987 | }
 988 | 
 989 | void pattern30()
 990 | {
 991 | 
 992 | /*-------------------------------------------------
 993 | 30.         1
 994 |           2 1 2
 995 |         3 2 1 2 3
 996 |       4 3 2 1 2 3 4
 997 |     5 4 3 2 1 2 3 4 5
 998 | 
 999 | */
1000 | 
1001 |     int n;
1002 |     cout<<"Enter a number: ";
1003 |     cin>>n;
1004 | 
1005 |     for(int row = 1; row <= n; ++row)
1006 |     {
1007 |         for(int space = 0; space < n - row; ++space)
1008 |         {
1009 |             cout<<"  ";
1010 |         }
1011 |         for (int col = row; col >= 1; --col)
1012 |         {
1013 |             cout<<col<<" ";
1014 |         }
1015 |         for(int col = 2; col <= row; col++)
1016 |         {
1017 |             cout<<col<<" ";
1018 |         }
1019 |         cout<<endl;
1020 |     }
1021 | 
1022 | }
1023 | 
1024 | void pattern31()
1025 | {
1026 | 
1027 | /*
1028 | --------------------------------------------------
1029 | 31.      4 4 4 4 4 4 4  
1030 |          4 3 3 3 3 3 4   
1031 |          4 3 2 2 2 3 4   
1032 |          4 3 2 1 2 3 4   
1033 |          4 3 2 2 2 3 4   
1034 |          4 3 3 3 3 3 4   
1035 |          4 4 4 4 4 4 4   
1036 | */
1037 | 
1038 | }
1039 | 
1040 | void pattern32()
1041 | {
1042 | 
1043 | /*
1044 | --------------------------------------------------
1045 | 32.    E
1046 |        D E
1047 |        C D E
1048 |        B C D E
1049 |        A B C D E
1050 | */
1051 | 
1052 | }
1053 | 
1054 | void pattern33()
1055 | {
1056 | 
1057 | /*
1058 | --------------------------------------------------
1059 | 33.    a
1060 |        B c
1061 |        D e F
1062 |        g H i J
1063 |        k L m N o
1064 | */
1065 | 
1066 | }
1067 | 
1068 | void pattern34()
1069 | {
1070 | 
1071 | /*--------------------------------------------------
1072 |      
1073 | 34.    E D C B A
1074 |        D C B A
1075 |        C B A
1076 |        B A
1077 |        A
1078 | */
1079 | 
1080 | }
1081 | 
1082 | int main()
1083 | {
1084 |     
1085 |     return 0;
1086 | }
1087 | 


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