Gitingest

Include files under: 50kb

Private Repository

Summary

Repository: keremtan/leetcodechallenge
Files analyzed: 160

Estimated tokens: 24.9k

Download

Directory Structure

Directory structure:

└── keremtan-leetcodechallenge/

    ├── 1030_Matrix_Cells_in_Distance_Order.cpp

    ├── 1046_Last_Stone_Weight.cpp

    ├── 1047_Remove_All_Adjacent_Duplicates_In_String.cpp

    ├── 1103_Distribute_Candies_to_People.cpp

    ├── 1122_Relative_Sort_Array.cpp

    ├── 1137_N-th_Tribonacci_Number.cpp

    ├── 1189_Maximum_Number_of_Balloons.cpp

    ├── 118_Pascals_Triangle.cpp

    ├── 11_Container_With_Most_Water.cpp

    ├── 1200_Minimum_Absolute_Difference.cpp

    ├── 121_Best_Time_to_Buy_and_Sell_Stock.cpp

    ├── 122_Best_Time_to_Buy_and_Sell_Stock_II.cpp

    ├── 125_Valid_Palindrome.cpp

    ├── 1281_Subtract_the_Product_and_Sum_of_Digits_of_an_Integer.cpp

    ├── 1287_Element_Appearing_More_Than_25%_In_Sorted_Array.cpp

    ├── 1331_Rank_Transform_of_an_Array.cpp

    ├── 1332_Remove_Palindromic_Subsequences.cpp

    ├── 1337_The_K_Weakest_Rows_in_a_Matrix.cpp

    ├── 1356_Sort_Integers_by_The_Number_of_1_Bits.cpp

    ├── 136_Single_Number.cpp

    ├── 13_Roman_to_Integer.cpp

    ├── 1403_Minimum_Subsequence_in_Non-Increasing_Order.cpp

    ├── 1408_String_Matching_in_an_Array.cpp

    ├── 1437_Check_If_All_1s_Are_at_Least_Length_K_Places_Away.cpp

    ├── 1441_Build_an_Array_With_Stack_Operations.cpp

    ├── 1446_Consecutive_Characters.cpp

    ├── 1455_Check_If_a_Word_Occurs_As_a_Prefix_of_Any_Word_in_a_Sentence.cpp

    ├── 145_Binary_Tree_Postorder_Traversal.cpp

    ├── 1491_Average_Salary_Excluding_the_Minimum_and_Maximum_Salary.cpp

    ├── 14_Longest_Common_Prefix.cpp

    ├── 1502_Can_Make_Arithmetic_Progression_From_Sequence.cpp

    ├── 1512_Number_of_Good_Pairs.cpp

    ├── 1518_Water_Bottles.cpp

    ├── 151_Reverse_Words_in_a_String.cpp

    ├── 1523_Count_Odd_Numbers_in_an_Interval_Range.cpp

    ├── 1539_Kth_Missing_Positive_Number.cpp

    ├── 1550_Three_Consecutive_Odds.cpp

    ├── 1572_Matrix_Diagonal_Sum.cpp

    ├── 1582_Special_Positions_in_a_Binary_Matrix.cpp

    ├── 1598_Crawler_Log_Folder.cpp

    ├── 1619_Mean_of_Array_After_Removing_Some_Elements.cpp

    ├── 1629_Slowest_Key.cpp

    ├── 1636_Sort_Array_by_Increasing_Frequency.cpp

    ├── 1652_Defuse_the_Bomb.cpp

    ├── 1678_Goal_Parser_Interpretation.cpp

    ├── 167_Two_Sum_II_Input_Array_Is_Sorted.cpp

    ├── 169_Majority_Element.cpp

    ├── 1710_Maximum_Units_on_a_Truck.cpp

    ├── 1716_Calculate_Money_in_Leetcode_Bank.cpp

    ├── 171_Excel_Sheet_Column_Number.cpp

    ├── 1768_Merge_Strings_Alternately.cpp

    ├── 1769_Minimum_Number_of_Operations_to_Move_All_Balls_to_Each_Box.cpp

    ├── 1779_Find_Nearest_Point_That_Has_the_Same_X_or_Y_Coordinate.cpp

    ├── 1790_Check_if_One_String_Swap_Can_Make_Strings_Equal.cpp

    ├── 1822_Sign_of_the_Product_of_an_Array.cpp

    ├── 1848_Minimum_Distance_to_the_Target_Element.cpp

    ├── 1869_Longer_Contiguous_Segments_of_Ones_than_Zeros.cpp

    ├── 1876_Substrings_of_Size_Three_with_Distinct_Characters.cpp

    ├── 1877_Minimize_Maximum_Pair_Sum_in_Array.cpp

    ├── 1880_Check_if_Word_Equals_Summation_of_Two_Words.cpp

    ├── 1903_Largest_Odd_Number_in_String.cpp

    ├── 191_Number_of_1_Bits.cpp

    ├── 1935_Maximum_Number_of_Words_You_Can_Type.cpp

    ├── 1952_Three_Divisors.cpp

    ├── 1974_Minimum_Time_to_Type_Word_Using_Special_Typewriter.cpp

    ├── 1_Two_Sum.cpp

    ├── 2016_Maximum_Difference_Between_Increasing_Elements.cpp

    ├── 2022_Convert_1D_Array_Into_2D_Array.cpp

    ├── 202_Happy_Number.cpp

    ├── 2042_Check_if_Numbers_Are_Ascending_in_a_Sentence.cpp

    ├── 2068_Check_Whether_Two_Strings_are_Almost_Equivalent.cpp

    ├── 206_Reverse_Linked_List.cpp

    ├── 2073_Time_Needed_to_Buy_Tickets.cpp

    ├── 2078_Two_Furthest_Houses_With_Different_Colors.cpp

    ├── 2085_Count_Common_Words_With_One_Occurrence.cpp

    ├── 2108_Find_First_Palindromic_String_in_the_Array.cpp

    ├── 2129_Capitalize_the_Title.cpp

    ├── 2138_Divide_a_String_Into_Groups_of_Size_k.cpp

    ├── 2144_Minimum_Cost_of_Buying_Candies_With_Discount.cpp

    ├── 2149_Rearrange_Array_Elements_by_Sign.cpp

    ├── 2160_Minimum_Sum_of_Four_Digit_Number_After_Splitting_Digits.cpp

    ├── 2164_Sort_Even_and_Odd_Indices_Independently.cpp

    ├── 2165_Smallest_Value_of_the_Rearranged_Number.cpp

    ├── 2176_Count_Equal_and_Divisible_Pairs_in_an_Array.cpp

    ├── 217_Contains_Duplicate.cpp

    ├── 2180_Count_Integers_With_Even_Digit_Sum.cpp

    ├── 2224_Minimum_Number_of_Operations_to_Convert_Time.cpp

    ├── 2243_Calculate_Digit_Sum_of_a_String.cpp

    ├── 2248_Intersection_of_Multiple_Arrays.cpp

    ├── 2264_Largest_3-Same-Digit_Number_in_String.cpp

    ├── 2269_Find_the_K-Beauty_of_a_Number.cpp

    ├── 2287_Rearrange_Characters_to_Make_Target_String.cpp

    ├── 2293_Min_Max_Game.cpp

    ├── 2299_Strong_Password_Checker_II.cpp

    ├── 22_Generate_Parentheses.cpp

    ├── 2319_Check_if_Matrix_Is_X-Matrix.cpp

    ├── 232_Implement_Queue_using_Stacks.cpp

    ├── 2347_Best_Poker_Hand.cpp

    ├── 238_Product_of_Array_Except_Self.cpp

    ├── 242_Valid_Anagram.cpp

    ├── 2451_Odd_String_Difference.cpp

    ├── 2455_Average_Value_of_Even_Numbers_That_Are_Divisible_by_Three.cpp

    ├── 2465_Number_of_Distinct_Averages.cpp

    ├── 2490_Circular_Sentence.cpp

    ├── 2520_Count_the_Digits_That_Divide_a_Number.cpp

    ├── 2558_Take_Gifts_From_the_Richest_Pile.cpp

    ├── 258_Add_Digits.cpp

    ├── 2600_K_Items_With_the_Maximum_Sum.cpp

    ├── 268_Missing_Number.cpp

    ├── 27_Remove_Element.cpp

    ├── 283_Move_Zeroes.cpp

    ├── 303_Range_Sum_Query-Immutable.cpp

    ├── 349_Intersection_of_Two_Arrays.cpp

    ├── 383_Ransom_Note.cpp

    ├── 387_First_Unique_Character_in_a_String.cpp

    ├── 389_Find_the_Difference.cpp

    ├── 392_Is_Subsequence.cpp

    ├── 415_Add_Strings.cpp

    ├── 41_First_Missing_Positive.cpp

    ├── 43_Multiply_Strings.cpp

    ├── 443_String_Compression.cpp

    ├── 461_Hamming_Distance.cpp

    ├── 476_Number_Complement.cpp

    ├── 496_Next_Greater_Element_I.cpp

    ├── 500_Keyboard_Row.cpp

    ├── 504_Base_7.cpp

    ├── 506_Relative_Ranks.cpp

    ├── 509_Fibonacci_Number.cpp

    ├── 50_Pow-x,n-.cpp

    ├── 520_Detect_Capital.cpp

    ├── 566_Reshape_the_Matrix.cpp

    ├── 605_Can_Place_Flowers.cpp

    ├── 606_Construct_String_from_Binary_Tree.cpp

    ├── 66_Plus_One.cpp

    ├── 67_Add_Binary.cpp

    ├── 682_Baseball_Game.cpp

    ├── 693_Binary_Number_with_Alternating_Bits.cpp

    ├── 69_SqrtX.cpp

    ├── 766_Toeplitz_Matrix.cpp

    ├── 771_Jewels_and_Stones.cpp

    ├── 806_Number_of_Lines_To_Write_String.cpp

    ├── 821_Shortest_Distance_to_a_Character.cpp

    ├── 824_Goat_Latin.cpp

    ├── 852_Peak_Index_in_a_Mountain_Array.cpp

    ├── 867_Transpose_Matrix.cpp

    ├── 876_Middle_of_the_Linked_List.cpp

    ├── 884_Uncommon_Words_from_Two_Sentences.cpp

    ├── 888_Fair_Candy_Swap.cpp

    ├── 88_Merge_Sorted_Array.cpp

    ├── 896_Monotonic_Array.cpp

    ├── 908_Smallest_Range_I.cpp

    ├── 917_Reverse_Only_Letters.cpp

    ├── 922_Sort_Array_By_Parity_II.cpp

    ├── 929_Unique_Email_Addresses.cpp

    ├── 944_Delete_Columns_to_Make_Sorted.cpp

    ├── 965_Univalued_Binary_Tree.cpp

    ├── 976_Largest_Perimeter_Triangle.cpp

    ├── 977_Squares_of_a_Sorted_Array.cpp

    ├── 989_Add_to_Array-Form_of_Integer.cpp

    └── 999_Available_Captures_for_Rook.cpp

Files Content

================================================
FILE: 1030_Matrix_Cells_in_Distance_Order.cpp
================================================
class Solution {
public:
    vector<vector<int>> allCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
        multimap<int, vector<int>> dist;
        vector<vector<int>> ret;
        ret.reserve(rows*cols);
        vector<int> coor = {0, 0};
        int d;
        
        for(int i=0; i<rows; i++)
            for(int j=0; j<cols; j++){
                d = abs(rCenter-i)+abs(j-cCenter);
                coor[0] = i;
                coor[1]= j;
                dist.insert(make_pair(d,coor));
            }
        
        for(auto& it : dist){
           ret.emplace_back(it.second);
        }
        return ret;
    }
};


================================================
FILE: 1046_Last_Stone_Weight.cpp
================================================
class Solution {
public:
    int lastStoneWeight(vector<int>& stones) {
        while(stones.size()>1){        
            sort(stones.begin(), stones.end(), greater<int>());
            stones[1] = (stones[0]-stones[1]);
            stones.erase(stones.begin());
        }
        return stones[0];
    }
};


================================================
FILE: 1047_Remove_All_Adjacent_Duplicates_In_String.cpp
================================================
class Solution {
public:
    string removeDuplicates(string s) {
      string ret = "";
        for (char& c: s) {
            if (ret.size() != 0 && ret.back() == c)
                ret.pop_back();
            else
                ret.push_back(c);
        }
        return ret;
    }
};


================================================
FILE: 1103_Distribute_Candies_to_People.cpp
================================================
class Solution {
public:
    vector<int> distributeCandies(int candies, int num_people) {
        vector<int> ret(num_people);
        int can{1}, i{0}, cum{0};
        while(candies>can){
            if(i!=num_people){
                ret[i++]+=can; 
                candies-=can;
                can++;
            }
            else i=0;
        }
        if(i==num_people) 
            i=0;
        if(candies)
            ret[i]+=candies-cum;
        return ret;
    }
};


================================================
FILE: 1122_Relative_Sort_Array.cpp
================================================
class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        map<int, int> map;
        for(const int& n : arr1)
            map[n]++;
        
        int ix=0;
        for(const int& n2 : arr2){
            for(int i=0; i<map[n2]; i++)
                arr1[ix++]=n2;
            map.erase(n2);
        }
        
       for(const auto& [key, value] : map){
           for(int i=0; i<value; i++)
               arr1[ix++]=key;
       }
        
        return arr1;
    }
};


================================================
FILE: 1137_N-th_Tribonacci_Number.cpp
================================================
class Solution {
public:
    int tribonacci(int n) {
        if(n<3)
            return n!=0 ? 1 : 0;
        int t0=0, t1=1, t2=1, ret=0;
        for(int i=2; i<n; i++){
            ret=t0+t1+t2;
            t0=t1;
            t1=t2;
            t2=ret;
        }
        return ret;
    }
};


================================================
FILE: 1189_Maximum_Number_of_Balloons.cpp
================================================
class Solution {
public:
    int maxNumberOfBalloons(string t) {
        int ban;
        int lo; 
        unordered_map<char, int> umap;
        for(int i=0; i<t.size(); i++){
            if(t[i]=='b' || t[i]=='a' || t[i]=='l' || t[i]=='o' || t[i]=='n')
                umap[t[i]]+=1;
        }
        ban = umap['b'] < umap['a'] ? umap['b'] : umap['a'];
        if(umap['n'] < ban)
            ban = umap['n'];
        lo = (umap['l'] < umap['o'] ? umap['l'] : umap['o'])/2;
        
        return ban < lo ? ban : lo;
    }
};


================================================
FILE: 118_Pascals_Triangle.cpp
================================================
class Solution {
public:
   vector<vector<int>> generate(int numRows) {
        vector<vector<int>> ret;
       ret.reserve(numRows);
        for(int i=0; i<numRows; i++){
            vector<int> nums;
            nums.reserve(i+1);
            for(int j=0;j<i+1;j++){
                if(j==0|| j==i){
                    nums.emplace_back(1);
                }
                else
                    nums.emplace_back(ret[i-1][j-1]+ret[i-1][j]);
            }
            ret.emplace_back(nums);
        }
        return ret;
    }
};


================================================
FILE: 11_Container_With_Most_Water.cpp
================================================
class Solution {
public:
    int maxArea(vector<int>& height) {
        int ret{}, tmp{};
        int fi{}, li=height.size()-1;

        while(fi<li){
            tmp = (li-fi)*min(height[fi], height[li]);
            if(tmp>ret)
                ret=tmp;
            if(height[fi]<height[li])
                fi++;
            else li--;
        }

        return ret;
    }
};


================================================
FILE: 1200_Minimum_Absolute_Difference.cpp
================================================
class Solution {
public:
    vector<vector<int>> minimumAbsDifference(vector<int>& arr) {
        vector<vector<int>> ret;
        sort(arr.begin(), arr.end());
        int min=abs(arr[1]-arr[0]);
        ret.push_back({arr[0],arr[1]});
        for(int i=1; i<arr.size()-1; i++){
            if(abs(arr[i+1]-arr[i]) > min){
                continue;
            }
            else if(abs(arr[i+1]-arr[i])==min){
                ret.push_back({arr[i],arr[i+1]});  
            }
            else {
                min=abs(arr[i+1]-arr[i]);
                ret.clear();        
                ret.push_back({arr[i],arr[i+1]});        
            }
        }
        return ret;
    }
};


================================================
FILE: 121_Best_Time_to_Buy_and_Sell_Stock.cpp
================================================
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int min=100000, max=-1, ret=0;
        for(int& i : prices){
            if(i<min){
                min=i;
                max=-1;
            }
            else if(max<i){
                max=i;
                if(i-min>ret)
                    ret = i-min;
            }
        }
        return ret;
    }
};


================================================
FILE: 122_Best_Time_to_Buy_and_Sell_Stock_II.cpp
================================================
class Solution {
    public int maxProfit(int[] p) {
        int min=100000, max=-1, ret=0, tmp=0, size=p.length;
        for(int i=0; i<size; i++){
            if(p[i]<min){
                min=p[i];
                max=-1;
            }
            if(max<p[i]){
                max=p[i];
                tmp=max-min;
                while(i<size-1 && p[i+1]>p[i])
                    i++;
                if(p[i]-min> tmp)
                    tmp=p[i]-min;
                
                ret+=tmp;
                tmp=0;
                min=100000;
            }
        }
        if(tmp!=0) ret+=tmp;
        return ret;
    }
}


================================================
FILE: 125_Valid_Palindrome.cpp
================================================
class Solution {
public:
    bool isPalindrome(string s) {
        int i{}, j=s.size()-1;

        while(i < j){
           if(!isalnum(s[i])) i++;
           else if(!isalnum(s[j])) j--;
           else if(tolower(s[i++])!=tolower(s[j--]))
            return 0;
        }

        return 1;
    }
};


================================================
FILE: 1281_Subtract_the_Product_and_Sum_of_Digits_of_an_Integer.cpp
================================================
class Solution {
public:
    int subtractProductAndSum(int n) {
        int mul=1, sum=0, tmp;
        while(n>0){
            tmp=n%10;
            n/=10;
            mul*=tmp;
            sum+=tmp;
        }
        return mul-sum;
    }
};


================================================
FILE: 1287_Element_Appearing_More_Than_25%_In_Sorted_Array.cpp
================================================
class Solution {
public:
    int findSpecialInteger(vector<int>& arr) {
        int size=arr.size(), percent= size/4;
        for(int i=0; i<size-percent; i++)
            if(arr[i]==arr[i+percent])
                return arr[i];
        return -1;
    }
};


================================================
FILE: 1331_Rank_Transform_of_an_Array.cpp
================================================
class Solution {
public:
    vector<int> arrayRankTransform(vector<int>& arr) {
        int size = arr.size(), ix=1;
        if(size==0) return {};
        vector<int> temp(arr);
        sort(arr.begin(), arr.end());
        unordered_map<int, int> um;
        um[arr[0]]=ix;
        for(int i=1; i<size; i++)
            if(arr[i-1]<arr[i])
                um[arr[i]]=++ix;
            else um[arr[i]]=ix;
        ix=0;
        while(ix<size){
            arr[ix]= um[temp[ix]];
            ix++;
        }
        return arr;
    }
};


================================================
FILE: 1332_Remove_Palindromic_Subsequences.cpp
================================================
class Solution {
public:
    int removePalindromeSub(string s) {
        string t=s;
        std::reverse(t.begin(),t.end());
        if(t==s) return 1;
        return 2;
        
    }
};


================================================
FILE: 1337_The_K_Weakest_Rows_in_a_Matrix.cpp
================================================
class Solution {
public:
    vector<int> kWeakestRows(vector<vector<int>>& mat, int k) {      
        vector<int> ret;
        std::multimap<vector<int>, int> map;
        int ix = 0;
        for(vector<int>& v : mat) {
            map.insert(make_pair(v, ix++));           
        }
        
        for(auto& a : map){
            ret.push_back(a.second);
            if(--k<1) break;
        }      
        return ret;
        
    }
};


================================================
FILE: 1356_Sort_Integers_by_The_Number_of_1_Bits.cpp
================================================
class Solution {
public:
    vector<int> sortByBits(vector<int>& arr) {
        int bitCount=0;
        sort(arr.begin(), arr.end());
        multimap<char, int> m;
        for(int& num : arr){
            bitCalculate(num, bitCount);
            m.insert({bitCount, num});
        }
        bitCount=0;
        for(auto it=m.begin(); it!=m.end(); ++it)
            arr[bitCount++]=it->second;
        return arr;
    }
    void bitCalculate(int num, int& bitCount){
        bitCount=0;
        while(num){
            if(num&1) bitCount++;
            num>>=1;
        }
    }
};


================================================
FILE: 136_Single_Number.cpp
================================================
class Solution {
public:
    int singleNumber(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        for(int i=1; i<nums.size(); i+=2){
            if(nums[i-1]!=nums[i]){
                return nums[i-1];
            }
        }
        return nums[nums.size()-1];
    }
};


================================================
FILE: 13_Roman_to_Integer.cpp
================================================
class Solution {
public:
    int romanToInt(string s) {
        int ret=0;
        unordered_map<char, int> romans;
        romans['I'] = 1;
        romans['V'] = 5;
        romans['X'] = 10;
        romans['L'] = 50;
        romans['C'] = 100;
        romans['D'] = 500;
        romans['M'] = 1000;
        
        for(int i=0; i<s.size(); i++){
            if(romans[s[i+1]] > romans[s[i]]){
                ret+= romans[s[i+1]] - romans[s[i]];
                i++;
            }      
            else{
                ret+=romans[s[i]];
            }
        }
        return ret;
    }
};


================================================
FILE: 1403_Minimum_Subsequence_in_Non-Increasing_Order.cpp
================================================
class Solution {
public:
    vector<int> minSubsequence(vector<int>& nums) {
        vector<int> ret;
        int i, j, sum=0, tmp;
        std::sort(nums.begin(), nums.end(), std::greater<int>());
        for (i = 0; i< nums.size(); i++){
            ret.push_back(nums[i]);
            sum += nums[i];
            tmp = 0;
            for (j = i +1; j< nums.size(); j++){
                tmp += nums[j];
                if(tmp > sum)
                    break;
            }
            if (sum > tmp) break;
        }     
        return ret;       
    }
};


================================================
FILE: 1408_String_Matching_in_an_Array.cpp
================================================
class Solution {
public:
    vector<string> stringMatching(vector<string>& words) {
        vector<string> ret;
        int f, l, size=words.size(), c;
        for(int i=0; i<size; i++){
            f = i-1;
            l = i+1;
            c=0;
            while(c++ < size) {
                if(f > -1 && words[f--].find(words[i])!=-1) {
                    ret.push_back(words[i]);
                    break;
                }
                if(l < size && words[l++].find(words[i])!=-1) {
                    ret.push_back(words[i]);
                    break;
                }
            }
        }
        return ret;
    }
};



================================================
FILE: 1437_Check_If_All_1s_Are_at_Least_Length_K_Places_Away.cpp
================================================
class Solution {
public:
    bool kLengthApart(vector<int>& nums, int k) {
        int count=k, ix=0;
        for(int i=0; i<nums.size(); i++){
            if(nums[i]!=1){
               ++count;
            }
            else {
              if(count<k){
                return 0;
              }
              count = 0;
            }
        }
        return 1;
    }
};


================================================
FILE: 1441_Build_an_Array_With_Stack_Operations.cpp
================================================
class Solution {
public:
    vector<string> buildArray(vector<int>& target, int n) {
        vector<string> ret;
        int i=0, counter=1;
        while(i<target.size()){
            if(target[i++]==counter++){
                ret.push_back("Push");
            }
            else{
                ret.push_back("Push");
                ret.push_back("Pop");
                i--;
            }
           
        }
        return ret;
    }
};


================================================
FILE: 1446_Consecutive_Characters.cpp
================================================
class Solution {
public:
    int maxPower(string s) {
        int ret= 1, cnt=1;
        for(int i=1; i<s.size(); i++){
            if(s[i-1]!=s[i]){
                if(cnt>ret) ret=cnt;
                cnt=1;
            }
            else cnt++;
        }
         if(ret < cnt)
            ret = cnt;
        return ret;
    }
};


================================================
FILE: 1455_Check_If_a_Word_Occurs_As_a_Prefix_of_Any_Word_in_a_Sentence.cpp
================================================
class Solution {
public:
    int isPrefixOfWord(string sentence, string searchWord) {
        int ret=1, i=0, s1 = sentence.size()+1, s2 = searchWord.size();
        while(i+s2<s1){
            if(string_view(sentence.c_str()+i, s2)==searchWord)
                return ret;       
            while(sentence[i++]!=32 && i<s1);   
            ret++;
        }
        return -1;
    }
};


================================================
FILE: 145_Binary_Tree_Postorder_Traversal.cpp
================================================
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

class Solution {
    private:
    vector<int> v;

    public:
    vector<int> postorderTraversal(TreeNode* root) {
        if(root!=NULL){
            postorderTraversal(root->left);
            postorderTraversal(root->right);
            v.push_back(root->val);
        }
        return v;
    }
};


================================================
FILE: 1491_Average_Salary_Excluding_the_Minimum_and_Maximum_Salary.cpp
================================================
class Solution {
    public double average(int[] salaries) {
        int size = salaries.length-2;
        int max=-1, min=1000000;
        double sum=0;
        for(int salary : salaries){
            sum+=salary;
            if(salary>max) max=salary;
            if(salary<min) min=salary;
        }
        sum -= (min+max);
        return sum/size;
    }
}


================================================
FILE: 14_Longest_Common_Prefix.cpp
================================================
class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if(strs.empty())
            return "";
        for(int i=0; i<strs[0].size(); i++){
            char c = strs[0][i];
             for(int j=1; j<strs.size(); j++){
                 if(i==strs[j].size() || c!=strs[j][i])
                    return strs[0].substr(0,i);
             }
        }
        return strs[0];
    }
};


================================================
FILE: 1502_Can_Make_Arithmetic_Progression_From_Sequence.cpp
================================================
class Solution {
public:
    bool canMakeArithmeticProgression(vector<int>& arr) {
        sort(arr.begin(),arr.end());
        int d = arr[0]-arr[1];
        for(int i=1; i<arr.size()-1; i++){
            if(arr[i]-arr[i+1]!=d)
                return false;
        }
        return true;
    }
};


================================================
FILE: 1512_Number_of_Good_Pairs.cpp
================================================
class Solution {
public:
    int numIdenticalPairs(vector<int>& nums) {
        int ret{};
        vector<int> memorization(101, 0);
        for(size_t i{}; i<nums.size(); i++){
            ret+=memorization[nums[i]];
            memorization[nums[i]]++;
        }
        return ret;
    }
};


================================================
FILE: 1518_Water_Bottles.cpp
================================================
class Solution {
public:
    int numWaterBottles(int numBottles, int numExchange) {
        int drink=numBottles, emptyBottles=numBottles, t=0;
        while(emptyBottles>=numExchange){
            drink+=emptyBottles/numExchange;
            t=emptyBottles%numExchange;
            emptyBottles/=numExchange;
            emptyBottles+=t;
        }
        return drink;
    }
};


================================================
FILE: 151_Reverse_Words_in_a_String.cpp
================================================
class Solution {
public:
    string reverseWords(string s) {
        string ret{};
        int fi=s.size()-1, li=s.size()-1;

        while(fi>-1){
            while(fi >-1 && s[fi]==' ') fi--;
            li=fi;

            while(fi >-1 && s[fi]!=' ') fi--;

            if(string_view(s.data() + fi+1, li-fi) != "")
                ret+=s.substr( fi+1, li-fi)+" ";

            fi--;
        }
        
        return ret.substr(0, ret.size()-1);   
    }
};


================================================
FILE: 1523_Count_Odd_Numbers_in_an_Interval_Range.cpp
================================================
class Solution {
public:
    int countOdds(int low, int high) {
        if(low%2!=1) low++;
        if(high%2!=1) high--;
        return (high-low)/2+1;
    }
};


================================================
FILE: 1539_Kth_Missing_Positive_Number.cpp
================================================
class Solution {
public:
    int findKthPositive(vector<int>& arr, int k) {
        int misCount=0, ix=0;
        for(int i=1; i<arr[arr.size()-1]; i++){
            if(arr[ix]==i)
                ix++;
            else misCount++;

            if(misCount==k)
                return i;
        }
        return arr.back()+ (k-misCount);
    }
};


================================================
FILE: 1550_Three_Consecutive_Odds.cpp
================================================
class Solution {
public:
    bool threeConsecutiveOdds(vector<int>& arr) {
        int size=arr.size()-1, i=0, j=size, c1=0, c2=0;
        while(i<size || j>-1){
            if(arr[i]!=1)
                if(arr[i]%2!=0)
                    c1++;
                else c1=0;
            else c1++;
            if(arr[j]!=1)
                if(arr[j]%2!=0)
                    c2++;
                else c2=0;
            else c2++;
            if(c1==3 || c2==3)
                return 1;
            i++;
            j--;
        }
        return 0;
    }
};


================================================
FILE: 1572_Matrix_Diagonal_Sum.cpp
================================================
class Solution {
public:
    int diagonalSum(vector<vector<int>>& mat) {
        ios_base::sync_with_stdio(false);
        cin.tie(NULL);
        int str=0, fns=mat[0].size()-1;
        int ret=0;
        for(int i=0; i<mat.size(); i++){
            ret+=mat[i][str++]+mat[i][fns--];
        }
        if(mat.size()%2!=0)
            ret-=mat[mat.size()/2][mat[0].size()/2];
        return ret;
    }
};


================================================
FILE: 1582_Special_Positions_in_a_Binary_Matrix.cpp
================================================
class Solution {
public:
    int numSpecial(vector<vector<int>>& mat) {
        int ret=0, x;
        bool isOk=true;
        for(int i=0; i<mat.size(); i++){
            for(int j=0; j<mat[0].size(); j++){
                if(mat[i][j]==1){
                    isOk=true;
                    x=j+1;
                    while(x<mat[0].size())
                        if(mat[i][x++]==1){
                            isOk=false;
                            break;
                        }
                        
                    if(!isOk) break;
                        
                    x=j-1;
                    while(x>-1)
                        if(mat[i][x--]==1){
                            isOk=false;
                            break;
                        }
                        
                    if(!isOk) break;
                        
                    x=i+1;
                    while(x<mat.size())
                        if(mat[x++][j]==1){
                            isOk=false;
                            break;
                        }
                        
                    if(!isOk) break;
                        
                    x=i-1;
                    while(x>-1)
                        if(mat[x--][j]==1){
                            isOk=false;
                            break;
                        }
                        
                    if(!isOk) break;
                        
                    ret++;
                }
                if(ret==mat.size()) break;
                
            } 
        } 
        return ret;
    }
};


================================================
FILE: 1598_Crawler_Log_Folder.cpp
================================================
class Solution {
public:
    int minOperations(vector<string>& logs) {
        int ret=0;
        for(string& s : logs){
            if(s[0]!=46)
                ret++;
            else if(s[1]==46)
                ret = ret != 0 ? --ret : 0;
        }
      return ret;  
    }
};


================================================
FILE: 1619_Mean_of_Array_After_Removing_Some_Elements.cpp
================================================
class Solution {
public:
    double trimMean(vector<int>& arr) {
        double sum = 0.0;
        int size = arr.size(), i = size*0.05, j = size-i-1;
        sort(arr.begin(), arr.end());
        while(i<j)
            sum+=arr[i++]+arr[j--]; 
        return sum/(size - size*0.1);
    }
};


================================================
FILE: 1629_Slowest_Key.cpp
================================================
class Solution {
public:
    char slowestKey(vector<int>& releaseTimes, string keysPressed) {
        int max=releaseTimes[0], tmp=releaseTimes[0], retIx=0;
        for(int i=1; i<releaseTimes.size(); i++) {
            tmp=releaseTimes[i]-releaseTimes[i-1];
            if(max<tmp){
                max=tmp;
                retIx=i;
            }
            else if(max==tmp){
                if(keysPressed[i]>keysPressed[retIx])
                    retIx=i;
            }
        }
        return keysPressed[retIx];
    }
};


================================================
FILE: 1636_Sort_Array_by_Increasing_Frequency.cpp
================================================
class Solution {
public:
    vector<int> frequencySort(vector<int>& nums) {
        map<int, int,  greater<int>> cMap;
        multimap<int, int> m;

        for(int& i : nums)
            cMap[i]++;    
        
        for(const auto& [key, value] : cMap)
            m.insert({value, key});
        
        int ix=0;
        for(auto& it : m){
            for(int i=0; i<it.first; i++){
                nums[ix++]=it.second;
            }
        }
        return nums;
    }
};


================================================
FILE: 1652_Defuse_the_Bomb.cpp
================================================
class Solution
{
public:
    vector<int> decrypt(vector<int>& code, int k)
    {
        int ix=0, size=code.size();
        vector<int> ret(size, 0);
        if (k == 0)
            return ret;
        else
        {
            for (int i = 0; i < size; i++)
            {
                ix = 0;
                if (k > 0)
                {
                    for (int j = i + 1; ix < k; j++)
                    {
                        if (j == size)
                            j = 0;
                        ret[i] += code[j];
                        ix++;
                    }
                }
                else if (k < 0)
                {
                    for (int j = i - 1; ix > k; j--)
                    {
                        if (j < 0)
                            j = size - 1;
                        ret[i] += code[j];
                        ix--;
                    }
                }
            }
        }
        return ret;
    }
};


================================================
FILE: 1678_Goal_Parser_Interpretation.cpp
================================================
class Solution {
public:
    string interpret(string command) {
        string ret;
        for(int i=0; i<command.size()-1; i++){
            if(command[i]=='(')
                if(command[i+1]!=')'){
                    ret+="al";
                    i+=3;
                }
                else {
                    ret+="o";
                    i+=1;
                }
            else ret+=command[i];
        }
        if(command[command.size()-1]!=')')
            ret+="G";
        return ret;
    }
};


================================================
FILE: 167_Two_Sum_II_Input_Array_Is_Sorted.cpp
================================================
class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int i{}, j=numbers.size()-1;

        while(i<j){
            if(numbers[i]+numbers[j]>target)
                j--;
            else if(numbers[i]+numbers[j]<target)
                i++;
            else return {++i, ++j};
        }
        return {};
    }
};


================================================
FILE: 169_Majority_Element.cpp
================================================
class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int leader = 0, vote = 0;
        for(int& i : nums) {
            if(vote == 0){
                leader = i;
                vote = 1;
            }
            else if(leader == i) vote++;
            else vote--;
        }
        return leader;
    }
};


================================================
FILE: 1710_Maximum_Units_on_a_Truck.cpp
================================================
class Solution {
public:
    int maximumUnits(vector<vector<int>>& boxTypes, int truckSize) {   
        sort(boxTypes.begin(), boxTypes.end(), [](const vector<int>& a, const vector<int>& b) {
            return a[1] > b[1];
        });
        int ret = 0;
        for(int i=0; i< boxTypes.size(); i++){
            
            if(truckSize > boxTypes[i][0]){
                ret += boxTypes[i][0] * boxTypes[i][1];
                truckSize-=boxTypes[i][0];
            }
            else{
                ret += truckSize * boxTypes[i][1];
                break;
            }
        }
        return ret; 
    }
};


================================================
FILE: 1716_Calculate_Money_in_Leetcode_Bank.cpp
================================================
class Solution {
public:
    int totalMoney(int n) {
        int i=0, ret=0;
        
        for(; i<n/7; i++)
            ret+=(28+(7*i));
        
        for(int j=1; j<=n%7; j++)
            ret+=(j+i);
        
        return ret;
    }
};


================================================
FILE: 171_Excel_Sheet_Column_Number.cpp
================================================
class Solution {
    public int titleToNumber(String columnTitle) {
        int digit = columnTitle.length(), ret=0, p;
        for(int i=0; i<digit; i++){
            p=digit-i-1;
            ret+= Math.pow(26,p)*(columnTitle.charAt(i)-64);
        }
        return ret;
    }
}


================================================
FILE: 1768_Merge_Strings_Alternately.cpp
================================================
class Solution {
public:
    string mergeAlternately(string word1, string word2) {
        int mx= max(word1.length(), word2.length());
        int mn= min(word1.length(), word2.length());
        int i=0;
        string ret;
        while(i<mn){
            ret+=word1[i];
            ret+=word2[i++];
        }
        string* ptr = word1.length() > word2.length()? &word1 : &word2;
        while(i<mx){
            ret+= (*ptr)[i++];
        }
       return ret; 
    }
};


================================================
FILE: 1769_Minimum_Number_of_Operations_to_Move_All_Balls_to_Each_Box.cpp
================================================
class Solution {
public:
    vector<int> minOperations(string boxes) {
        int total = 0;
        vector<int> ret(boxes.size(), 0);
        for(int i=0; i<boxes.size(); i++){
            if(boxes[i]=='1'){
                total++;
                ret[0] += i;
            }
        }
        int left = 0, right = total;
        if(boxes[0]=='1'){right--; left++;}
        for(int i=1; i<boxes.size(); i++){
            ret[i] = ret[i-1] - right + left;
            if(boxes[i]=='1'){right--; left++;}
        }
        return ret;
    }
};


================================================
FILE: 1779_Find_Nearest_Point_That_Has_the_Same_X_or_Y_Coordinate.cpp
================================================
class Solution {
public:
    int nearestValidPoint(int x, int y, vector<vector<int>>& points) {  
        int tmp=-1, ix=0;
        multimap<int, int> dist;
        for(const vector<int>& point : points){
            if(x==point[0] || y==point[1]){
                tmp=abs(x-point[0])+abs(y-point[1]);
                dist.insert({tmp, ix});       
            }
            ix++;
        }
        if(tmp==-1)
            return -1;
        return dist.begin()->second;        
    }
};


================================================
FILE: 1790_Check_if_One_String_Swap_Can_Make_Strings_Equal.cpp
================================================
class Solution {
public:
    bool areAlmostEqual(string s1, string s2) {
        if(s1.size()!=s2.size())
            return 0;
        int mis=0;
        vector<int> chars1(26);
        vector<int> chars2(26);

        for(int i=0; i<s1.size(); i++){
            if(s1[i]!=s2[i])
                mis++;
            chars1[s1[i]-'a']++;
            chars2[s2[i]-'a']++;
        }
        for(int i=0; i<26; i++){
            if(chars1[i]!=chars2[i])
                return 0;
        }
        return mis > 2? 0 : 1;
    }
};


================================================
FILE: 1822_Sign_of_the_Product_of_an_Array.cpp
================================================
class Solution {
public:
    int arraySign(vector<int>& nums) {
        int count=0;
        for(int i=0; i<nums.size(); i++){
            if(nums[i]<0 ){ count++; }
            else if(nums[i]==0){ return 0; }
        }
        
        if(count%2 != 0)
            return -1;    
        
        return 1;
    }
};


================================================
FILE: 1848_Minimum_Distance_to_the_Target_Element.cpp
================================================
class Solution {
public:
    int getMinDistance(vector<int>& nums, int target, int start) {
        int ret=1000;
        for(int i =0; i<nums.size(); i++){
            if(nums[i]==target){
                if(ret>abs(start-i))
                    ret=abs(start-i);
            }
        }
        return ret;
    }
};


================================================
FILE: 1869_Longer_Contiguous_Segments_of_Ones_than_Zeros.cpp
================================================
class Solution {
public:
    bool checkZeroOnes(string s) {
        int m1=0, m0=0, c1=0, c0=0;
        char bfr=s[0];
        for(int i=0; i<s.size(); i++){
            if(s[i]!='0'){
                c1++;
                if(c0>m0) m0=c0;
                c0=0;
            }
            else{
                c0++;
                if(c1>m1) m1=c1;
                c1=0;
            }
        }
        if(c0>m0) m0=c0;
        if(c1>m1) m1=c1;

        return m1 > m0 ? 1 : 0;
    }
};


================================================
FILE: 1876_Substrings_of_Size_Three_with_Distinct_Characters.cpp
================================================
class Solution {
public:
    int countGoodSubstrings(string s) {
        int ret=0;
        if(s.size()>2) {    
            for(int i=0; i<s.size()-2; i++){
                if(s[i] == s[i+1] || s[i] == s[i+2] || s[i+1] == s[i+2]) { continue; }
                ret++;     
            }
        }
        return ret;
        
    }
};


================================================
FILE: 1877_Minimize_Maximum_Pair_Sum_in_Array.cpp
================================================
class Solution {
public:
    int minPairSum(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int i=-1, j=nums.size(), ret=0;
        while(i<j){
            if(ret<nums[++i]+nums[--j])
                ret=nums[i]+nums[j];
        }
        return ret;
    }
};


================================================
FILE: 1880_Check_if_Word_Equals_Summation_of_Two_Words.cpp
================================================
bool isSumEqual(string firstWord, string secondWord, string targetWord) {
    return (convertNum(firstWord)+convertNum(secondWord)) == convertNum(targetWord);
}

int convertNum(string& word){      
    int ascii = 97, num=0;
    for (char& c : word)
        num = (num*10) + int(c)-ascii; 
    return num;
}


================================================
FILE: 1903_Largest_Odd_Number_in_String.cpp
================================================
class Solution {
public:
    string largestOddNumber(string num) {
        std::ios::sync_with_stdio(false);
        std::cin.tie(nullptr);
        int ix {};
        for(auto it = num.rbegin(); it!=num.rend(); it++){
            if((*it)%2!=0)
                break;
            else ix++; 
        }
        return num.substr(0, num.size()-ix);
    }
};


================================================
FILE: 191_Number_of_1_Bits.cpp
================================================
class Solution {
public:
    int hammingWeight(uint32_t n) {
        int ret=0;
        do{
            if(n&1)
                ret++;
        } while(n>>=1);
        return ret;
    }
};


================================================
FILE: 1935_Maximum_Number_of_Words_You_Can_Type.cpp
================================================
class Solution {
public:
    int canBeTypedWords(string text, string brokenLetters) {
        int ret = 0;
        bool isBroken;
        std::vector<string> words;
        std::vector<char> chars;
        split(words, text);
        for(char& b : brokenLetters)
            chars.push_back(b);
        
        for(string& w : words) {
            isBroken = false;
            for(char& s : w) {
                if (isBroken)
                    break;
                for(char& c : chars) {
                    if(c==s) {
                        ret++;
                        isBroken = true;
                        break;
                    }
                }
            }
        }
        return words.size()-ret;
    }
    void split(vector<string>& words, string& text){
        string tmp;
        for(int i=0; i<text.size(); i++){
            if(text[i] != ' ')
                tmp+=text[i];
            else{
                words.push_back(tmp);
                tmp="";
            }
        }
        words.push_back(tmp);
    }
};


================================================
FILE: 1952_Three_Divisors.cpp
================================================
class Solution {
public:
    bool isThree(int n) {
        int ret = 1;
        if(n<3) return 0;
        for(int i=2; i<n; i++){
            if(n%i==0){
                if(ret==0) return 0;
                ret--;
            }
        }
        return ret>0 ? 0 : 1;
    }
};


================================================
FILE: 1974_Minimum_Time_to_Type_Word_Using_Special_Typewriter.cpp
================================================
class Solution {
public:
    int minTimeToType(string word) {
        int ret=0, pointer=97, ascii;
        for(char& c : word){
            ascii = (int)c;
            if (abs(ascii - pointer) < 13){
                ret += abs(ascii - pointer);
            }
            else{
                if(ascii - pointer > 0)
                    ret += (pointer-97) + (123-ascii);
                else
                    ret += (ascii-97) + (123-pointer);
            }
            pointer = ascii;
            ret++;
        }
        return ret;
    }
};


================================================
FILE: 1_Two_Sum.cpp
================================================
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int diff, counter=0;
        vector<int> ret;
        ret.reserve(2);
        map<int, int> ix;
        
        for(int i = 0; i<nums.size(); i++){
            diff = target-nums[i];
            if(diff != nums[i]){
                ix[nums[i]] = (i+1);
                if(ix[nums[i]]>0 && ix[diff]>0){
                    ret.clear();
                    ret.emplace_back(i);
                    ret.emplace_back(ix[diff]-1);
                    return ret;
                }
            }
            else{
                ret.emplace_back(i);
                counter++;
                if(counter==2){
                    return ret;
                }
            }
        }
        
        return ret;
    }
};


================================================
FILE: 2016_Maximum_Difference_Between_Increasing_Elements.cpp
================================================
class Solution {
public:
    int maximumDifference(vector<int>& nums) {
        int min = INT_MAX, ret = -1;
        for(int i=0; i<nums.size(); i++){
            if(nums[i]<min){
                min=nums[i];
            }
            else{
                ret=max(ret,nums[i]-min);
            }
        }
        return ret > 0? ret : -1;
    }
};


================================================
FILE: 2022_Convert_1D_Array_Into_2D_Array.cpp
================================================
class Solution {
public:
    vector<vector<int>> construct2DArray(vector<int>& original, int m, int n) {
        vector<vector<int>> ret(m);
        if(m*n != original.size()){
            ret.resize(0);
            return ret;
        }
        for(int i=0; i<m; i++){
            ret[i].resize(n);
            for(int j=0; j<n; j++){
                ret[i][j]=original[j+ n*i];
            }
        }
        return ret;
    }
};


================================================
FILE: 202_Happy_Number.cpp
================================================
class Solution {
public:
    bool isHappy(int n) {
        int num=0, tmp;
        unordered_set<int> st;
        while(n!=1){
            num=0;
            while(n>0){
                tmp=n%10;
                num+=(tmp*tmp);
                n/=10;
            }
            n=num;
            if(!st.count(n))
                st.insert(n); 
            else return 0;
        }
        return 1;
    }
};


================================================
FILE: 2042_Check_if_Numbers_Are_Ascending_in_a_Sentence.cpp
================================================
class Solution {
public:
    bool areNumbersAscending(string s) {
        int tmp=0, before=-100, mx=1;
        for(char& c : s){
            if((int)c > 47 && (int)c < 58){
                if(tmp==-1){ tmp=0; }
                tmp = tmp*mx + c;
                mx *= 100;
            }
            if (tmp !=-1 && c==' '){     
                if(before >= tmp) { return false; }
                before=tmp;
                mx=1;
                tmp=-1;
            }    
        }
        if(before >= tmp && tmp !=-1){ return false; }
        return true;       
    }
};


================================================
FILE: 2068_Check_Whether_Two_Strings_are_Almost_Equivalent.cpp
================================================
class Solution {
public:
    bool checkAlmostEquivalent(string word1, string word2) {
        unordered_map<int, int> w;
        
        for(int i=0; i<word1.size(); i++) {
            w[word1[i]]++;
            w[word2[i]]--;
        }
        
        for(auto& it : w)
            if(it.second > 3 || it.second < -3)
                return false;
        
        return true;
    }
};


================================================
FILE: 206_Reverse_Linked_List.cpp
================================================
Class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* curr=head, *prev=NULL, *temp;
        while(curr!=NULL){
            temp=curr->next;
            curr->next=prev;
            prev=curr;
            curr=temp;   
        }
        return prev;
    }
};


================================================
FILE: 2073_Time_Needed_to_Buy_Tickets.cpp
================================================
class Solution {
public:
    int timeRequiredToBuy(vector<int>& tickets, int k) {
        int ret=k+1;
        for(int i=0; i<tickets.size(); i++)
            if(tickets[i]<tickets[k]){
                ret+= i<k ? tickets[i]-1: tickets[i];
            }
            else ret +=(tickets[k]-1);    
        return ret;
    }
};


================================================
FILE: 2078_Two_Furthest_Houses_With_Different_Colors.cpp
================================================
class Solution {
public:
    int maxDistance(vector<int>& colors) {
        int i=0, j=colors.size()-1, ti, tj;
        while(i<j){
            if(colors[i]!=colors[j]){
                break;
            }
            else{
                ti=i;
                tj=j;
                while(colors[++ti]==colors[i]);
                while(colors[--tj]==colors[i]);
                if((ti-i) < (j-tj)){
                    i=ti;
                }
                else{
                    j=tj;
                }
            }
        }
        return j-i;
    }
};


================================================
FILE: 2085_Count_Common_Words_With_One_Occurrence.cpp
================================================
class Solution {
public:
    int countWords(vector<string>& words1, vector<string>& words2) {
        int counter=0;
        unordered_map<string, int> map, map2;
        for(string& s1 : words1)
            map[s1]++;
        for(string& s2 : words2)
            map2[s2]++;
        for(auto& it1 : map){
            if(it1.second == 1){     
                for(auto& it2 : map2){
                    if(it2.second == 1)
                        if(it1.first == it2.first) counter++;
                }           
            }
        }
        return counter;
    }
};


================================================
FILE: 2108_Find_First_Palindromic_String_in_the_Array.cpp
================================================
class Solution {
public:
    string firstPalindrome(vector<string>& words) {
        ios_base::sync_with_stdio(false);
        cin.tie(NULL);
        for(string& word : words){
            if(isPalindromic(word))
                return word;
        }
        return "";
    }
    bool isPalindromic(string& s){
        int i=0, j=s.size()-1;
        while(i < j){
            if(s[i]!=s[j])
                return 0;
            i++;
            j--;
        }
        return 1;
    }
};


================================================
FILE: 2129_Capitalize_the_Title.cpp
================================================
class Solution {
public:
    string capitalizeTitle(string title) {
        bool isBfrSpace = 1;
        char i=0, cnt=0, c=1, size=(1+title.size());
        for(; i<size; i++){
            if(title[i]==32 || i==(size-1)){
                isBfrSpace=1;
                c=1;
                if(cnt<3){
                    while(i-c>-1 && title[i-c]!=32){
                        if(title[i-c] < 91)
                            title[i-c] += 32;
                        c++;
                    }
                }
                cnt=0;
            }
            else if(!isBfrSpace){ 
                if(title[i] < 91)
                    title[i]+=32;
                cnt++;
            }
            else{
                if(title[i] > 90)
                    title[i] -= 32;
                isBfrSpace = 0;
                cnt++;
            }
        }
        return title;
    }
};


================================================
FILE: 2138_Divide_a_String_Into_Groups_of_Size_k.cpp
================================================
class Solution {
public:
    vector<string> divideString(string s, int k, char fill) {
        int c=0, n=s.size(), group=n/k, i=0;
        vector<string> ret;
        ret.reserve(group+1);
        string tmp;
        
        for(; i<n; i++){
            if(c!=k){
                tmp+=s[i];
                c++;
            }
            else{
                ret.emplace_back(tmp);
                tmp.clear();
                i--;
                c=0;
            }
        }
        
        if(tmp.size()!=k) {
            i = tmp.size();
            for(; i<k; i++)
                tmp+=fill;
        }
            
         ret.emplace_back(tmp);
            
        return ret;
    }
};


================================================
FILE: 2144_Minimum_Cost_of_Buying_Candies_With_Discount.cpp
================================================
class Solution {
public:
    int minimumCost(vector<int>& cost) {
        priority_queue<int> pq;
        int candy;
        for(int& c : cost)
            pq.push(c);
        
        int ans = 0;
        while(pq.size())
        {
            candy = pq.top();
            pq.pop();
            ans+=candy;
            if(pq.size())
            {
                candy = pq.top();
                pq.pop();
                ans+=candy;
                if(pq.size())
                    pq.pop();
            }
        }
        return ans;
    }
};


================================================
FILE: 2149_Rearrange_Array_Elements_by_Sign.cpp
================================================
class Solution {
public:
    vector<int> rearrangeArray(vector<int>& nums) {
        vector<int> ret(nums.size());
        int p=0, n=1;
        for(int& i : nums)
            if(i < 0){
                ret[n]=i;
                n+=2;
            }
            else {
                ret[p]=i;
                p+=2;
            }
        return ret;
    }
};


================================================
FILE: 2160_Minimum_Sum_of_Four_Digit_Number_After_Splitting_Digits.cpp
================================================
class Solution {
public:
    int minimumSum(int num) {
        vector<int> v={num%10};
        
        while( num/=10){
            v.insert(lower_bound(v.begin(), v.end(), num%10), num%10);
        }   
        return (v[0]*10+v[3]) + (v[1]*10 +v[2]);
    }
};


================================================
FILE: 2164_Sort_Even_and_Odd_Indices_Independently.cpp
================================================
class Solution {
public:
    vector<int> sortEvenOdd(vector<int>& nums) {
        int es=2, os=3, size=nums.size(), i, j;
        if(size>1){
            vector<int> evens;
            evens.reserve(size/2);
            vector<int> odds;
            odds.reserve(size/2);
            for(i=0; i<size; i+=2){
                evens.emplace_back(nums[i]);
                odds.emplace_back(nums[i+1]);
            }
            if(i<size){
            odds.emplace_back(nums[i+1]);
            }
            sort(evens.begin(), evens.end());
            sort(odds.begin(), odds.end(), greater<int>());
        
            for(i=0, j=0; i<size; i+=2, j++){
                nums[i]=evens[j];
                nums[i+1]=odds[j];
            }
        }
        return nums;
    }
};


================================================
FILE: 2165_Smallest_Value_of_the_Rearranged_Number.cpp
================================================
class Solution {
public:
    long long smallestNumber(long long num) {
        vector<int> digits{};
        int ix{};

        while(num){
            digits.push_back(num%10);
            num/=10;
        }

        sort(digits.begin(), digits.end());

        if(!digits.empty() && digits[0]==0)
        {
            auto it = find_if(digits.begin(),digits.end(), [](const int& num){
                return num!=0;
            });

            num= *it;
            int dist=distance(digits.begin(), it);
            ix=1;

            while(dist--){
                num*=10;
                ix++;
            }
        }

        for(; ix<digits.size(); ++ix){
            num = num*10 + digits[ix];
        }
        
        return num;
    }
};


================================================
FILE: 2176_Count_Equal_and_Divisible_Pairs_in_an_Array.cpp
================================================
class Solution {
public:
    int countPairs(vector<int>& nums, int k) {
        int ret=0;
        for(int i=0; i<nums.size(); i++){
            for(int j=0; j<i; j++){
                if(nums[i]==nums[j] && i*j%k==0)
                    ret++;
            }
        }
        return ret;
    }
};


================================================
FILE: 217_Contains_Duplicate.cpp
================================================
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_map<int, char> um;
        for(int& n : nums)
            if(++um[n]> 1)
                return 1;
        return 0;
    }
};


================================================
FILE: 2180_Count_Integers_With_Even_Digit_Sum.cpp
================================================
class Solution {
public:
    int countEven(int num) {
        int ret=0, tmp, i;
        num++;
        for(int j=2; j<num; j++){
            i=j;
            tmp=0;
            while(i>9){
                tmp += i%10;
                i/=10;
            }
            tmp+=i;
            if(tmp%2==0)
                ret++;
        }
        return ret;
    }
};


================================================
FILE: 2224_Minimum_Number_of_Operations_to_Convert_Time.cpp
================================================
class Solution {
public:
    int convertTime(string current, string correct) {
        int ret=0, digit=1, cur=0, cor=0, hour=1, i;
        int t[] = {59,14,4,0};
        for(i = current.size()-1; i>-1; i--){
            if(58!=current[i]){
                cur += (current[i]-48)*digit*hour;
                cor += (correct[i]-48)*digit*hour;
                digit=10;
            }
            else {
                digit=1;
                hour=60;
            }
        }
        cor -= cur;
        i=0;
        while(cor>0){
            if(cor>t[i]){
                cor -= t[i]+1;
                ret++;
            }
            else i++;
        } 
        return ret;
    }
};


================================================
FILE: 2243_Calculate_Digit_Sum_of_a_String.cpp
================================================
class Solution {
public:
    string digitSum(string s, int k) {
        int t = k, sum=0, d=10, n;
        vector<int> vec;
        vector<char> ch;
        vec.reserve(s.size()/k+1);
      
        while(s.size()>k){
            
            for(char& c : s){
                sum+= (c-48);
                t--;
                if(t==0){
                    vec.emplace_back(sum);
                    sum=0;
                    t=k;
                }
            }
            
            if(s.size()%k!=0){
                vec.emplace_back(sum);
            }
            sum=0;
            t = k;
            s="";
            
            for(int& i : vec){
                if(i==0){
                    s+=48;
                    continue;
                }
                while(i>0)
                {
                    n=i%d;
                    ch.push_back((n+48));
                    i/=10;
                }
                for(int i=ch.size()-1; i>-1; i--){
                    s+=ch[i];
                }
                ch.clear();
            }
         
            vec.clear();
        }
        return s;
    }
};


================================================
FILE: 2248_Intersection_of_Multiple_Arrays.cpp
================================================
class Solution {
public:
    vector<int> intersection(vector<vector<int>>& nums) {
        vector<int> ret;
        unordered_map<int, int> c;
        for(vector<int>& v : nums)
            for(int& i : v)
                c[i]++;
        ret.reserve(c.size());
        for(auto& it : c)
            if(it.second==nums.size())
                ret.emplace_back(it.first);
        
        sort(ret.begin(), ret.end());
            
        return ret;
    }
};


================================================
FILE: 2264_Largest_3-Same-Digit_Number_in_String.cpp
================================================
class Solution {
public:
    string largestGoodInteger(string num) {
        string ret="";
        ret.reserve(3);
        char bfr=num[0];
        int count=0;
        for(int i=1; i<num.size(); i++){
            if(bfr!=num[i])
                count=0;
            else count++;
            if(count==2){
                if(ret[0]<num[i]){
                    ret.clear();
                    for(int j=0; j<3; j++)
                        ret+=num[i];
                }
                count=0;
            }
            bfr=num[i];
        }
        return ret;
    }
};


================================================
FILE: 2269_Find_the_K-Beauty_of_a_Number.cpp
================================================
class Solution {
public:
    int divisorSubstrings(int num, int k) {
        string s = to_string(num);
        int ret=0, size=s.size()-k+1;
        for(int i=0; i<size; i++){
            int div = stoi(s.substr(i,k));
            if(div && num%div==0)
                ret++;
        }
        return ret;
    }
};


================================================
FILE: 2287_Rearrange_Characters_to_Make_Target_String.cpp
================================================
class Solution {
public:
    int rearrangeCharacters(string s, string target) {
        vector<char> str(26,0);
        vector<char> trt(26,0);
        int ret=1000;
        for(char& c : s)
            str[c-'a']+=1;
        for(char& c : target)
            trt[c-'a']+=1;
        for(char& c : target){
           if(ret>(str[c-'a']/trt[c-'a'])){
                ret=(str[c-'a']/trt[c-'a']);
            }
        }
        return ret;
    }
};


================================================
FILE: 2293_Min_Max_Game.cpp
================================================
class Solution {
public:
    int minMaxGame(vector<int>& nums) {
        int ptr = 0, ix = 0, condition=nums.size();
        
        if(condition==1)
             return nums[0];
        if(condition==2)
            return min(nums[0], nums[1]);
        
        while(1){    
            nums[ptr++] = min(nums[ix++], nums[ix++]);
            nums[ptr++] = max(nums[ix++], nums[ix++]);      
            if(ix>condition-1){
                ptr=0;
                ix=0;
                condition/=2;
                if(condition<2)
                    return nums[0];
            }
        }
        return -1;
    }
};


================================================
FILE: 2299_Strong_Password_Checker_II.cpp
================================================
class Solution {
public:
    bool strongPasswordCheckerII(string password) {
        if(password.size()<8) return 0;
        
        bool l=0, u=0, d=0, s=0;
        char b =-1;
        for(const char& c : password){
            if(b==c) return 0;
            if(c>96 && c<123)
                l=1;
            else if(c>64 && c<91)
                u=1;
            else if(c>47 && c<58)
                d=1;
            else if((c>32 && c<48) || c=='^' || c=='@')
                s=1;
            b=c;
        }
        return (l && u && d && s);
    }
};


================================================
FILE: 22_Generate_Parentheses.cpp
================================================
class Solution {
public:
    vector<string> generateParenthesis(int num) {
        vector<string> ret;
        vector<char> prnt;
        prnt.reserve(num*2);
        backtrack(ret, prnt, 0, 0, num);
        return ret;
    }
    void backtrack(vector<string>& ret, vector<char> prnt, const int& left, const int& right, int& num){
        if(prnt.size()==num*2){
            string tmp;
            tmp.reserve(num*2);
            for(char& c : prnt){
                tmp+=c;
            }
            ret.push_back(tmp);
            return;
        }
        if(left<num){
            prnt.emplace_back('(');
            backtrack(ret, prnt, left+1, right, num);
            prnt.pop_back();
            
        }
        
        if(right<left){
            prnt.emplace_back(')');
            backtrack(ret, prnt, left, right+1, num);
            prnt.pop_back();
        }
    }
};


================================================
FILE: 2319_Check_if_Matrix_Is_X-Matrix.cpp
================================================
class Solution {
public:
    bool checkXMatrix(vector<vector<int>>& grid) {
        cin.tie(NULL);
        std::ios_base::sync_with_stdio(false);
        for(int i=0; i<grid.size(); i++){
            for(int j=0; j<grid.size(); j++){
                if(i+j==grid.size()-1 || i==j){
                    if(grid[i][j]==0)
                        return 0;
                }
                else if(grid[i][j]!=0)
                        return 0;
            }
        }
        return 1;
    }
};


================================================
FILE: 232_Implement_Queue_using_Stacks.cpp
================================================
class MyQueue {
private:
    stack<int> input;
    stack<int> output;
public:
    MyQueue() {
    }
    
    void push(int x) {
        input.push(x);
    }
    
    int pop() {
        if(output.empty())
            while(!input.empty()){
                output.push(input.top());
                input.pop();
            }
        int top = output.top();
        output.pop();
        return top;
    }
    
    int peek() {
        if(output.empty())
            while(!input.empty()){
                output.push(input.top());
                input.pop();
            }
        return output.top();
    }
    
    bool empty() {
        if(!output.empty() || !input.empty())
            return 0;
        
        return 1;
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */


================================================
FILE: 2347_Best_Poker_Hand.cpp
================================================
class Solution {
public:
    string bestHand(vector<int>& ranks, vector<char>& suits) {
        unordered_map<char, int> suit;
        unordered_map<int, int> rank;
        int s=0, r=0;
        for(int i=0; i<5; i++){
            suit[suits[i]]++;
            rank[ranks[i]]++;
        }
        for(auto it1=suit.begin(); it1!=suit.end(); ++it1){
            if(s < it1->second) s=it1->second;
        }

        if(s==5) return "Flush";

        for(auto it2=rank.begin(); it2!=rank.end(); ++it2){
            if(r < it2->second) r=it2->second;
        }
        if (r>2) return "Three of a Kind";
        else if (r>1) return "Pair";
        else return "High Card";
    }
};


================================================
FILE: 238_Product_of_Array_Except_Self.cpp
================================================
class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        vector<int> ret(nums.size(), 1);

        for(int i{}; i<nums.size()-1; i++)
            ret[i+1]=ret[i]*nums[i];

        int suffix{1};
        for(int i=nums.size()-1; i>0; i--){
            suffix*=nums[i];
            ret[i-1]*=suffix;
        }
        return ret;
    }
};


================================================
FILE: 242_Valid_Anagram.cpp
================================================
class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.length() != t.length()) return 0;
        vector<int> cntr(26,0);
        for(int i = 0; i < s.length(); i++) {
            cntr[s[i]-'a']++;
            cntr[t[i]-'a']--;
        }
        for(int& c : cntr)
            if(c!= 0) return 0;
        return 1;
    }
};


================================================
FILE: 2451_Odd_String_Difference.cpp
================================================
class Solution {
public:
    string oddString(vector<string>& words) {
        int wSize = words[0].size(), size=words.size(), i=0;
        unsigned int tmp=0, bfr=-1;
        for(; i<size; i++){
            for(int j=1; j<wSize; j++){
                tmp=(tmp*10)+((words[i][j])-(words[i][j-1]));
            }
            if(bfr!=-1) {
                if(bfr!=tmp){
                    break;
                }
            }
            else bfr=tmp;
            tmp=0;
        }
        if(i!=1)
            return words[i];

        tmp=0;
        for(int j=1; j<wSize; j++)
            tmp=(tmp*10)+((words[2][j])-(words[2][j-1]));
        if(bfr!=tmp) return words[0];
        return words[1];
    }
};


================================================
FILE: 2455_Average_Value_of_Even_Numbers_That_Are_Divisible_by_Three.cpp
================================================
class Solution {
    public int averageValue(int[] nums) {
        int count=0, sum=0;
        for(int n : nums){
            if(n%6==0){
                sum+=n;
                count++;
            }
        }
        return sum!=0 ? sum/count : sum;
    }
}


================================================
FILE: 2465_Number_of_Distinct_Averages.cpp
================================================
class Solution {
public:
    int distinctAverages(vector<int>& nums) {
        int i=0, j=nums.size()-1;
        unordered_set<int> averages;
        sort(nums.begin(), nums.end());
        while(i<j){
            averages.insert(nums[i++]+nums[j--]);
        }
        return averages.size();
    }
};


================================================
FILE: 2490_Circular_Sentence.cpp
================================================
class Solution {
public:
    bool isCircularSentence(string sentence) {
        size_t size=sentence.size()-1;
        for(int i{}; i<size; i++){
            while(i<size && sentence[i]!=' ') i++;
                if(sentence[i+1]!=NULL && sentence[i-1]!=sentence[i+1])
                    return 0;
        }
        return sentence[0]!=sentence[size] ? 0 : 1;
    }
};


================================================
FILE: 2520_Count_the_Digits_That_Divide_a_Number.cpp
================================================
class Solution {
public:
    int countDigits(int num) {
        int tmp {num}, ret{};
        while(tmp){
            if(num%(tmp%10)==0)
                ret++;
            tmp/=10;
        }
        return ret;
    }
};


================================================
FILE: 2558_Take_Gifts_From_the_Richest_Pile.cpp
================================================
class Solution 
{
public:
    long long pickGifts(vector<int>& gifts, int k) 
    {
        priority_queue<long long> pq;

        for(int& it : gifts)
            pq.push(it);

        long long ret=0, tmp;
        while(k--)
        {
            tmp = sqrt(pq.top());
            pq.pop();
            pq.push(tmp);
        }
            
        while(!pq.empty())
        {
            ret += pq.top();
            pq.pop();
        }
        return ret;
    }
};


================================================
FILE: 258_Add_Digits.cpp
================================================
class Solution {
    public int addDigits(int num) {
        int ret=0;
        while(num!=0){
            ret+=num%10;
            num/=10;
            if(num==0 && ret>9){
                num=ret;
                ret=0;
            }
        }
        return ret;
    }
}


================================================
FILE: 2600_K_Items_With_the_Maximum_Sum.cpp
================================================
class Solution {
public:
    int kItemsWithMaximumSum(int numOnes, int numZeros, int numNegOnes, int k) {
        int ret{};
        if(k<=numOnes) return k;
        else if(k<=numOnes+numZeros) return numOnes;
   
        return numOnes + (k-numZeros-numOnes)*-1;
    }
};


================================================
FILE: 268_Missing_Number.cpp
================================================
class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int size = nums.size();
        int sumOfNum=size*(size+1)/2;
        for(int& num : nums)
           sumOfNum-=num;
        return sumOfNum;
    }
};


================================================
FILE: 27_Remove_Element.cpp
================================================
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int j{};
        for (int i = 0; i < nums.size(); ++i) {
            if (nums[i] != val) {
                nums[j++] = std::move(nums[i]); 
            }
        }
        return j;
    }
};


================================================
FILE: 283_Move_Zeroes.cpp
================================================
class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int t;
        for (int ix = 0, i = 0; i < nums.size(); i++)
            if (nums[i] != 0) {
                t = nums[ix];
                nums[ix++]=nums[i];
                nums[i] = t;
            }
    }
};


================================================
FILE: 303_Range_Sum_Query-Immutable.cpp
================================================
class NumArray {
public:
    NumArray(vector<int>& nums) {
        sum.reserve(nums.size()+1);
        sum.emplace_back(0);
        for (int& n : nums)
            sum.emplace_back(sum.back() + n);
    }
    int sumRange(int left, int right) {
        return sum[right+1]-sum[left];
    }
private:
    vector<int> sum;
};


================================================
FILE: 349_Intersection_of_Two_Arrays.cpp
================================================
class Solution {
public:
    vector<int> setIntersection(unordered_set<int>& s1,unordered_set<int>& s2){
        vector<int> ret;
        ret.reserve(s1.size());
        for(const int& n : s1)
           for(const int& n2 : s2)
               if(n2==n){
                   ret.emplace_back(n);
                   s2.erase(n2);
                   break;
               }
        return ret;
    }
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> s1(nums1.begin(), nums1.end());
        unordered_set<int> s2(nums2.begin(), nums2.end());
        
        if(nums1.size()<nums2.size())
            return setIntersection(s1,s2);   
        
        return setIntersection(s2,s1);;
        
    }
};


================================================
FILE: 383_Ransom_Note.cpp
================================================
class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        vector<int> m(26);
        for(char& c: magazine)
            m[c-'a']++;
        for(char& c: ransomNote){
            if(m[c-'a']>0)
                m[c-'a']-=1;
            else return 0;
        }
        return 1;
    }
};


================================================
FILE: 387_First_Unique_Character_in_a_String.cpp
================================================
class Solution {
public:
    int firstUniqChar(string s) {
        int chars[26] = {0};
        for (int i = 0; i < s.size(); i++)
            chars[s[i]-'a']++;
        for (int i = 0; i < s.size(); i++)
            if (chars[s[i]-'a'] == 1) 
                return i;
        return -1;
    }
};


================================================
FILE: 389_Find_the_Difference.cpp
================================================
class Solution {
public:
    char findTheDifference(string s, string t) {
        int i=0, ss=0, st=0;
        for(; i<s.size(); i++){
            ss+=s[i];
            st+=t[i];
        }
        st+=t[i];
        return st-ss;
    }
};


================================================
FILE: 392_Is_Subsequence.cpp
================================================
class Solution {
public:
    bool isSubsequence(string s, string t) {
        int si{};

        for(int i{}; i<t.size(); i++){
            if(t[i]==s[si]){
                si++;
            }
        }
        return si==s.size();
    }
};


================================================
FILE: 415_Add_Strings.cpp
================================================
class Solution {
public:
    string addStrings(string num1, string num2) {
        string ret;
        if(num1.size() < num2.size())
            add(num2, num1, ret);
        else add(num1, num2, ret);

        reverse(ret.begin(), ret.end());
        return ret;
    }
    void add(const string& lng, const string& shrt, string& ret){
        int carry{}, lix=lng.size()-1;

        for(int six=shrt.size()-1; six>-1; six--){
            int digit = lng[lix--]+shrt[six]+r-96;
            ret+= ((digit%10)+48);
            carry = digit <10 ? 0 : digit/10;
        }
        
        while(lix>-1){
            int digit = lng[lix--]-48+r;
            ret+=((digit%10)+48);
            carry = digit <10 ? 0 : digit/10;
        }
        if(carry!=0)
            carry+=(r+48);
    }
};


================================================
FILE: 41_First_Missing_Positive.cpp
================================================
class Solution {
public:
    int firstMissingPositive(vector<int>& A) {
        
        std::sort(A.begin(), A.end());
 
        if(A[0]>1 or A[A.size()-1]<0)
            return 1;
        
        for(int i=0; i < A.size()-1; i++){
            if(A[i]<0 and A[i+1]>1){
                return 1;
            }
            
            if(abs(A[i+1])-abs(A[i]) > 1){
                return A[i]+1;
            }
        }
        return A[A.size()-1]+1;
    }
};


================================================
FILE: 43_Multiply_Strings.cpp
================================================
class Solution {
public:
    string multiply(string num1, string num2) {
        if (num1 == "0" || num2 == "0")
            return "0";

        int n = num1.size();
        int m = num2.size();
        vector<int> result(n + m, 0);

        for (int i = n - 1; i >-1; i--) {
            for (int j = m - 1; j >-1; j--) {
                int product = (num1[i] - 48) * (num2[j] - 48);
                int sum = product + result[i + j + 1];

                result[i + j + 1] = sum % 10;
                result[i + j] += sum / 10;
            }
        }

        string ret;
        ret.reserve(n+m);

        int ix = result[0]!=0 ? 0 : 1;
        while (ix<result.size()) {
            ret += (result[ix++] + 48);
        }

        return ret;
    }
};


================================================
FILE: 443_String_Compression.cpp
================================================
class Solution {
public:
    int compress(vector<char>& chars) {
        int i{}, ix{};
        while(i<chars.size()){
            const char c = chars[i];
            int counter{};

            while(i<chars.size() && chars[i]==c){
                counter++;
                ++i;
            }

            chars[ix++]=c;

            if(counter>1)
                for(const char& d : to_string(counter))
                    chars[ix++]=d;
        }
        return ix; 
    }
};


================================================
FILE: 461_Hamming_Distance.cpp
================================================
class Solution {
public:
    int hammingDistance(int x, int y) {
        x = x^y;
        y = 0;
        while(x){
            if(x&1) y++;
            x>>=1;
        }
        return y;
    }
};


================================================
FILE: 476_Number_Complement.cpp
================================================
class Solution {
public:
    int findComplement(int num) {
        int binaryNum[32]; 
        int i = 0, ret=0; 
        while (num > 0) { 
            binaryNum[i] = num % 2 == 0 ? 1 : 0 ; 
            num/=2; 
            i++; 
        } 
        for(int j=0; j<i; j++){
            ret += binaryNum[j]==1 ? pow(2,j) : 0;
        }
        return ret;
    }
};


================================================
FILE: 496_Next_Greater_Element_I.cpp
================================================
class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        int left, right, tmpIx, num;
        for(int i=0; i<nums1.size(); i++){
            right = -1, left=nums2.size(), num = nums1[i];
            while(++right <= --left){
                if(num==nums2[right]) {
                    tmpIx = right;
                    break;
                }
                else if (num==nums2[left]) {
                    tmpIx = left;
                    break;
                }
            }
            while(tmpIx < nums2.size()){
                if (num < nums2[tmpIx]){
                    nums1[i]=nums2[tmpIx];
                    num=-2;
                    break;
                }
                tmpIx++;
            }
            if(num !=-2){
                nums1[i] = -1;
            }
        }
        return nums1;
    }
};


================================================
FILE: 500_Keyboard_Row.cpp
================================================
class Solution {
public:
    Solution(){
        const vector<string> read{"qwertyuiop", "asdfghjkl", "zxcvbnm"};
        int keyboardIx{1};
        for(const string& str : read){
            for(const char& chr : str){
                m_um[chr]=keyboardIx;
                m_um[chr-32]=keyboardIx; // for upcase chars
            }
            keyboardIx++;
        }
    }

    vector<string> findWords(vector<string>& words) {
        vector<string> ret{};
        ret.reserve(words.size());

        for(const string& str : words){
            int counter{}, flag=m_um[str[0]];
            for(const char& chr: str){
                counter+=m_um[chr];
            }

            if((flag==1 && counter==str.size())
            || (flag==2 && counter==str.size()*2)
            || (flag==3 && counter==str.size()*3))
                ret.emplace_back(str);
        }
        return ret;
    }
private:
    unordered_map<unsigned char, unsigned char> m_um{};
};


================================================
FILE: 504_Base_7.cpp
================================================
class Solution {
public:
    string convertToBase7(int num) {
        int bs7{};
        bool isNeg = num<0;
        string ret{};

        if(isNeg) 
            num*=-1;
        
        while(num>6){
            ret+=to_string(num%7);
            num/=7;
        }
        ret+=to_string(num);
        
        if(isNeg)
            return "-"+string(ret.rbegin(), ret.rend());

        return string(ret.rbegin(), ret.rend());
    }
};


================================================
FILE: 506_Relative_Ranks.cpp
================================================
class Solution {
public:
    vector<string> findRelativeRanks(vector<int>& score) {
        int rank=1, size=score.size();
        map<int, int, greater<int>> m;
        vector<string> ret(size);
        
        for(int i=0; i<size; i++)
            m[score[i]]=i;

        for(auto it=m.begin(); it!=m.end(); ++it){
            if(rank>3)
                ret[it->second]=to_string(rank);
            else if(rank==1) ret[it->second]="Gold Medal";
            else if(rank==2) ret[it->second]="Silver Medal";
            else ret[it->second]="Bronze Medal";
            rank++;
        }
        
        return ret;
    }
};


================================================
FILE: 509_Fibonacci_Number.cpp
================================================
class Solution {
public:
    int fib(int n) {
        int bef0=0, bef1=1, ret=0;
        if(n>2){
             n++;
             for(int i=2; i<n; i++){
                ret = bef0 + bef1;
                bef0=bef1;
                bef1 = ret;
            }
            return ret;
        }
        else if(n==0){
            return 0;
        }
        else{
           return 1;
        }
    }
};

/*
// Recursive
class Solution {
public:
    int fib(int n) {
        if(n > 2){
            return fib(n-1)+fib(n-2);
        }
        else if(n>0){
            return 1;
        }
        return 0;
    }
};

*/


================================================
FILE: 50_Pow-x,n-.cpp
================================================
class Solution {
public:
    double myPow(double x, int n) {
        if(n==0)
            return 1;
        if(n>0){
            if(n%2==0)
                return myPow(x*x,n/2);
            else
                return x*myPow(x*x,(n-1)/2);  
        }
        else{
             if(n%-2==0)
                return myPow(((1/x)*(1/x)),n/-2);
            else
                return (1/x)*myPow(((1/x)*(1/x)),((n+1)/-2));  
        }
    }
};


================================================
FILE: 520_Detect_Capital.cpp
================================================
class Solution {
public:
    bool detectCapitalUse(string word) {
        int size=word.size();

        if(size<2) return true;

        for(int i=0; i<size-1; i++){
            if(word[i]>96 && word[i+1]<91)
                return false;
            if(word[i+1]>96 && word[i]<91)
                if(i!=0)
                    return false;
        }
        return true;
    }
};


================================================
FILE: 566_Reshape_the_Matrix.cpp
================================================
class Solution {
    public int[][] matrixReshape(int[][] mat, int r, int c) {
        int m = mat.length, n=mat[0].length;
        int[][] ret = new int[r][c];
        int size=m*n;
        if(size!=r*c)
            return mat;
        for(int i=0; i<size; i++){
            ret[i/c][i%c]=mat[i/n][i%n];
        }
        return ret;
    }
}


================================================
FILE: 605_Can_Place_Flowers.cpp
================================================
class Solution {
public:
    bool canPlaceFlowers(vector<int>& f, int n) {
        if(n==0)
            return 1;
        
        int empty= f[0]!=1 ? 1 : 0;
        for(const auto& i : f){
            if(i){
                n -= ((empty-1)/2);
                empty=0;
            }
            else { empty++; }
        }

        n-=(empty/2);

        return n<1;
    }
};


================================================
FILE: 606_Construct_String_from_Binary_Tree.cpp
================================================
class Solution {
public:
     void search(const TreeNode* root, string& ret) {
        if (!root) return;   
        ret += to_string(root->val);
        if (root->left) {
            ret += '(';
            search(root->left, ret);
            ret += ')';
        }
        if (root->right) {
            if (!root->left) ret += "()";
            ret += '(';
            search(root->right, ret);
            ret += ')';
        }
    }
    string tree2str(TreeNode* root) {
        string ret;
        search(root, ret);
        return ret;
    }  
};


================================================
FILE: 66_Plus_One.cpp
================================================
class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        digits.back()++;
        if(digits.back()>9) {
            int carry{};
            for(int ix = digits.size()-1; ix>-1; ix--){
                int n = digits[ix]+carry;
                digits[ix]= n%10;
                carry = n<10 ? 0 : n/10;
            }
            if(carry)
                digits.insert(digits.begin(), carry);
        }
        return digits;
    }
};


================================================
FILE: 67_Add_Binary.cpp
================================================
class Solution {
public:
    string addBinary(string a, string b) {
        size_t sizeA = a.size();
        size_t sizeB = b.size();
        int r = 0;
        stack<char> added;
        string ret;

        if (sizeA < sizeB)
            a = string(sizeB - sizeA, '0') + a;
        else if (sizeB < sizeA)
            b = string(sizeA - sizeB, '0') + b;

        chk(a, b, r, added);

        if (r)
            added.push('1');

        while (!added.empty()) {
            ret += added.top();
            added.pop();
        }

        return ret;
    }

    void chk(const string& a, const string& b,
            int& r, stack<char>& added)
    {
        for (int i = a.size() - 1; i >-1; i--) {
            if (a[i] + b[i] + r - 96 < 2) {
                added.push(a[i] + b[i] + r - 48);
                r = 0;
            }
            else if(a[i] + b[i] + r - 96 != 3){
                added.push('0');
                r = 1;
            }
            else {
                added.push('1');
                r = 1;
            }
        }
    }
};


================================================
FILE: 682_Baseball_Game.cpp
================================================
class Solution {
public:
    int calPoints(vector<string>& ops) {
        int sum = 0, tmp1, tmp2;
        stack<int> st;
        
        for(int i=0; i<ops.size(); i++){
            
            if(ops[i]=="C"){
                st.pop();
            }
            
            else if (ops[i]=="D"){
                st.push((st.top()*2));
            }
            
            else if (ops[i]=="+"){
                tmp1 = st.top();
                st.pop();
                tmp2 = st.top();
                st.pop();
                st.push(tmp2);
                st.push(tmp1);
                st.push(tmp1+tmp2);
            }
            
            else{
                st.push((stoi(ops[i])));
            }
        }
        
        while(!st.empty()){
                sum+=st.top();
                st.pop();
            }
        
        return sum;
        
    }
};


================================================
FILE: 693_Binary_Number_with_Alternating_Bits.cpp
================================================
class Solution {
public:
    bool hasAlternatingBits(int n) {
        char bfr=n%2;
        n>>=1;
        while(n)
            if(bfr!=(n%2)){
                bfr=n%2;
                n>>=1;
            }
            else return 0;
        return 1;
    }
};


================================================
FILE: 69_SqrtX.cpp
================================================
class Solution {
public:
    int mySqrt(int x) {
        cin.tie(NULL);
        
        long ret{x};
        while(ret*ret>x){
            ret = 0.5 * (ret + (x/ret));
        }
        return ret;
    }
};


================================================
FILE: 766_Toeplitz_Matrix.cpp
================================================
class Solution {
public:
    bool isToeplitzMatrix(vector<vector<int>>& matrix) {
        int n=matrix.size(), m=matrix[0].size();
        for(int i=1; i<n; i++)
            for(int j=1; j<m; j++)
                if(matrix[i][j]!=matrix[i-1][j-1])
                    return false;
        return true;
    }
};


================================================
FILE: 771_Jewels_and_Stones.cpp
================================================
class Solution {
public:
    int numJewelsInStones(string jewels, string stones) {
        int ret{};
        unordered_map<char, int> umj;
        for(const char& c : jewels)
            umj[c]++;
        for(const char& c : stones)
            ret+=umj[c];
        return ret;
    }
};


================================================
FILE: 806_Number_of_Lines_To_Write_String.cpp
================================================
class Solution {
public:
    vector<int> numberOfLines(vector<int>& widths, string s) {
        int line=1, wide=0;
        
        for(const char& c : s){
            if(widths[c-97]+wide>100){
                wide=0;
                line++;
            }
            wide+=widths[c-97];
        }
        
        return {line, wide};
    }
};


================================================
FILE: 821_Shortest_Distance_to_a_Character.cpp
================================================
class Solution {
public:
    vector<int> shortestToChar(string s, char c) {
        vector<int> ret;
        ret.reserve(s.size());
        int f=0,b=0, min_c=1000, cost=0;
        for(int i=0; i<s.size(); i++){
            f=i, b=i, cost=0, min_c=1000;
            if(c==s[i]){
                ret.emplace_back(cost);
                continue;
            }
            while(f < s.size()){
                if(s[f++] != c){ cost++; }
                else {
                    min_c = cost;
                    break;
                }
            }
            cost=0; 
            while(b > -1){
                if(s[b--] != c){ cost++; }
                else {
                    min_c = min_c < cost ? min_c : cost;
                    break;
                }
            }
            ret.emplace_back(min_c);
        }
        return ret;
    }
};


================================================
FILE: 824_Goat_Latin.cpp
================================================
class Solution {
public:
    string toGoatLatin(string sentence) {      
        sentence+=" ";
        string tmp, ret, a="", tmp2="";
        char init=-1;
        int counter=0;
        for(char& c : sentence){
            if(init==-1)
            {
                init=c;
                a+="a";
                tmp="";
            }
            if(c==' '){
                if(init!=65 && init!=97 && init!=69 && init!=101 && init!=73 && init!=105 && init!=79 && init!=111 && init!=85 && init!=117){
                    tmp2="";
                    for(int i=1; i<tmp.size(); i++)
                        tmp2+=tmp[i];
                    tmp2+=tmp[0];
                    tmp=tmp2;
                }
                ret+=tmp+"ma"+a;
                if(counter!=sentence.size()-1)
                    ret+=" ";
                init=-1; 
            }
            tmp+=c;
            counter++;
        }
        return ret;
    }
};


================================================
FILE: 852_Peak_Index_in_a_Mountain_Array.cpp
================================================
class Solution {
public:
    int peakIndexInMountainArray(vector<int>& arr) {
	int left = 0, right = arr.size() - 1, m;
	    while (left <= right) {
		    m = floor((left + right) / 2);
		    if (arr[m] > arr[m + 1] && arr[m] > arr[m - 1]) return m;
		    else if (arr[m] < arr[m + 1]) left = m + 1;
		    else right = m - 1;
	    }
	    return 0;
    }
};


================================================
FILE: 867_Transpose_Matrix.cpp
================================================
class Solution {
public:
    vector<vector<int>> transpose(vector<vector<int>>& matrix) {
        int col=matrix[0].size(), row=matrix.size();
        vector<int> tmp;
        tmp.reserve(row);
        vector<vector<int>> ret;
        ret.reserve(col);
        for(int i=0; i<col; i++){
            for(int j=0; j<row; j++){
                tmp.emplace_back(matrix[j][i]);
            }
            ret.emplace_back(tmp);
            tmp.clear();
        }
        return ret;
    }
};


================================================
FILE: 876_Middle_of_the_Linked_List.cpp
================================================
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* traveler = head;
        int ix = 1, counter=0;
        while(traveler -> next != nullptr){
            ix += 1;
            traveler = traveler ->  next;
        }
        traveler = head;
        while(counter++ < (ix/2))
            traveler = traveler ->  next;
        return traveler;
    }
};


================================================
FILE: 884_Uncommon_Words_from_Two_Sentences.cpp
================================================
class Solution {
public:
    vector<string> uncommonFromSentences(string s1, string s2) {
        unordered_map<string, int> words;
        vector<string> ret;
        string tmp="", tmp2="";
        int n = max(s1.size(), s2.size());
        for(int i=0; i<n; i++){
            if(i<s1.size()){
                if(s1[i]!=' '){
                    tmp+=s1[i];
                }
                else {
                    words[tmp]++;
                    tmp.clear();
                }
            }
            if(i<s2.size()){
                if(s2[i]!=' '){
                    tmp2+=s2[i];
                }
                else {
                    words[tmp2]++;
                    tmp2.clear();
                }
            }
        }
        if(tmp.size()>0)
            words[tmp]++;
        if(tmp2.size()>0)
            words[tmp2]++;
            
        for(auto& it : words){
            if(it.second==1)
                ret.push_back(it.first);
        }
        
        return ret;
    }
};


================================================
FILE: 888_Fair_Candy_Swap.cpp
================================================
class Solution {
public:
    vector<int> fairCandySwap(vector<int>& alice, vector<int>& bob) {
        int suma=0, sumb=0, d=0;
        for(int& i : alice)
            suma+=i;
        for(int& i : bob)
            sumb+=i;
        d=(sumb-suma)/2;
        unordered_set<int> bobs(bob.begin(), bob.end());
        for(int& a: alice){
            if(bobs.count(a+d))
            return {a,a+d};
        }
        return {};
    }
};


================================================
FILE: 88_Merge_Sorted_Array.cpp
================================================
class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int i{m-1}, j{n-1}, k{m+n-1};
        while(j>-1){
            if(i>-1 && nums1[i]>nums2[j])
                nums1[k--]=nums1[i--];
            else nums1[k--]=nums2[j--];
        }
    }
};


================================================
FILE: 896_Monotonic_Array.cpp
================================================
class Solution {
public:
    bool isMonotonic(vector<int>& nums) {
        return isIncrease(nums) || isDescreasing(nums);
    }
    bool isIncrease(vector<int>& nums){
        for(int i=1; i<nums.size(); i++){
            if(nums[i-1]>nums[i])
                return 0;
        }
        return 1;
    }
    bool isDescreasing(vector<int>& nums){
        for(int i=1; i<nums.size(); i++){
            if(nums[i-1]<nums[i])
                return 0;
        }
        return 1;
    }
};


================================================
FILE: 908_Smallest_Range_I.cpp
================================================
class Solution {
public:
    int smallestRangeI(vector<int>& nums, int k) {
        int mx=INT_MIN;
        int mn=INT_MAX;
        for(int& num : nums){
            mx=max(mx,num);
            mn=min(mn,num);
        }
        mx-=k;
        mn+=k; 
        return  mn>=mx ? 0 : mx-mn;
    }
};


================================================
FILE: 917_Reverse_Only_Letters.cpp
================================================
class Solution {
public:
    string reverseOnlyLetters(string s) {
        int i=0, j=s.size()-1;
        char c;
        if(j==0) return s;
        while(1){
            while(!((s[i]>64 && (s[i]<91)) || (s[i]>96 && (s[i]<123))) && i<j)
                i++;
            while(!((s[j]>64 && (s[j]<91)) || ((s[j])>96 && (s[j]<123))) && i<j)
                j--;
            
            if(i<j){
                c=s[i];
                s[i]=s[j];
                s[j]=c;
                i++;
                j--;
            }
            else break;
        }
        return s;
    }
};


================================================
FILE: 922_Sort_Array_By_Parity_II.cpp
================================================
class Solution {
public:
    vector<int> sortArrayByParityII(vector<int>& nums) {
        int ptr, tmp;
        for(int i=0; i<nums.size(); i++){
            if(i%2 != nums[i]%2){
                ptr=i;
                while(nums[++ptr]%2 == nums[i]%2);
                tmp=nums[ptr];
                nums[ptr]=nums[i];
                nums[i] = tmp;
            }
        }
        return nums;
    }
};


================================================
FILE: 929_Unique_Email_Addresses.cpp
================================================
class Solution {
public:
    int numUniqueEmails(vector<string>& emails) {
        set<string> mails;
        string local, domain, tmp;
        bool isDomain = false, isAddable=true;
        for(string& email : emails){
            local="";
            domain="";
            isAddable=true;
            isDomain = false;
            for(char& c : email){
                if(c==64){
                    isDomain=true;
                }
                if(isDomain){
                    domain+=c;
                }
                else{
                    if(c==43){
                        isAddable=false;
                    }
                    if(c!=46 && isAddable){
                        local+=c;
                    }
                }
            }
            mails.insert(local+domain);
        }
        return mails.size();
    }
};


================================================
FILE: 944_Delete_Columns_to_Make_Sorted.cpp
================================================
class Solution {
public:
    int minDeletionSize(vector<string>& strs) {
        int ret = 0;
        for (int col=0; col < strs[0].size(); col++) {
            for (int row=0; row < strs.size()-1; row++) {
                if (strs[row][col] > strs[row + 1][col]) {
                    ret++;
                    break;
                }
            }
        }
        return ret;
    }
};


================================================
FILE: 965_Univalued_Binary_Tree.cpp
================================================
class Solution {
public:
    bool isUnivalTree(TreeNode* root) {
        
        bool left = (root->left == nullptr || (root->val == root->left->val && isUnivalTree(root->left)));
        bool right = (root->right == nullptr || (root->val == root->right->val && isUnivalTree(root->right)));
        
        return left && right;
    }
};


================================================
FILE: 976_Largest_Perimeter_Triangle.cpp
================================================
class Solution {
public:
    int largestPerimeter(vector<int>& nums) {
        ios_base::sync_with_stdio(false);
        cin.tie(NULL);
        sort(nums.begin(), nums.end(), greater<int>());
        for(int i=0; i<nums.size()-2; i++)
            if(nums[i] < nums[i+1]+nums[i+2])
                return nums[i]+nums[i+1]+nums[i+2];
        return 0;
    }
};


================================================
FILE: 977_Squares_of_a_Sorted_Array.cpp
================================================
class Solution {
public:
	vector<int> sortedSquares(vector<int>& nums) {
		vector<int> ret(nums.size());
		int i = 0, j = nums.size()-1, ix = nums.size()-1, n1, n2;
		while(i <= j){
			n1 = nums[i] * nums[i];
			n2 = nums[j] * nums[j];
			if(n1 > n2){
				ret[ix--] = n1;
                i++;
            }
            else{
                ret[ix--] = n2;
                j--;
            }
		}
		return ret;
	}
};


================================================
FILE: 989_Add_to_Array-Form_of_Integer.cpp
================================================
class Solution {
public:
    vector<int> addToArrayForm(vector<int>& num, int k) {
        int ix = num.size()-1, carry{};

        while(ix>-1){
            int digit = num[ix]+ (k%10) + carry;
            num[ix--]=(digit%10);
            
            carry = digit < 10 ? 0 : digit/10;
            k /=10;
        }

        while(k){
            int digit = (k%10) + carry;
            num.insert(num.begin(), (digit%10));
        
            carry = digit < 10 ? 0 : digit/10;
            k/=10;
        }

        if(carry)
            num.insert(num.begin(), carry);


        return num;
    }
};


================================================
FILE: 999_Available_Captures_for_Rook.cpp
================================================
class Solution {
public:
    int numRookCaptures(vector<vector<char>>& board) {
        int ret=0, Ri=0, Rj=0;
        bool isFound=true; 
        for(int i=0; i<8; i++){
            if(isFound){
            for(int j=0; j<8; j++){
                    if(board[i][j]==82){
                        Ri=i;
                        Rj=j;
                        isFound=false;
                        break;
                    }
                }
            }
            else break;
        }
        for(int i=Ri+1; i<8; i++){
            if(board[i][Rj]==66) { break; }
            if(board[i][Rj]==112){ ret++; break; }
        }
        for(int i=Ri-1; i>-1; i--){
            if(board[i][Rj]==66) { break; }
            if(board[i][Rj]==112){ ret++; break; }
        }
        for(int j=Rj+1; j<8; j++){
            if(board[Ri][j]==66) { break; }
            if(board[Ri][j]==112){ ret++; break; }
        }
        for(int j=Rj-1; j>-1; j--){
            if(board[Ri][j]==66) { break; }
            if(board[Ri][j]==112){ ret++; break; }
        }
        return ret;
    }
};