Philadelphia

Author: MaskRay

basic-calculator-ii.nim

@@ -0,0 +1,30 @@
+import strutils
+
+proc calculate(s: cstring): cint {.exportc.} =
+  var
+    i = 0
+    sign = 1
+    sum = 0
+  while s[i].isSpaceAscii: inc i
+  if s[i] == '-':
+    inc i
+    sign = -1
+
+  while true:
+    while s[i].isSpaceAscii: inc i
+    var x = s[i].ord-'0'.ord
+    while (inc i; s[i].isDigit): x = x*10+s[i].ord-'0'.ord
+
+    while (while (s[i].isSpaceAscii): inc i; let op = s[i]; op == '*' or op == '/'):
+      inc i
+      while s[i].isSpaceAscii: inc i
+      var y = s[i].ord-'0'.ord
+      while (inc i; s[i].isDigit): y = y*10+s[i].ord-'0'.ord
+      x = if op == '*': x*y else: x div y
+    sum += sign*x
+    while s[i].isSpaceAscii: inc i
+    if s[i] == 0.char: break
+    sign = if s[i] == '-': -1 else: 1
+    inc i
+
+  return cast[cint](sum)

check-if-word-can-be-placed-in-crossword.cc

@@ -0,0 +1,37 @@
+// Check if Word Can Be Placed In Crossword
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+class Solution {
+public:
+  bool placeWordInCrossword(vector<vector<char>>& g, string word) {
+    int n = g.size(), m = g[0].size();
+    REP(_, 2) {
+      REP(i, n)
+        REP(j, m)
+          if (g[i][j] != '#') {
+            int jj = j+1;
+            while (jj < m && g[i][jj] != '#') jj++;
+
+            if (jj-j == word.size()) {
+              int k = 0;
+              for (; k < word.size() && (g[i][j+k] == ' ' || word[k] == g[i][j+k]); k++);
+              if (k == word.size())
+                return true;
+              k = 0;
+              for (; k < word.size() && (g[i][j+k] == ' ' || word[word.size()-1-k] == g[i][j+k]); k++);
+              if (k == word.size())
+                return true;
+            }
+            j = jj-1;
+          }
+      vector<vector<char>> h(m, vector<char>(n));
+      REP(i, n)
+        REP(j, m)
+          h[j][i] = g[i][j];
+      g.swap(h);
+      swap(n, m);
+    }
+    return false;
+  }
+};

detect-squares.nim

@@ -0,0 +1,34 @@
+# Detect Squares
+import tables
+
+const N = 1001
+
+type DetectSquares {.exportc.} = object
+  ls: Table[int, seq[int]]
+  rs: Table[int, seq[int]]
+  c: seq[int]
+
+proc detectSquaresCreate(): ptr DetectSquares {.exportc.} =
+  result = create DetectSquares
+  result[] = DetectSquares(ls: initTable[int, seq[int]](), rs: initTable[int, seq[int]](), c: newSeq[int](N*N))
+
+proc detectSquaresAdd(obj: ptr DetectSquares, point: ptr UncheckedArray[cint], pointSize: cint) {.exportc.} =
+  let (x, y) = (cast[int](point[0]), cast[int](point[1]))
+  obj.ls.mgetOrPut(x+y, @[]).add(y)
+  obj.rs.mgetOrPut(x-y, @[]).add(y)
+  obj.c[x+y*N] += 1
+
+proc detectSquaresCount(obj: ptr DetectSquares, point: ptr UncheckedArray[cint], pointSize: cint): cint {.exportc.} =
+  let (x0, y0) = (cast[int](point[0]), cast[int](point[1]))
+  var res = 0
+  for y1 in obj.ls.getOrDefault(x0+y0, @[]):
+    if y0 == y1: continue
+    let x1 = x0+y0-y1
+    res += obj.c[x0+y1*N] * obj.c[x1+y0*N]
+  for y1 in obj.rs.getOrDefault(x0-y0, @[]):
+    if y0 == y1: continue
+    let x1 = x0-y0+y1
+    res += obj.c[x0+y1*N] * obj.c[x1+y0*N]
+  cast[cint](res)
+
+proc detectSquaresFree(obj: sink DetectSquares) {.exportc.} = discard

different-ways-to-add-parentheses.nim

@@ -0,0 +1,35 @@
+import sequtils, strutils
+
+proc malloc(size: csize_t): pointer {.importc.}
+
+proc diffWaysToCompute(s: cstring, returnSize: ptr cint): ptr UncheckedArray[cint] {.exportc.} =
+  var
+    i = 0
+    nums = newSeq[int]()
+    ops = newSeq[char]()
+  while true:
+    var x = 0
+    while (x = x*10+s[i].ord-'0'.ord; inc i; s[i].isDigit):
+      discard
+    nums.add(x)
+    if s[i] == 0.char: break
+    ops.add(s[i])
+    inc i
+  let n = nums.len
+  var s = newSeqWith(n, newSeqWith(n, newSeq[int]()))
+  for i in 0..<n:
+    s[i][i].add(nums[i])
+  for i in countdown(n-2, 0):
+    for j in i+1..<n:
+      for k in i..<j:
+        for x in s[i][k]:
+          for y in s[k+1][j]:
+            s[i][j].add(case ops[k]
+            of '+': x+y
+            of '-': x-y
+            else: x*y)
+
+  returnSize[] = cast[cint](s[0][n-1].len)
+  result = cast[ptr UncheckedArray[cint]](malloc(cast[csize_t](cint.sizeof*returnSize[])))
+  for i in 0..<s[0][n-1].len:
+    result[i] = cast[cint](s[0][n-1][i])

longest-subsequence-repeated-k-times.cc

@@ -1,56 +1,47 @@
 // Longest Subsequence Repeated k Times
-#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define FOR(i, a, b) for (long i = (a); i < (b); i++)
 #define REP(i, n) FOR(i, 0, n)
-#define ROF(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (b); --i >= (a); )
-using pii = pair<int, int>;
+#define ROF(i, a, b) for (long i = (b); --i >= (a); )
 
 class Solution {
-  vector<pii> ab;
   vector<array<int, 26>> nxt;
   string cur, ans;
-  int k;
-  bool dfs(int st, int i) {
-    bool ok = 0;
-    for (auto &c: ab) {
-      if (c.second == 0) continue;
-      int j = nxt[i][c.first];
+  int freq[26] = {}, k;
+  void dfs(int l, int i) {
+    ROF(c, 0, 26) {
+      if (freq[c] < k) continue;
+      int j = nxt[i][c];
       if (j < 0) continue;
-      c.second--;
-      cur.push_back('a'+c.first);
-      ok |= dfs(st+1, j);
-      cur.pop_back();
-      c.second++;
+
+      freq[c] -= k;
+      cur[l-1] = 'a'+c;
+      REP(_, k-1)
+        REP(x, l) {
+          j = nxt[j][cur[x]-'a'];
+          if (j < 0) goto out;
+        }
+      if (l > ans.size())
+        ans = cur.substr(0, l);
+      dfs(l+1, nxt[i][c]);
+out:
+      freq[c] += k;
     }
-    if (ok)
-      return true;
-    if (st <= ans.size())
-      return false;
-    REP(_, k-1)
-      for (char c: cur) {
-        i = nxt[i][c-'a'];
-        if (i < 0) return false;
-      }
-    ans = cur;
-    return true;
   }
 public:
   string longestSubsequenceRepeatedK(string s, int k) {
-    this->k = k;
-    int freq[26] = {}, n = s.size();
+    int n = s.size();
     for (char c: s)
       freq[c-'a']++;
-    ROF(c, 0, 26)
-      if (freq[c] >= k)
-        ab.emplace_back(c, freq[c]/k);
-
     nxt.resize(n+1);
     REP(c, 26)
       nxt[n][c] = -1;
     ROF(i, 0, n) {
       nxt[i] = nxt[i+1];
       nxt[i][s[i]-'a'] = i+1;
     }
-    dfs(0, 0);
+    this->k = k;
+    cur.resize(n/k);
+    dfs(1, 0);
     return ans;
   }
 };