12 problems solved.

lintcoder · lintcoder · commit 243fef6a5ee8 · 2021-10-01T19:53:55.000+08:00
diff --git a/src/1114.cpp b/src/1114.cpp
@@ -0,0 +1,34 @@
+class Foo {
+public:
+    Foo() {
+        flag1 = 0;
+        flag2 = 0;
+    }
+
+    void first(function<void()> printFirst) {
+        
+        // printFirst() outputs "first". Do not change or remove this line.
+        printFirst();
+        flag1 = 1;
+    }
+
+    void second(function<void()> printSecond) {
+        
+        // printSecond() outputs "second". Do not change or remove this line.
+        while (flag1 == 0)
+            ;
+        printSecond();
+        flag2 = 1;
+    }
+
+    void third(function<void()> printThird) {
+        
+        // printThird() outputs "third". Do not change or remove this line.
+        while (flag2 == 0)
+            ;
+        printThird();
+    }
+private:
+    volatile int flag1;
+    volatile int flag2;
+};
diff --git a/src/1418.cpp b/src/1418.cpp
@@ -0,0 +1,39 @@
+vector<vector<string>> displayTable(vector<vector<string>>& orders) {
+        int len = orders.size();
+        map<int, map<string,int>> mp;
+        set<string> st;
+        
+        for (int i = 0; i < len; ++i)
+        {
+            mp[atoi(orders[i][1].c_str())][orders[i][2]]++;
+            st.insert(orders[i][2]);
+        }
+        
+        int reslen = mp.size()+1;
+        int foodnum = st.size();
+        vector<vector<string>> res(reslen, vector<string>(foodnum+1, "0"));
+        res[0][0] = "Table";
+        
+        int i = 1;
+        for (auto iter = st.begin(); iter != st.end(); ++iter)
+        {
+            res[0][i++] = *iter;
+        }
+        
+        i = 1;
+        for (auto iter = mp.begin(); iter != mp.end(); ++iter)
+        {
+            res[i][0] = to_string(iter->first);
+            int j = 1;
+            for (auto iterJ = st.begin(); iterJ != st.end(); ++iterJ)
+            {
+                if ((iter->second).find(*iterJ) == iter->second.end())
+                    res[i][j++] = "0";
+                else
+                    res[i][j++] = to_string((iter->second)[*iterJ]);
+            }    
+            ++i;
+        }
+        
+        return res;
+    }
diff --git a/src/1913.cpp b/src/1913.cpp
@@ -0,0 +1,6 @@
+int maxProductDifference(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        int len = nums.size();
+        
+        return nums[len-1]*nums[len-2] - nums[0]*nums[1];
+    }
diff --git a/src/1929.cpp b/src/1929.cpp
@@ -0,0 +1,8 @@
+vector<int> getConcatenation(vector<int>& nums) {
+        int len = nums.size();
+        vector<int> res(2*len);
+        res.assign(nums.begin(), nums.end());
+        res.insert(res.end(), nums.begin(), nums.end());
+        
+        return res;
+    }
diff --git a/src/1935.cpp b/src/1935.cpp
@@ -0,0 +1,31 @@
+int canBeTypedWords(string text, string brokenLetters) {
+        int flag[26] = {0};
+        int len = brokenLetters.size();
+        for (int i = 0; i < len; ++i)
+        {
+            flag[brokenLetters[i]-'a'] = 1;
+        }
+        
+        int textlen = text.size();
+        int res = 0;
+        int i = 0;
+        bool isbroke = false;
+        while (i < textlen)
+        {
+            if (text[i] == ' ')
+            {
+                if (isbroke == false)
+                    ++res;
+                isbroke = false;
+            }
+            else if (!isbroke && flag[text[i]-'a'] == 1)
+            {
+                isbroke = true;
+            }
+            ++i;
+        }
+        if (isbroke == false)
+            ++res;
+        
+        return res;
+    }
diff --git a/src/1941.cpp b/src/1941.cpp
@@ -0,0 +1,22 @@
+bool areOccurrencesEqual(string s) {
+        int counts[26] = {0};
+        int len = s.size();
+        for (int i = 0; i < len; ++i)
+        {
+            ++counts[s[i]-'a'];
+        }
+        
+        int num = 0;
+        for (int i = 0; i < 26; ++i)
+        {
+            if (counts[i] > 0)
+            {
+                if (num == 0)
+                    num = counts[i];
+                else if (counts[i] != num)
+                    return false;
+            }
+        }
+        
+        return true;
+    }
diff --git a/src/1967.cpp b/src/1967.cpp
@@ -0,0 +1,11 @@
+int numOfStrings(vector<string>& patterns, string word) {
+        int len = patterns.size();
+        int res = 0;
+        for (int i = 0; i < len; ++i)
+        {
+            if (word.find(patterns[i]) != string::npos)
+                ++res;
+        }
+        
+        return res;
+    }
diff --git a/src/1979.cpp b/src/1979.cpp
@@ -0,0 +1,31 @@
+int findGCD(vector<int>& nums) {
+        int len = nums.size();
+        int minval = nums[0], maxval = nums[0];
+        for (int i = 1; i < len; ++i)
+        {
+            if (nums[i] < minval)
+                minval = nums[i];
+            if (nums[i] > maxval)
+                maxval = nums[i];
+        }
+        
+        return gcd(minval, maxval);
+    }
+    
+    int gcd(int a, int b)
+    {
+        if (a > b)
+        {
+            int tmp = a;
+            a = b;
+            b = tmp;
+        }
+        
+        if (b%a == 0)
+            return a;
+        else
+        {
+            b %= a;
+            return gcd(b, a);
+        }
+    }
diff --git a/src/1991.cpp b/src/1991.cpp
@@ -0,0 +1,21 @@
+int findMiddleIndex(vector<int>& nums) {
+        int len = nums.size();
+        vector<int> subsum(len+1, 0);
+        int sum = 0;
+        subsum[0] = 0;
+        for (int i = 1; i < len+1; ++i)
+        {
+            sum += nums[i-1];
+            subsum[i] = sum;
+        }
+        
+        int tmp = subsum[len];
+        for (int i = 0; i < len; ++i)
+        {
+            if (subsum[i] == tmp-nums[i])
+                return i;
+            tmp -= nums[i];
+        }
+        
+        return -1;
+    }
diff --git a/src/2000.cpp b/src/2000.cpp
@@ -0,0 +1,15 @@
+string reversePrefix(string word, char ch) {
+        int index = word.find(ch);
+        if (index != string::npos)
+        {
+            int i = 0, j = index;
+            while (i < j)
+            {
+                swap(word[i], word[j]);
+                ++i;
+                --j;
+            }
+        }
+        
+        return word;
+    }
diff --git a/src/2006.cpp b/src/2006.cpp
@@ -0,0 +1,14 @@
+int countKDifference(vector<int>& nums, int k) {
+        int res = 0;
+        int len = nums.size();
+        for (int i = 0; i < len-1; ++i)
+        {
+            for (int j = i+1; j < len; ++j)
+            {
+                if (abs(nums[i]-nums[j]) == k)
+                    ++res;
+            }
+        }
+        
+        return res;
+    }
diff --git a/src/2011.cpp b/src/2011.cpp
@@ -0,0 +1,13 @@
+int finalValueAfterOperations(vector<string>& operations) {
+        int len = operations.size();
+        int result = 0;
+        for (int i = 0; i < len; ++i)
+        {
+            if (operations[i].find('+') != string::npos)
+                ++result;
+            else
+                --result;
+        }
+        
+        return result;
+    }
