LeetCode Weekly Contest 281

class Solution {
public:
    int countEven(int num) {
        
        int ans = 0;
        for(int i=1;i<=num;i++)
        {
             int res = 0;
             int x = i;
             while(x)
             {
                 res+= (x%10);
                 x/=10;
             }
            
            if((res&1)==0)
            {
                ans++;
            }
        }
        
        return ans;
        
    }
};

/**
 * 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* mergeNodes(ListNode* head) {
        
        ListNode* node = head->next;
        
        
        ListNode* pre = head;
        ListNode* res = head;
        int ans=0;
      
        while(node!=NULL)
        {
            if(node->val == 0)
            {
                    pre->next = new ListNode(ans);
                    pre->next->next = node;
                    pre = node;
 
                    ans=0;
            }
            else
            {
                ans+=node->val;
            }
            
            node = node->next;
        }
        
        ListNode* node2 = res->next;
        
        while(node2!=NULL&&node2->next!=NULL)
        {
            if(node2->next->val == 0)
            {
                node2->next = node2->next->next;
            }
            
            node2 = node2->next;
        }
        
        return res->next;
        
    }
};

class Solution {
public:
    int a[30];
    string repeatLimitedString(string s, int repeatLimit) {
        
        memset(a,0,sizeof(a));
        for(int i=0;i<s.length();i++)
        {
            a[s[i]-'a']++;
        }
        
        int pos=25;
        string res="";
        while(pos>=0)
        {
            int i=0;
            while(a[pos]>0 && i< repeatLimit)
            {
                res+='a'+pos;
                a[pos]--;
                i++;
                
                if(i==repeatLimit && a[pos]>0)
                {
                    int j = pos-1;
                    while(j>=0 && a[j]<=0)
                    {
                        j--;
                    }
                    
                    if(j!=-1)
                    {
                        a[j]--;
                        res+='a'+j;
                        i=0;
                    }
                }
            }
            
            pos--;
        }
        
        return res;
        
    }
};

class Solution {
public:
    int a[405];
    map<int,int> m;
    int pos;
    long long countPairs(vector<int>& nums, int k) {
        
        pos=0;
        for(int i=1;i*i<=k;i++)
        {
            if(k%i==0)
            {
                a[pos++] = i;
                
                m[i] = pos-1;
                a[pos++] = k/i;
                m[k/i] = pos-1;
            }
        }
        
        int sum[pos][100005];
        for(int i=0;i<pos;i++)
        {
            if(nums[0] % a[i] == 0)
            {
                sum[i][0] =1;
            }
            else
            {
                sum[i][0] = 0;
            }
            
            for(int j=1;j<nums.size();j++)
            {
                if(nums[j] % a[i] == 0)
                {
                    sum[i][j] = sum[i][j-1]+1;
                }
                else
                {
                    sum[i][j] = sum[i][j-1];
                }
            }
        }
        
        long long int ans=0;
        for(int i=0;i<nums.size();i++)
        {
            int x = k / gcd(nums[i], k);
          
            int j = m[x];
           
            ans+= sum[j][nums.size()-1] - sum[j][i];
          
        }
        
        return ans;
        
    }
    
    int gcd(int x, int y)
    {
        if(x % y == 0)
            return y;
        else
            return gcd(y, x%y);
    }
};