8 problems solved.

lintcoder · lintcoder · commit cff8589aea3f · 2022-04-09T17:04:32.000+08:00
diff --git a/src/2180.cpp b/src/2180.cpp
@@ -0,0 +1,17 @@
+int countEven(int num) {
+        int ct = 0;
+        for (int i = 1; i <= num; ++i)
+        {
+            int n = i;
+            int sum = 0;
+            while (n > 0)
+            {
+                sum += n%10;
+                n /= 10;
+            }
+            if (sum%2 == 0)
+                ++ct;
+        }
+        
+        return ct;
+    }
diff --git a/src/2196.cpp b/src/2196.cpp
@@ -0,0 +1,55 @@
+TreeNode* createBinaryTree(vector<vector<int>>& descriptions) {
+        map<int, int> nodeflag;
+        map<int, pair<int,int>> nodepos;
+        int len = descriptions.size();
+        
+        for (int i = 0; i < len; ++i)
+        {
+            nodeflag[descriptions[i][0]] |= 1;
+            nodeflag[descriptions[i][1]] |= 2;
+            if (descriptions[i][2] == 1)
+                nodepos[descriptions[i][0]].first = descriptions[i][1];
+            else
+                nodepos[descriptions[i][0]].second = descriptions[i][1];
+        }
+        
+        int headval = 0;
+        auto iterLast = nodeflag.end();
+        for (auto iter = nodeflag.begin(); iter != iterLast; ++iter)
+        {
+            if (iter->second == 1)
+            {
+                headval = iter->first;
+                break;
+            }
+        }
+        
+        TreeNode* head = new TreeNode(headval);
+        deque<TreeNode*> dq;
+        dq.push_back(head);
+        int k = 1;
+        while (k != 0)
+        {
+            int n = 0;
+            for (int i = 0; i < k; ++i)
+            {
+                TreeNode* node = dq[i];
+                if (nodepos[node->val].first != 0)
+                {
+                    node->left = new TreeNode(nodepos[node->val].first);
+                    dq.push_back(node->left);
+                    ++n;
+                }
+                if (nodepos[node->val].second != 0)
+                {
+                    node->right = new TreeNode(nodepos[node->val].second);
+                    dq.push_back(node->right);
+                    ++n;
+                }
+            }
+            dq.erase(dq.begin(), dq.begin()+k);
+            k = n;
+        }
+        
+        return head;  
+    }
diff --git a/src/2215.cpp b/src/2215.cpp
@@ -0,0 +1,20 @@
+vector<vector<int>> findDifference(vector<int>& nums1, vector<int>& nums2) {
+        int arr1[2001] = {0};
+        int arr2[2001] = {0};
+        int len1 = nums1.size(), len2 = nums2.size();
+        for (int i = 0; i < len1; ++i)
+            arr1[nums1[i]+1000] = 1;
+        for (int i = 0; i < len2; ++i)
+            arr2[nums2[i]+1000] = 1;
+        
+        vector<vector<int>> res(2, vector<int>());
+        for (int i = 0; i < 2001; ++i)
+        {
+            if (arr1[i] != 0 && arr2[i] == 0)
+                res[0].push_back(i-1000);
+            if (arr1[i] == 0 && arr2[i] != 0)
+                res[1].push_back(i-1000);
+        }
+        
+        return res;
+    }
diff --git a/src/222.cpp b/src/222.cpp
@@ -0,0 +1,16 @@
+int countNodes(TreeNode* root) {
+        int ct = 0;
+        search(root, ct);
+        
+        return ct;
+    }
+    
+    void search(TreeNode* node, int& n)
+    {
+        if (node != nullptr)
+        {
+            ++n;
+            search(node->left, n);
+            search(node->right, n);
+        }
+    }
diff --git a/src/2220.cpp b/src/2220.cpp
@@ -0,0 +1,11 @@
+int minBitFlips(int start, int goal) {
+        bitset<32> bs(start), bg(goal);
+        int ct = 0;
+        for (int i = 0; i < 32; ++i)
+        {
+            if (bs[i] != bg[i])
+                ++ct;
+        }
+        
+        return ct;
+    }
diff --git a/src/2221.cpp b/src/2221.cpp
@@ -0,0 +1,13 @@
+int triangularSum(vector<int>& nums) {
+        int len = nums.size();
+        while (len > 1)
+        {
+            for (int i = 0; i < len-1; ++i)
+            {
+                nums[i] = (nums[i]+nums[i+1])%10;
+            }
+            --len;
+        }
+        
+        return nums[0];
+    }
diff --git a/src/2224.cpp b/src/2224.cpp
@@ -0,0 +1,23 @@
+int convertTime(string current, string correct) {
+        int curMinutes = ((current[0]-'0')*10+(current[1]-'0'))*60 + ((current[3]-'0')*10+(current[4]-'0'));
+        int corrMinutes = ((correct[0]-'0')*10+(correct[1]-'0'))*60 + ((correct[3]-'0')*10+(correct[4]-'0'));
+        int delta = corrMinutes - curMinutes;
+        int ct = 0;
+        if (delta >= 60)
+        {
+            ct += delta/60;
+            delta %= 60;
+        }
+        if (delta >= 15)
+        {
+            ct += delta/15;
+            delta %= 15;
+        }
+        if (delta >= 5)
+        {
+            ct += delta/5;
+            delta %= 5;
+        }
+        
+        return ct + delta;
+    }
diff --git a/src/2225.cpp b/src/2225.cpp
@@ -0,0 +1,21 @@
+vector<vector<int>> findWinners(vector<vector<int>>& matches) {
+        map<int, pair<int,int>> mp;
+        int len = matches.size();
+        for (int i = 0; i < len; ++i)
+        {
+            mp[matches[i][0]].first++;
+            mp[matches[i][1]].second++;
+        }
+        
+        vector<vector<int>> res(2, vector<int>{});
+        auto iterLast = mp.end();
+        for (auto iter = mp.begin(); iter != iterLast; ++iter)
+        {
+            if (iter->second.second == 0)
+                res[0].push_back(iter->first);
+            if (iter->second.second == 1)
+                res[1].push_back(iter->first);
+        }
+        
+        return res;
+    }
