Update

Author: MaiDeveloper

clock-angle.js

@@ -0,0 +1,68 @@
+/**
+ * Clock Angle
+ *
+ * Given two integers, an hour and a minute, write a function to calculate the angle between the two hands on a clock representing that time.
+ *
+ * Example 1:
+ * Input: 3, 0
+ * Output: 90
+ *
+ * Example 2:
+ * Input: 3, 20
+ * Output: 20
+ *
+ * Example 3:
+ * Input: 12, 0
+ * Output: 0
+ *
+ * Example 4:
+ * Input: 2, 45
+ * Output: 172.5
+ *
+ */
+
+/**
+ * Calculate the clock angle
+ * @param {Number} hour
+ * @param {Number} minute
+ * @return {Number}
+ * @time comlexity: O(1)
+ * @space complexity: O(1)
+ */
+const clockAngle = (hour, minute) => {
+  const ANGLE_PER_HOUR = 360 / 12,
+        ANGLE_PER_MINUTE = 360 / 60,
+        minuteHand = minute * ANGLE_PER_MINUTE,
+        hourHand = hour * ANGLE_PER_HOUR + minute / 60 * ANGLE_PER_HOUR;
+
+  const angle = Math.abs(hourHand - minuteHand);
+
+  return Math.min(360 - angle, angle);
+};
+
+
+import { assert } from 'chai';
+
+describe('Clock Angle', () => {
+
+    it('3:00 should be 90 degree', () => {
+      assert.strictEqual(clockAngle(3, 0), 90);
+    });
+
+    it('3:20 should be 20 degree', () => {
+      assert.strictEqual(clockAngle(3, 20), 20);
+    });
+
+    it('12:00 should be 0 degree', () => {
+      assert.strictEqual(clockAngle(12, 0), 0);
+    });
+
+    it('2:45 should be 172.5 degree', () => {
+      assert.strictEqual(clockAngle(2, 45), 172.5);
+    });
+
+    it('9:00 should be 90 degree', () => {
+      assert.strictEqual(clockAngle(9, 0), 90);
+    });
+
+});

test.js

@@ -1,30 +1,16 @@
-function lcs(wordX, wordY) {
-  const m = wordX.length;
-  const n = wordY.length;
-  const l = [];
+function test(str) {
+  let ans = '';
+  const map = {};
 
-  for (let i = 0; i <= m; i++) {
-    l[i] = []; // {1}
-    for (let j = 0; j <= n; j++) {
-      l[i][j] = 0; // {2}
-    }
-  }
+  for (let i = str.length - 1; i >= 0; i--) {
+    map[str[i]] = (map[str[i]] || 0) + 1;
 
-  for (let i = 0; i <= m; i++) {
-    for (let j = 0; j <= n; j++) {
-      if (i === 0 || j === 0) {
-        continue;
-      } else if (wordX[i - 1] === wordY[j - 1]) {
-        l[i][j] = l[i - 1][j - 1] + 1; // {3}
-      } else {
-        const a = l[i - 1][j];
-        const b = l[i][j - 1];
-        l[i][j] = a > b ? a : b; // {4} max(a,b)
-      }
+    if (map[str[i]] === 1) {
+      ans = str[i];
     }
   }
-  console.log(l);
-  return l[m][n]; // {5}
+
+  return ans;
 }
 
-console.log(lcs('acbaed', 'abcadf'));
+console.log(test(" tutorial horizon"));

unique-paths-iii.js

@@ -66,7 +66,7 @@ class UniquePath {
   /**
    * Set the grid
    * @param {Array[][]} grid
-   * @time complexity: O(mn), where m is the number of rows and n is the number of cols
+   * @time complexity: O(mn), where m is the number of rows and n is the number of columns
    * @space complexity: O(mn)
    */
   setGrid(grid) {
@@ -101,7 +101,7 @@ class UniquePath {
    * @param {Number} col
    * @param {Number} validSquare
    * @return {Number} Number of unique paths
-   * @time complexity: O(4^m*n), where m is the number of rows and n is the number of cols,
+   * @time complexity: O(4^m*n), where m is the number of rows and n is the number of columns,
    *                             it walks in 4 directions (up, down, left, right). So its 4 power m * n
    * @space complexity: O(mn), because of its recursion stacks
    */