add Leetcode problems

Author: bira37

LeetCode/General Problems/CountGoodTriplets.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int countGoodTriplets(vector<int>& arr, int a, int b, int c) {
+        int ans =0;
+        int n = arr.size();
+        for(int i=0; i<n; i++){
+            for(int j=i+1; j<n; j++){
+                for(int k=j+1; k<n; k++){
+                    if(abs(arr[i] - arr[j]) <= a && abs(arr[j] - arr[k]) <= b && abs(arr[i] - arr[k]) <= c) ans++;
+                }
+            }
+        }
+        return ans;
+    }
+};

LeetCode/General Problems/DetectCapital.cs

@@ -0,0 +1,13 @@
+public class Solution {
+    public bool DetectCapitalUse(string word) {
+        bool first = (word[0] >= 'A' && word[0] <= 'Z');
+        int capital = 0;
+        for(int i=1; i<word.Length; i++){
+            if(word[i] >= 'A' && word[i] <= 'Z') capital++;
+        }
+        
+        if(capital == 0) return true;
+        if(first && capital == word.Length-1) return true;
+        return false;
+    }
+}

LeetCode/General Problems/GetTheMaximumScore.cpp

@@ -0,0 +1,58 @@
+class Solution {
+public:
+    typedef long long ll;
+    const int M = 1000000007;
+    
+    ll solve(vector<int>& v, vector<int>& w){
+        vector<ll> pv, pw;
+        for(int x : v){
+            if(pv.size() == 0) pv.push_back(x);
+            else pv.push_back(pv.back()+x);
+        }
+        for(int x : w){
+            if(pw.size() == 0) pw.push_back(x);
+            else pw.push_back(pw.back()+x);
+        }
+        ll ans = 0;
+        ll last_match = -1;
+        for(int i=0; i<v.size(); i++){
+            // putting v[i]
+            // check whether it exists on w
+            ll it = lower_bound(w.begin(), w.end(), v[i]) - w.begin();
+            if(it >= w.size() || w[it] != v[i]){
+                // no match, just put v[i] on ans
+                ans += v[i];
+            } else {
+                //matched 
+                if(last_match == -1){
+                    last_match = it;
+                    ans += v[i];
+                }
+                else {
+                    ll it2 = lower_bound(v.begin(), v.end(), w[last_match]) - v.begin();
+                    ll pfirst = pv[i] - (it2 > -1 ? pv[it2] : 0);
+                    ll psecond = pw[it] - (last_match > -1 ? pw[last_match] : 0);
+                    //cout << pfirst << " " << psecond << endl;
+                    if(psecond > pfirst) ans += max(pfirst, psecond) - min(pfirst, psecond);
+                    ans += v[i];
+                    last_match = it;
+                }
+            }
+            //cout << "after " << v[i] << " ans is " << ans << endl;
+        }
+        //cout << "current is " << ans << endl;
+        //adjust ending
+        if(last_match != -1){
+            ll it2 = lower_bound(v.begin(), v.end(), w[last_match]) - v.begin();
+            ll pfirst = pv.back() - (it2 > -1 ? pv[it2] : 0);
+            ll psecond = pw.back() - (last_match > -1 ? pw[last_match] : 0);
+            //cout << pfirst << "  " << psecond << endl;
+            if(psecond > pfirst) ans += max(pfirst, psecond) - min(pfirst, psecond);
+        }
+        return ans;
+    }
+    
+    int maxSum(vector<int>& nums1, vector<int>& nums2) {
+        return max(solve(nums1, nums2), solve(nums2, nums1))%M;
+    }
+};

LeetCode/General Problems/MergeKSortedLists.cs

@@ -0,0 +1,32 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode MergeKLists(ListNode[] lists) {
+        ListNode head = new ListNode(-1);
+        ListNode cur = head;
+        while(true){
+            int mn = -1;
+            for(int i=0; i<lists.Length; i++){
+                if(lists[i] == null) continue;
+                if(mn == -1) mn = i;
+                else if(lists[mn].val > lists[i].val){
+                    mn = i;
+                }
+            }
+            if(mn == -1) break;
+            cur.next = new ListNode(lists[mn].val);
+            lists[mn] = lists[mn].next;
+            cur = cur.next;
+        }
+        return head.next;
+    }
+}