Answer 1

拍平： const deepFlatten = arr => [].concat(...arr.map(v => (Array.isArray(v) ? deepFlatten(v) : v)));
用toString会改变数组里面的原始数据，应该会是扣分项。

Answer 2

暴力方法
function find() {
let result = [];
for(let i=1;i<10000;i++){
let str = i.toString();
let isToAdd = true;
for(let j in str){
if(str[j] != str[str.length -1 -j]){
isToAdd = false;
}
}
if(isToAdd &&str.length>1){
result.push(i);
}
}
console.log(result);
return result;
}

find();

Answer 3

function findMedianSortedArrays(nums1, nums2) {
  let [{ length: m }, { length: n }] = [nums1, nums2];
  if (m > n) {
    [m, n] = [n, m];
    [nums1, nums2] = [nums2, nums1];
  }
  let [imin, imax] = [0, m];
  const halfLen = (m + n + 1) / 2;
  while (imin <= imax) {
    let i = ~~((imin + imax) / 2);
    let j = ~~(halfLen - i);
    if (i < imax && nums2[j - 1] > nums1[i]) {
      imin = i + 1;
    } else if (i > imin && nums1[i - 1] > nums2[j]) {
      imax = i - 1;
    } else {
      let maxLeft;
      if (!i) {
        maxLeft = nums2[j - 1];
      } else if (!j) {
        maxLeft = nums1[i - 1];
      } else {
        maxLeft = Math.max(nums1[i - 1], nums2[j - 1]);
      }
      if ((m + n) % 2) {
        return maxLeft;
      }
      let minRight;
      if (i === m) {
        minRight = nums2[j];
      } else if (j === n) {
        minRight = nums1[i];
      } else {
        minRight = Math.min(nums2[j], nums1[i]);
      }
      return (maxLeft + minRight) / 2;
    }
  }
}

Answer 4

for循环中使用let，js引擎会为每一次循环初始化一个独立作用域和变量。
所以，第一种情况：
i 初始化次数：100，j 初始化次数：100 * 1000，k 初始化次数：100 * 1000 * 10000
第二种情况：
i 初始化次数：10000，j 初始化次数：10000 * 1000，k 初始化次数：10000 * 1000 * 100
通过比较可得
第二种情况，需要初始化的次数较多，所以耗时较长。

Answer 5

function convert(list) {
	const res = []
	const map = list.reduce((res, v) => (res[v.id] = v, res), {})
	for (const item of list) {
		if (item.parentId === 0) {
			res.push(item)
			continue
		}
		if (item.parentId in map) {
			const parent = map[item.parentId]
			parent.children = parent.children || []
			parent.children.push(item)
		}
	}
	return res
}

时间复杂度O(n)