Feat: add solution for 347, 647

Author: HC-kang

number-of-1-bits/HC-kang.ts

@@ -23,11 +23,12 @@ The input binary string 1111111111111111111111111111101 has a total of thirty se
 function hammingWeight(n: number): number {
   // Time complexity: O(logn)
   // Space complexity: O(logn)
-  // but it has a better readability
+  // it has a better readability and not so bad in space complexity
   return n.toString(2).split('1').length - 1;
 
   // Time complexity: O(logn)
   // Space complexity: O(1)
+  // it's better in space complexity, but sometimes the bitwise operation is not easy to understand
   let count = 0;
   while (n !== 0) {
     count += n & 1;

palindromic-substrings/HC-kang.ts

@@ -0,0 +1,93 @@
+/*
+647. Palindromic Substrings
+
+Example 1:
+Input: s = "abc"
+Output: 3
+Explanation: Three palindromic strings: "a", "b", "c".
+
+Example 2:
+Input: s = "aaa"
+Output: 6
+Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
+ */
+
+// Time complexity: O(n^3)
+// Space complexity: O(n^3)
+function countSubstrings(s: string): number {
+  function isPalindrome(s: string): boolean {
+    if (s.length === 0) return false;
+    if (s.length === 1) return true;
+    let left = 0;
+    let right = s.length - 1;
+    while (left < right) {
+      if (s[left] !== s[right]) return false;
+      left++;
+      right--;
+    }
+    return true;
+  }
+
+  const candidates = new Map<string, number>();
+  for (let i = 0; i < s.length; i++) {
+    for (let j = i + 1; j <= s.length; j++) {
+      // this will cost both t.c. and s.c. O(n^3)
+      candidates.set(s.slice(i, j), (candidates.get(s.slice(i, j)) || 0) + 1);
+    }
+  }
+
+  let count = 0;
+  for (const [key, value] of candidates) {
+    if (isPalindrome(key)) count += value
+  }
+
+  return count;
+};
+
+// Time complexity: O(n^3)
+// Space complexity: O(1)
+function countSubstrings(s: string): number {
+  function isPalindrome(s: string): boolean {
+    if (s.length === 0) return false;
+    if (s.length === 1) return true;
+    let left = 0;
+    let right = s.length - 1;
+    while (left < right) {
+      if (s[left] !== s[right]) return false;
+      left++;
+      right--;
+    }
+    return true;
+  }
+
+  let count = 0;
+  for (let i = 0; i < s.length; i++) {
+    for (let j = i + 1; j <= s.length; j++) {
+      // this will cause t.c. O(n^3). need to optimize this part
+      if (isPalindrome(s.slice(i, j))) count++;
+    }
+  }
+
+  return count;
+}
+
+// Time complexity: O(n^2)
+// Space complexity: O(1)
+function countSubstrings(s: string): number {
+  function expandIsPalindrome(left: number, right: number): number {
+    let count = 0;
+    while (left >= 0 && right < s.length && s[left] === s[right]) {
+      count++;
+      left--;
+      right++;
+    }
+    return count;
+  }
+
+  let count = 0;
+  for (let i = 0; i < s.length; i++) {
+    count += expandIsPalindrome(i, i);
+    count += expandIsPalindrome(i, i + 1);
+  }
+  return count;
+}

top-k-frequent-elements/HC-kang.ts

@@ -0,0 +1,24 @@
+/*
+347. Top K Frequent Elements
+
+Example 1:
+Input: nums = [1,1,1,2,2,3], k = 2
+Output: [1,2]
+
+Example 2:
+Input: nums = [1], k = 1
+Output: [1]
+ */
+
+// Time complexity: O(nlogn)
+// Space complexity: O(n)
+function topKFrequent(nums: number[], k: number): number[] {
+  const acc = new Map<number, number>();
+  for (const num of nums) { // s.c. O(n)
+    acc.set(num, (acc.get(num) || 0) + 1);
+  }
+  return Array.from(acc.entries())
+    .sort((a, b) => b[1] - a[1]) // this will cost t.c. O(nlogn)
+    .slice(0, k)
+    .map((v) => v[0]);
+}