add scripts

Author: everthis

513-find-bottom-left-tree-value.js

@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const findBottomLeftValue = function(root) {
+    const res = []
+    single(root, 0, res)
+    return res[res.length - 1][0].val
+};
+
+function single(node, row, arr) {
+    if (node == null) {
+        return null
+    }
+    if (row < arr.length) {
+        arr[row].push(node)
+    } else {
+        arr[row] = [node]
+    }
+    single(node.left, row + 1, arr)
+    single(node.right, row + 1, arr)
+}

515-find-largest-value-in-each-tree-row.js

@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+const largestValues = function(root) {
+    const res = []
+    single(root, 0, res)
+    return res
+};
+
+function single(node, row, arr) {
+    if (node == null) {
+        return null
+    }
+    if (row < arr.length) {
+        if (node.val > arr[row]) {
+            arr[row] = node.val
+        }
+    } else {
+        arr[row] = node.val
+    }
+    single(node.left, row + 1, arr)
+    single(node.right, row + 1, arr)
+}

540-single-element-in-a-sorted-array.js

@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const singleNonDuplicate = function(nums) {
+    let i=0;
+    while(true){
+        if(nums[i]==nums[i+1]) {
+            i+=2;
+        } else {
+            return nums[i];
+        }
+    }
+};

637-average-of-levels-in-binary-tree.js

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+const averageOfLevels = function(root) {
+    const res = []
+    layer(res, [root])
+    return res.map(el => el.val / el.num)
+    
+};
+
+function layer(arr, args) {
+    const item = {
+        val: args.reduce((ac, el) => ac + el.val, 0),
+        num: args.length
+    }
+    arr.push(item)
+    const children = []
+    args.forEach(el => {
+        el.left === null ? null : children.push(el.left)
+        el.right === null ? null : children.push(el.right)
+    })
+    if(children.length) {
+        layer(arr, children)
+    }
+}

693-binary-number-with-alternating-bits.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+const hasAlternatingBits = function(n) {
+    const str = bin(n)
+    for(let i = 1, prev = str.charAt(0); i < str.length; i++) {
+        if (str.charAt(i) === prev) {
+            return false
+        }
+        prev = str.charAt(i)
+    }
+    return true
+};
+
+function bin(num){
+    return (num >>> 0).toString(2)
+}

762-prime-number-of-set-bits-in-binary-representation.js

@@ -0,0 +1,40 @@
+/**
+ * @param {number} L
+ * @param {number} R
+ * @return {number}
+ */
+const countPrimeSetBits = function(L, R) {
+    let res = 0
+    for(let i = L; i <= R; i++) {
+        if (chkPrime(i)) {
+            res += 1
+        }
+    }
+    return res
+};
+
+function chkPrime(num) {
+    const str = bin(num)
+    const snum = setNum(str)
+    return isPrime(snum)
+}
+
+function setNum(str) {
+    let num = 0
+    for(let i = 0; i < str.length; i++) {
+        if (str.charAt(i) === '1') {
+            num += 1
+        }
+    }
+    return num
+}
+
+function bin(num) {
+    return (num >>> 0).toString(2)
+}
+function isPrime(num) {
+    for(let i = 2; i < num; i++) {
+        if(num % i === 0) return false;
+    }
+    return num !== 1;
+}

835-image-overlap.js

@@ -0,0 +1,47 @@
+/**
+ * @param {number[][]} A
+ * @param {number[][]} B
+ * @return {number}
+ */
+const largestOverlap = function(A, B) {
+    const N = A.length
+    const count = constructMatrix(2*N, 2*N, 0)
+    for (let i = 0; i < N; i++) {
+      for (let j = 0; j < N; j++) {
+        if (A[i][j] === 1) {
+          for(let ii = 0; ii < N; ii++) {
+            for(let jj = 0; jj < N; jj++) {
+              if(B[ii][jj] === 1) {
+                count[i-ii+N][j-jj+N] += 1
+              }
+            }
+          }
+        }
+      }
+    }
+    let ans = 0
+
+    for(let row of count) {
+      for(let v of row) {
+        ans = Math.max(ans, v)
+      }
+    }
+    return ans
+};
+
+function constructMatrix(row, col, init = 0) {
+  const matrix = []
+  for(let i = 0; i < row; i++) {
+    matrix[i] = []
+    for(let j = 0; j < col; j++) {
+      matrix[i][j] = init
+    }
+  }
+  return matrix
+}
+
+console.log(largestOverlap([[1,1,0],
+    [0,1,0],
+    [0,1,0]],[[0,0,0],
+    [0,1,1],
+    [0,0,1]]))