计算忽略重叠数的数字数组的总数[关闭]答案

【问题标题】：Count total of number array with ignoring overlap number [closed]计算忽略重叠数的数字数组的总数[关闭]
【发布时间】：2022-01-06 13:29:16
【问题描述】：

我有这种问题，并试图通过使用 Javascript/Go 来解决它。给定这个数字集数组，我想找到数字的总和。计算应忽略重叠并考虑将其仅计为一次。

const nums = [[10, 26], [43, 60], [24,31], [40,50], [13, 19]]

如果翻译成图片会像下面这样。

结果应该41

规则是

重叠的一组数字（粉色区域）应该算一次。
计算绿化面积的总和。
两者合计。

任何帮助将不胜感激。

【问题讨论】：

漂亮的图片。出了什么问题？
结果不应该是41吗？ (31 - 10) + (60 - 40)
@HaoWu 不错，应该是 41 岁。

标签： javascript arrays algorithm go math

【解决方案1】：

这是一个使用 javascript 的单行解决方案（假设正确答案是 41 而不是 42）。

这个想法是迭代所有区间数并将它们放在一个数组中，然后使用Set 修剪所有重复项。时间复杂度不是最优的，但足够短。

const nums = [[10, 26], [43, 60], [24, 31], [40, 50], [13, 19]];

const total = new Set(nums.reduce((acc, [from, to]) => 
  [...acc, ...Array.from({ length: to - from }, (_, i) => i + from)], [])).size;

console.log(total);

不确定如何使用 go，但这只是一个建议。

【讨论】：

Go 中没有单行代码。

【解决方案2】：

您可以通过检查第二个值对对进行排序并减少，然后添加增量以获得总和。

const
    nums = [[10, 26], [43, 60], [24, 31], [40, 50], [13, 19]],
    result = nums
        .sort((a, b) => a[0] - b[0] || a[1] - b[1])
        .reduce((r, [...a]) => {
            const last = r[r.length - 1];
            if (last && last[1] >= a[0]) last[1] = Math.max(last[1], a[1]);
            else r.push(a);
            return r;
        }, [])
        .reduce((s, [l, r]) => s + r - l, 0);

console.log(result)

【讨论】：

它首先按第一个值排序，然后按升序排列第二个值。

【解决方案3】：

这是我的版本：

const getCoverage = arr => arr
  .reduce((results, el) => {
    if (!results.length) { 
      return [el];
    }
    let running = true, i = 0;
    while(running && i < results.length) {
      if (el.some(n => n >= results[i][0] && n <= results[i][1])) {
        results[i] = [
          Math.min(el[0], results[i][0]),
          Math.max(el[1], results[i][1])
        ];
        running = false;
      } 
      i++;
    }
    if (running) {
      results.push(el);
    }
    return results;
  }, [])
  .reduce((total, el) => el[1] - el[0] + total, 0);

console.log(
  getCoverage([[10, 26], [43, 60], [24,31], [40,50], [13, 19]])
);

第一个 reducer 合并重叠（和相邻）的间隔，第二个将结果合并的差异相加。

【讨论】：

【解决方案4】：

您可以将给定二维数组的值分布在一个数组中并对它们进行排序。求非重叠数组的边缘值的差值之和与重叠区域内的值之差之和，结果就是两者的差值。

const nums = [[10, 26], [43, 60], [24, 31], [40, 50], [13, 19]]
let arr = []
//spread given 2-D array
nums.forEach(item => arr=[...arr,...item]);
// Sort both arrays
arr.sort();
nums.sort();
let previtem, sum = 0;
let min , max ;
let count = 0;
//Loop to find sum of difference between non-overlapping values
nums.forEach((item,index) => {
        if (index === 0) {
           min = nums[0][0], max = nums[0][1]     
        }
        else if (!(item[0]>min && item[0]<max) && !(item[1]>min && item[1]<max))
        {
                flag = 1;
                count = count + (item[0] - max);
                min = item[0];
                max = item[1];
                console.log(item,count);
        }
        else if (item[0]>min && item[0]<max &&  !(item[1]>min && item[1]<max)) {
                max = item[1];
        }
})

// loop to find sum of difference of unique values within overlapping area
arr.forEach(item => {
        if (previtem && item !== previtem) {
                sum=sum+(item-previtem)
        }
        previtem = item;
})

//Print the result
console.log(sum - count);

【讨论】：