算法2

4
100 200 300 500
1 2
1 3
2 4
 
输出：700
说明：
成员1,2,3组成的小家庭财富值为600
成员2,4组成的小家庭财富值为700

function getMaxWealthFamily(N, wealths, familys) {
  wealths = wealths.unshift(0); // 下标从一开始
  let maxWealth = wealths[1];
  let familyWealth = [...wealths];
 
  for (let i = 2; i < N + 1; i++) {
    const [N1, N2] = familys[i].split(' ').map(Number);
    familyWealth[N1] += wealths[N2];
    maxWealth = Math.max(maxWealth, familyWealth[N1])
  }
  console.log(maxWealth);
}

function getPopulerProject(length, weights, projects) {
  let tempProjects = projects.map(value => {
    let splitValue = value.split(' ');
    let name = splitValue[0];
    let scores = splitValue.slice(1);
    let hotness = 0;
    for (let j = 0; j < 5; j++) {
      hotness += weights[j] * scores[j]
    }
    return {
      name: name,
      hotness: hotness
    }
  })
  tempProjects.sort((a, b) => {
    if (a.hotness !== b.hotness) {
      return b.hotness - a.hotness;
    } else {
      return a.name.localeCompare(b.name);
    }
  })
  for (let project of tempProjects) {
    console.log(project.name);
  }
}

输入：
2
present
present absent present present leaveearly present absent
 
输出：
true false

function kaoqin (N, arr) {
  function check(records) {
    let absent = 0;
    for (let i = 0; i < records.length; i++) {
      if (records[i] === 'absent') {
        absent++;
        if (absent > 1) {
          return false;
        }
      } else if (records[i] === 'leaveearly' || records[i] === 'late') {
        if (i > 0 && (records[i - 1] === 'late' || records[i - 1] === 'leaveearly')) {
          return false;
        }
      }
      if (i >= 6) {
        let count = 0;
        for (let j = i - 6; j <= i; j++) {
          if (records[j] !== 'present') {
            count++;
          }
        }
        if (count > 3) {
          return false;
        }
      }
    }
 
    return true;
  }
}

输入：
100 10
95 96 97 98 99 101 102 103 104 105
 
输出：
99 101 98 102 97 103 96 104 95 105
 
说明：
小明身高100，班级学生10个，身高分别为95 96 97 98 99 101 102 103 104 105，按身高差排序后结果为: 99 101 98 102 97 103 96 104 95 105。

function findSimilyHeight (targetHeight, studentsNum, heights) {
  heights.sort((a, b) => {
    let diffA = Math.abs(a - targetHeight);
    let diffB = Math.abs(b - targetHeight);
    if (diffA === diffB) { // 身高差一样，个子矮的排前面
      return a - b;
    }
    return diffA - diffB;
  })
}

3 3
1 0 1
0 0 0
0 1 0
 
输出 9
说明：土地上的旗子为1，其坐标分别为(0,0)，(2,1)以及(0,2)，为了覆盖所有旗子，矩阵需要覆盖的横坐标为0和2，纵坐标为0和2，所以面积为9，即（2-0+1）*（2-0+1）= 9
 
 
3 3
1 0 2
0 0 0
0 3 4
 
输出 1
由于不存在成对的小旗子，故而返回1，即一块土地的面积。

// inputs 为数组 ['1 0 2', '0 0 0', '0 3 4']
function getMaxSize(m, n, inputs) {
  let land = []
  inputs.forEach(value => {
    land.push(value.split(' ').map(Number));
  })
  let maxArea = 0;
  let minpos = {};
  let maxpos = {};
  for (let i = 0; i < m; i++) {
    for (let j = 0; j < n; j++) {
      let num = land[i][j];
      if (num !== 0) {
        if (!minpos[num]) {
          minpos[num] = [i, j];
          maxpos[num] = [i, j];
        } else {
          minpos[num] = [Math.min(minpos[num][0], i), Math.min(minpos[num][1], j)];
          maxpos[num] = [Math.max(maxpos[num][0], i), Math.max(maxpos[num][1], j)];
        }
      }
    }
  }
  console.log(minpos, maxpos);
  for (let num in minpos) {
    let area = (maxpos[num][0] - minpos[num][0] + 1) * (maxpos[num][0] - minpos[num][1] + 1);
    maxArea = Math.max(maxArea, area);
  }
  console.log(maxArea);
}

3
1 1 1
 
输出 0
说明：选出 1 1 1，得到 0，最终数组转换为 []，最后没有剩下银块，返回 0
 
3
3 7 10
输出 1
说明：选出 3 7 10，需要计算 (7-3) 和 (10-7) 的差值，即(7-3)-(10-7)=1，所以数组转换为 [1]，剩余一块，返回该块重量，返回 1

function lastWeight(arr) {
  arr.sort((a, b) => {
    return b - a;
  })
 
  while (arr.length >= 3) {
    let z = arr.shift();
    let y = arr.shift();
    let x = arr.shift();
 
    if (x == y && y == z) {
      continue;
    } else {
      let remaining = 0;
      if (x === y && y < z) {
        remaining = z - y;
      } else if (x < y && y == z) {
        remaining = y - x;
      } else {
        remaining = Math.abs((z - y) - (y - x));
      }
      if (remaining !== 0) {
        arr.push(remaining);
      }
      arr.sort((a, b) => b - a);
    }
  }
 
  if (arr.length === 0) {
    console.log(0);
  } else {
    console.log(arr[0])
  }
}

10
1 2 1 2 1 2 1 2 1 2
5
 
输出 
2
1
2
在这个例子中，内存页框号 1 和 2 都被访问了 5 次，达到了阈值，因此它们被标记为热内存页。输出首先是热内存页的数量 2，然后是按照访问频次降序排列的页框号 1 和 2(频次一样的页框号，页框号小的排前面)。
 
 
5
1 2 3 4 5 
3
输出 0
 
在这个例子中，没有任何内存页的访问次数达到阈值 3，因此没有热内存页，输出为 0。

// records [1, 2, 1, 2, 3]
function memoryColdHotMark(recordsNum, records, threshold) {
  let pageFrequency = records.reduce((acc, curr) => {
    acc[curr] = (acc[curr] || 0) + 1;
    return acc;
  }, {}) // 获取每个页面的访问频率计数
  console.log(pageFrequency)
  let hotPage = Object.entries(pageFrequency).filter(([page, freq]) => {
    return freq >= threshold
  })
  if (hotPage.length > 0) {
    hotPage.sort((a, b) => {
      return pageFrequency[b] - pageFrequency[a] || a - b;
    })
    console.log(hotPage.length)
    hotPage.forEach(value=> {
      console.log(Number(value[0]))
    })
  }
}

输入：aabbcc
输出：a2b2c2
 
输入：bAaAcBb
输出：a3b2b2c0
 
bAaAcBb:
第一个b非连续字母，该字母之后字符串中还出现了2次(最后的两个Bb) ，所以输出b2
a连续出现3次，输出a3，
c非连续，该字母之后字符串再没有出现过c，输出c0
Bb连续2次，输出b2
对b2a3c0b2进行排序，最终输出a3b2b2c0

function getStringNum (str) {
  str = str.toLowerCase();
  let sb = ''
  let charCount = new Array(128).fill(0);
  for (let i = 0; i < str.length; i++) {
    let ch = str[i]
    if (ch >= 'a' && ch <= 'z') { // 如果是一个字母
      sb += ch;
      charCount[ch.charCodeAt()]++;
    }
  }
  let ans = []
  let input = sb + ' '
  let pre = input.charAt(0);
  let repeat = 1;
  charCount[pre.charCodeAt()]--;
  for (let i = 1; i < input.length; i++) {
    let cur = input[i];
    charCount[cur.charCodeAt()]--;
    if (cur === pre) {
      repeat++;
    } else {
      // 如果cur 和 pre字符不是同一个字符，表示出现了非连续字符
      ans.push(pre + (repeat > 1 ? repeat : charCount[pre.charCodeAt()]))// 将pre的摘要添加进ans中
      pre = cur;
      repeat = 1;
    }
  }
  ans.sort((a, b) => {
    if (a.charAt(a.length - 1) !== b.charAt(a.length - 1)) {
      // 最后一个字符不相等
      return b.charAt(b.length - 1) - a.charAt(a.length - 1);
    } else {
      return a.charAt(0) - b.charAt(0);
    }
  })
 
  let res = ''
  for (let an of ans) {
    res += an;
  }
  console.log(res);
}

输入：
1,2,5,-21,22,11,55,-101,42,8,7,32
 
输出：
1,-21,11,-101,2,22,42,32,5,55,7,8

这道题目是关于排序算法的问题，具体来说是按照数组元素的十进制最低位及元素索引位置进行排序。、
 
解题思路
首先，读入非空数组，将数组中的每个元素按照题目要求计算其十进制最低位，并记录下来该元素的索引位置和原始值。
创建一个辅助数组或列表，将每个元素的十进制最低位、索引位置和原始值组成一个元组，放入辅助数组中。
使用排序算法对辅助数组进行排序，排序规则是按照十进制最低位从小到大排序，如果最低位相同，则按照索引位置从小到大排序。
排序完成后，从辅助数组中提取原始值，即为排序后的结果。

function getSortedArr (arr) {
  arr.sort((a, b) => {
    let akey = a > 0 ? a % 10 : -a % 10;
    let bkey = b > 0 ? b % 10 : -b % 10;
    return akey - bkey;
  })
  console.log(arr);
}

1,3,3,3,2,4,4,4,5
 
输出 3,4,1,2,5

function uniqueArrarSort(arr) {
  let map = new Map();
  let uniqueArr = [];
  for (let i = 0; i < arr.length; i++) {
    let count = map.get(arr[i]) || 0;
    map.set(arr[i], count + 1);
    if (uniqueArr.indexOf(arr[i]) === -1) {
      uniqueArr.push(arr[i])
    }
  }
 
  uniqueArr.sort((a, b) => {
    if (map.get(a) === map.get(b)) {
      return null;
    } else {
      return map.get(b) - map.get(a);
    }
  })
}