已完成的答案

+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum1 = function(nums, target) {
+    for(let [i, v] of nums.entries()) {
+        let f = nums.indexOf(target-v, i+1);
+		
+        if (f >= 0) {
+            return [i, f]
+        }
+    }
+};
+
+var twoSum = function(nums, target) {
+	let m = {}
+    for(let [i, v] of nums.entries()) {
+		(m[v] === void 0) && (m[v]=i);
+		let d = target-v;
+		// console.info('-->', i,v,d,m[d])
+		if (m[d] >= 0 && m[d] !== i) {
+			return [m[d], i]
+		}
+    }
+};
+
+
+console.info(twoSum([3,2,4], 6));
+console.info(twoSum([2,7,11,15], 9));
+console.info(twoSum([4,2,4], 8)); 

+/**
+ * @param {number} n
+ * @return {string}
+ */
+var convertToTitle = function(n) {
+    let title = [];
+    while (n--) {
+        let c = n%26+1;
+        console.info(n, c, String.fromCharCode(64+c));
+        n = ~~(n / 26); 
+
+        title.unshift(String.fromCharCode(64+c));
+    }
+    return title.join('');
+};
+
+console.info(convertToTitle(701))
\ No newline at end of file

+/* Write your PL/SQL query statement below */
+select p.FirstName, p.LastName, a.City, a.State
+from Person p
+left join Address a on p.PersonId = a.PersonId
\ No newline at end of file

+/* Write your PL/SQL query statement below */
+with s as (
+select distinct Salary
+from Employee 
+order by Salary desc)
+select max(salary) SecondHighestSalary
+from (select salary, rownum nm from s) t
+where nm = 2

+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+function ListNode(val) {
+    this.val = val;
+    this.next = null;
+}
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function (l1, l2) {
+    function list2array(list) {
+        let arr = [];
+        do {
+            arr.push(list.val);
+            list = list.next;
+        }
+        while (list);
+        return arr;
+    }
+    function array2list(arr) {
+        let list = new ListNode(), c = list;
+        for (let [i, v] of arr.entries()) {
+            c.val = v;
+            c.next = i+1 < arr.length?new ListNode():null;
+            c = c.next;
+        }
+        return list;
+    }
+    let arr1 = list2array(l1);
+    let arr2 = list2array(l2);
+    let len = Math.max(arr1.length, arr2.length);
+    let rs = [], f = 0;
+    for (let i = 0; i < len; i++) {
+        let v1 = arr1.shift()||0;
+        let v2 = arr2.shift()||0;
+        let v = v1 + v2 + f;
+        if (v >= 10) {
+            rs.push(v - 10);
+            f = 1;
+        } else {
+            rs.push(v);
+            f = 0;
+        }
+    }
+    if (f > 0) {
+        rs.push(f);
+    }
+    
+    return array2list(rs);
+};
+
+
+console.info(addTwoNumbers({
+    val: 1,
+    next: null
+}, {
+    val: 9,
+    next: { val: 9, next: null }
+}));
\ No newline at end of file

+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+var isPowerOfThree = function(n) {
+    if (n ===1) {
+        return true;
+    }
+    while(true) {
+        n = n/3;
+        if (n === 1) {
+            return true;
+        } else if(n < 1) {
+            return false;
+        }
+    }
+};
+
+console.info(isPowerOfThree(0));
\ No newline at end of file

+/**
+ * @param {character[]} s
+ * @return {void} Do not return anything, modify s in-place instead.
+ */
+var reverseString = function(s) {
+    let len = s.length, half = len>>1;
+    for (let i=0;i<half;i++) {
+        if (i !== len-1-i) {
+            [s[i], s[len-1-i]] = [s[len-1-i], s[i]];
+        }
+    }
+    return s;
+};
+
+console.info(reverseString(["H","a","n","N","a","h", "9"]));
\ No newline at end of file

+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var findMedianSortedArrays = function(nums1, nums2) {
+    function merge(nums1, nums2) {
+        let nums = [];
+        while (nums1.length || nums2.length) {
+            if (nums1.length === 0) {
+                return nums.concat(nums2);
+            }
+            if (nums2.length === 0) {
+                return nums.concat(nums1);
+            }
+
+            if (nums1[0] < nums2[0]) {
+                nums.push(nums1.shift());
+            } else {
+                nums.push(nums2.shift());
+            }
+        }
+        return nums;
+    }
+    let nums = merge(nums1, nums2);
+
+    // let nums = [...nums1, ...nums2];
+    // nums.sort((a,b)=>a-b);
+    // console.info(nums1, nums2, '=>', nums)
+    let len = nums.length; 
+    if (len % 2 === 0) {
+        return (nums[len/2-1] + nums[(len/2)]) / 2;
+    } else {
+        return nums[~~(len/2)];
+    }
+};
+
+var nums1 = [];
+var nums2 = [9,
+28,
+245,
+307,
+461,
+561,
+680,
+683];
+console.info(findMedianSortedArrays(nums1, nums2));
\ No newline at end of file

+/**
+ * @param {number} x
+ * @param {number} n
+ * @return {number}
+ */
+var myPow = function(x, n) {
+    if (n === 0) return 1;
+    if (n === 1) return x;
+
+    if (x === 1) return 1;
+    if (x === -1) return n % 2 === 0 ? 1 : -1;
+
+    if (n < 0) {
+        n = -n;
+        x = 1/x;
+    }
+    
+    return (n % 2 === 0) ? myPow(x*x, n/2) : x * myPow(x*x, (n-1)/2);
+};
+
+var slowPow = function(x, n) {
+    if (Math.abs(x) >= 100) throw new Error('x is out of range');
+    if (n !== ~~n) throw new Error('n is out of range');
+
+    if (n === 0) return 1;
+    if (x === 1) return 1;
+    if (x === -1) return n % 2 === 0 ? 1 : -1;
+
+    let N = 1e8;
+    let ret = 1.0;
+    let sign = n > 0 ? 1 : (n=-n)&&-1;
+    while (n > 0) {
+        ret *= p(x, n>=N?N:n);
+        n -= N;
+    }
+
+    return sign > 0 ? ret : 1/ret;
+};
+
+var p = function(x, n) {
+    let ret = 1.0;
+    for (let i = 0; i < n; i++ ) {
+        ret = ret * x;
+    }
+    return ret;
+};
+
+var x = 0, n = -3;
+console.info(myPow(x, n), Math.pow(x, n));
\ No newline at end of file

+/**
+ * @param {number[][]} matrix
+ * @return {number[]}
+ */
+var spiralOrder = function(matrix) {
+    let rs = [];
+    while (matrix.length) {
+        // right
+        if (matrix.length) {
+            rs = rs.concat(matrix.shift());
+        }
+        console.info('after right matrix', matrix)
+
+        // down
+        matrix.forEach(m => {
+            let t = m.pop();
+            (t !== void 0) && rs.push(t);
+        });
+        console.info('after down matrix', matrix);
+
+        // left
+        if (matrix.length) {
+            rs = rs.concat(matrix.pop().reverse());
+        }
+        console.info('after left matrix', matrix);
+
+        //
+        for (let i=0;i<matrix.length;i++) {
+            // console.info('===>', matrix, [matrix.length-1-i], matrix.length-1-i)
+            let t = matrix[matrix.length-1-i].shift();
+            (t !== void 0) && rs.push(t);
+        }
+        console.info('matrix', matrix);
+    }
+    
+    return rs;
+};
+
+console.info(spiralOrder([
+    [1],
+    [5],
+    [9],
+    [13]
+  ]));
\ No newline at end of file

+/**
+ * @param {number} x
+ * @return {number}
+ */
+var reverse = function(x) {
+    let r;
+    let sign = Math.sign(x);
+    try {
+        r = Number.parseInt(String(Math.abs(x)).split('').reverse().join('')||'0');
+    } catch (e) {
+        r = 0;
+    }
+    return r > Math.pow(2, 31)-1 ? 0 : sign*r;
+};
+
+console.info(reverse(0));
\ No newline at end of file

+/**
+ * @param {number[][]} matrix
+ * @return {void} Do not return anything, modify matrix in-place instead.
+ */
+var setZeroes2 = function (matrix) {
+    let m = matrix.length;
+    let n = matrix[0].length;
+    let rs = []
+    // copy init matrix
+    for (let i = 0; i < m; i++) {
+        let r = []
+        // for(let j=0;j<n;j++) {
+        //     r.push(void 0)
+        // }
+        rs.push(r);
+    }
+
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            let v = matrix[i][j]
+            if (v === 0) {
+                for (let x = 0; x < n; x++) {
+                    rs[i][x] = 0;
+                }
+                for (let y = 0; y < m; y++) {
+                    rs[y][j] = 0;
+                }
+            } else {
+                (rs[i][j] === void 0) && (rs[i][j] = v);
+            }
+        }
+    }
+
+    return rs;
+};
+
+var setZeroes_ok = function (matrix) {
+    let m = matrix.length;
+    let n = matrix[0].length;
+    let rs = [];
+    // init matrix
+    for (let i = 0; i < m; i++) {
+        rs.push([]);
+    }
+
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            let v = matrix[i][j]
+            if (v === 0 && rs[i][j] === void 0) {
+                for (let x = 0; x < n; x++) {
+                    let t = matrix[i][x];
+                    if (t !== 0) {
+                        rs[i][x] = t;
+                    }
+                    matrix[i][x] = 0;
+                }
+                for (let y = 0; y < m; y++) {
+                    let t = matrix[y][j];
+                    if (t !== 0) {
+                        rs[y][j] = t;
+                    }
+                    matrix[y][j] = 0;
+                }
+            } else {
+                rs[i][j] = v;
+            }
+        }
+    }
+};
+
+var setZeroes = function (matrix) {
+    let m = matrix.length;
+    let n = matrix[0].length;
+
+    let rows = new Set();
+    let cols = new Set();
+
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            let v = matrix[i][j]
+            if (v === 0) {
+                rows.add(i);
+                cols.add(j);
+            }
+        }
+    }
+
+    rows.forEach(e => {
+        for (let j=0;j<n;j++) {
+            matrix[e][j] = 0;
+        }
+    });
+
+    cols.forEach(e => {
+        for (let i=0;i<m;i++) {
+            matrix[i][e] = 0;
+        }
+    });
+};
+var matrix = [[0, 1, 2, 0], [3, 4, 5, 2], [1, 3, 1, 5]];
+setZeroes(matrix);
+console.info(matrix);
\ No newline at end of file