第一题

给出一个整数数组，要求输出它的极差。
签到题，很简单。

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 有一个无序整型数组，求出这个数组中最大差值
 * @param arr int整型一维数组
 * @return int整型
 */
function getMaxProfit(arr) {
  // write code here
  return Math.max(...arr) - Math.min(...arr);
}
module.exports = {
  getMaxProfit: getMaxProfit,
};

第二题

给一个由id和pid组成的元素的数组，要求输出以此生成的树形结构，注意元素无序且可能重复，需要进行去重，输入输出均为字符串格式，需要自行转换。
这题属实拉稀了，一个小时没A掉，太久没写题手生了，只过了50%，开头还被输入卡了一会。

const line = '[{"id":1},{"id":2,"pid":1},{"id":4,"pid":3},{"id":3,"pid":2}]';
const arr = eval(line);
const set = new Set();
const ans = new Array();
const search = (list, id) => {
  for (const item of list) {
    if (item.id === id) return item;
    else {
      if (!item.child) continue;
      const ans = search(item.child, id);
      if (ans) return ans;
      else continue;
    }
  }
};
for (const item of arr) {
  // 第一次出现此元素
  if (!set.has(item.id)) {
    // 记录此元素已出现过
    set.add(item.id);
    // 新元素有父级
    if (item.pid) {
      // 新元素的父级没有出现过
      if (!set.has(item.pid)) {
        // 直接创建新元素的父级并插入新元素
        ans.push({ id: item.pid, child: [item] });
        set.add(item.pid);
      } else {
        // 新元素的父级有出现过
        const parent = search(ans, item.pid);
        // 找到其父级并插入到子元素中
        parent.child ? parent.child.push(item) : (parent.child = [item]);
      }
    } else {
      // 新元素没有父级，则将此新元素插入到根元素中
      ans.push(item);
    }
  } else {
    // 此元素已经出现过
    if (item.pid) {
      // 此元素有父级，但其父级没有出现过
      if (!set.has(item.pid)) {
        // 新建父级元素，并插入新元素
        ans.push({ id: item.pid, child: [item] });
        set.add(item.pid);
      } else {
        // 此元素有父级，且父级已经出现过
        const parent = search(ans, item.pid);
        // 找到其父级并检查是否已经包含了此子元素
        if (!parent.child) {
          // 父元素没有子元素数组，肯定未包含此子元素
          // 找到已经存在的当前元素
          const cur = search(ans, item.id);
          // 增加子元素
          parent.child = [Object.assign({}, cur)];
          // 删除原来的元素
          if (cur.pid) {
            // 此元素有父级，先找到父级再删除
            const P = search(ans, cur.pid);
            P.child.splice(P.child.indexOf(cur, 1));
          } else {
            // 此元素没有父级，在根节点删除
            ans.splice(ans.indexOf(cur, 1));
          }
        } else {
          // 父元素有子元素数组，遍历检查
          let has = false;
          for (const e of parent.child) {
            if (e.id === item.id) {
              has = true;
              break;
            }
          }
          // 没有包含此子元素
          if (!has) {
            // 找到已经存在的当前元素
            const cur = search(ans, item.id);
            // 插入子元素
            parent.child.push(Object.assign({}, cur));
            // 删除原来的元素
            if (cur.pid) {
              // 此元素有父级，先找到父级再删除
              const P = search(ans, cur.pid);
              P.child.splice(P.child.indexOf(cur, 1));
            } else {
              // 此元素没有父级，在根节点删除
              ans.splice(ans.indexOf(cur, 1));
            }
          } else {
            // 已经包含了此元素，无需操作
          }
        }
      }
    } else {
      // 此元素没有父级，无需操作
    }
  }
}
console.log(JSON.stringify(ans));

第三题
给一个整形一维数组arr和一个目标整数target，要求输出所有由数组arr中元素相加之和等于target的组合，注意同一个数字可以重复选择，只要结果组合含有不同的数字都认为是合法的答案。
没时间了！没写！之后补题！

本文作者：TTQ
本文链接：https://blog.ponder.fun/archives/159.html
最后修改时间：2022-09-07 21:27:38
本站未注明转载的文章均为原创，并采用 CC BY-NC-SA 4.0 授权协议，转载请注明来源，谢谢！