386

Author: MaskRay

README.md

@@ -0,0 +1,15 @@
+// Binary Watch
+class Solution {
+public:
+  vector<string> readBinaryWatch(int num) {
+    vector<string> r;
+    for (int i = 0; i < 12; i++)
+      for (int j = 0; j < 60; j++)
+        if (__builtin_popcount(i)+__builtin_popcount(j) == num) {
+          char buf[6];
+          sprintf(buf, "%d:%02d", i, j);
+          r.push_back(buf);
+        }
+    return r;
+  }
+};

binary-watch.cc

@@ -0,0 +1,24 @@
+// Decode String
+class Solution {
+  string f(int& i, string s) {
+    int x = 0;
+    string r;
+    for (; i < s.size(); i++)
+      if (unsigned(s[i]-'0') < 10)
+        x = x*10+s[i]-'0';
+      else if (s[i] == '[') {
+        string t = f(++i, s);
+        for (; x > 0; x--)
+          r += t;
+      } else if (s[i] == ']')
+        break;
+      else
+        r += s[i];
+    return r;
+  }
+public:
+  string decodeString(string s) {
+    int i = 0;
+    return f(i, s);
+  }
+};

decode-string.cc

@@ -0,0 +1,17 @@
+// Elimination Game
+/*
+l(i) = 2*r(i/2)+1
+r(i) = 2*l(i/2)+i%2
+
+=>
+
+l(i) = 4*l(i/4) + (i%4 >= 2 ? 3 : 1) = 4*l(i/4) + (i%4 | 1)
+= (0x55555555 | i) & x
+where x is the largest 2^k-1 less than i
+*/
+class Solution {
+public:
+  int lastRemaining(int n) {
+    return ((0x55555555 | n) & (1u<<31-__builtin_clz(n))-1) + 1;
+  }
+};

elimination-game.cc

@@ -0,0 +1,35 @@
+// Evaluate Division
+class Solution {
+  unordered_map<string, vector<pair<string, double>>> adj;
+  unordered_map<string, pair<int, double>> val;
+  void dfs(string u, int b, double g) {
+    if (val.count(u)) return;
+    val[u] = {b, g};
+    for (auto& x: adj[u])
+      dfs(x.first, b, g*x.second);
+  }
+public:
+  vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
+    int i = 0;
+    for (auto& x: equations) {
+      adj[x.first].emplace_back(x.second, values[i]);
+      adj[x.second].emplace_back(x.first, 1.0/values[i]);
+      i++;
+    }
+    i = 0;
+    for (auto& x: adj)
+      dfs(x.first, i++, 1);
+    vector<double> r;
+    for (auto& x: queries)
+      if (! val.count(x.first) || ! val.count(x.second))
+        r.push_back(-1);
+      else {
+        auto &u = val[x.first], &v = val[x.second];
+        if (u.first != v.first)
+          r.push_back(-1);
+        else
+          r.push_back(v.second/u.second);
+      }
+    return r;
+  }
+};

evaluate-division.cc

@@ -0,0 +1,15 @@
+// Frog Jump
+class Solution {
+public:
+  bool canCross(vector<int>& stones) {
+    vector<unordered_set<int>> a(stones.size());
+    a[0].insert(0);
+    for (int i = 1; i < stones.size(); i++)
+      for (int j = i-1; j >= 0 && stones[j]+j+1 >= stones[i]; j--) {
+        int t = stones[i]-stones[j];
+        if (a[j].count(t-1) || a[j].count(t) || a[j].count(j+1))
+          a[i].insert(t);
+      }
+    return a.back().size();
+  }
+};

frog-jump.cc

@@ -0,0 +1,18 @@
+// Integer Replacement
+class Solution {
+public:
+  int integerReplacement(int n) {
+    int r = 0;
+    unsigned m = n;
+    while (m > 3) {
+      if (m%2 == 0)
+        m >>= 1;
+      else if (m&2)
+        m++;
+      else
+        m--;
+      r++;
+    }
+    return r+m-1;
+  }
+};

integer-replacement.cc

@@ -0,0 +1,11 @@
+// Is Subsequence
+class Solution {
+public:
+  bool isSubsequence(string s, string t) {
+    size_t i = 0;
+    for (char c: t)
+      if (i < s.size() && s[i] == c)
+        i++;
+    return i == s.size();
+  }
+};

is-subsequence.cc

@@ -0,0 +1,57 @@
+// Longest Substring with At Least K Repeating Characters
+
+/// O(n |alphabet|)
+
+class Solution {
+public:
+  int longestSubstring(string s, int k) {
+    const int AB = 26;
+    int r = 0, c[AB];
+    for (int u = 1; u <= AB; u++) {
+      fill_n(c, AB, 0);
+      int unique = 0, geq_k = 0;
+      for (int i = 0, j = 0; j < s.size(); ) {
+        if (unique <= u) {
+          int& c0 = c[s[j]-'a'];
+          if (! c0)
+            unique++;
+          if (++c0 == k)
+            geq_k++;
+          j++;
+        } else {
+          int& c0 = c[s[i]-'a'];
+          if (c0 == k)
+            geq_k--;
+          if (! --c0)
+            unique--;
+          i++;
+        }
+        if (unique == u && geq_k == u)
+          r = max(r, j-i);
+      }
+    }
+    return r;
+  }
+};
+
+/// O(n |alphabet|)
+
+class Solution {
+  static const int AB = 26;
+  int f(const string& s, int l, int r, int k) {
+    int ret = 0, c[AB] = {}, b = l;
+    for (int i = l; i < r; i++)
+      c[s[i]-'a']++;
+    for (int i = l; i < r; i++)
+      if (c[s[i]-'a'] < k) {
+        if (b < i)
+          ret = max(ret, f(s, b, i, k));
+        b = i+1;
+      }
+    return b == l ? r-l : b < r ? max(ret, f(s, b, r, k)) : ret;
+  }
+public:
+  int longestSubstring(string s, int k) {
+    return f(s, 0, s.size(), k);
+  }
+};

longest-substring-with-at-least-k-repeating-characters.cc

@@ -0,0 +1,13 @@
+// Nth Digit
+class Solution {
+public:
+  int findNthDigit(int n) {
+    long d = 1, r = 1;
+    for (n--; n >= 9*r*d; r *= 10)
+      n -= 9*r*d++;
+    r += n/d;
+    for (d -= n%d+1; d--; )
+      r /= 10;
+    return r%10;
+  }
+};

nth-digit.cc

@@ -0,0 +1,22 @@
+// Random Pick Index
+class Solution {
+  vector<int> a;
+public:
+  Solution(vector<int> nums) {
+    a = nums;
+    srand(time());
+  }
+
+  int pick(int target) {
+    int t = -1, r;
+    for (int i = 0; i < a.size(); i++)
+      if (target == a[i]) {
+        int g = rand();
+        if (g > t) {
+          t = t;
+          r = i;
+        }
+      }
+    return r;
+  }
+};

random-pick-index.cc

@@ -0,0 +1,14 @@
+// Remove K Digits
+class Solution {
+public:
+  string removeKdigits(string num, int k) {
+    string a;
+    for (char c: num) {
+      for (; k && a.size() && a.back() > c; k--)
+        a.pop_back();
+      if (a.size() || c != '0')
+        a += c;
+    }
+    return k < a.size() ? a.substr(0, a.size()-k) : "0";
+  }
+};

remove-k-digits.cc

@@ -0,0 +1,13 @@
+// Rotate Function
+class Solution {
+public:
+  int maxRotateFunction(vector<int>& A) {
+    int s = 0, ss = 0, n = A.size(), r;
+    for (int i = 0; i < n; i++)
+      s += A[i], ss += i*A[i];
+    r = ss;
+    for (int i = 1; i < n; i++)
+      r = max(r, ss += n*A[i-1]-s);
+    return r;
+  }
+};

rotate-function.cc

@@ -0,0 +1,21 @@
+// UTF-8 Validation
+class Solution {
+public:
+  bool validUtf8(vector<int>& data) {
+    int c = 0;
+    for (int x: data)
+      if (c) {
+        if ((x >> 6) != 0b10)
+          return false;
+        c--;
+      } else if ((x >> 5) == 0b110)
+        c = 1;
+      else if ((x >> 4) == 0b1110)
+        c = 2;
+      else if ((x >> 3) == 0b11110)
+        c = 3;
+      else if (x >> 7)
+        return false;
+    return ! c;
+  }
+};