Question

我试图找到解析数组的算法。它应该做什么：在输入中输出两个数组first_array=[[10,25], [30,45], [50,60]]和second_array=[35, 40]它应该返回一个数组[[10,25], [30,35], [40,45], [50,60]]。正如您猜测的那样需要second_array[1]并与first_array[each][1]进行比较并创建子阵列。到目前为止我得到了（代码如下）。一些如何在if语句中我需要两个返回。第二个参数也可以是多个数组。

/*---- First part of problem ----*/
const first_array=[[10,25], [30,45], [50,60]];
const second_array=[35, 40];

const result = first_array.map(record => {
  if (second_array[0] > record[0] && second_array[0] < record[1]) {
    return [[record[0], second_array[0]], [second_array[1], record[1]]]
  } else {
    return record
  }
});

console.log(result)

// result [  [10,25] , [[30,35],[40,45]] , [50,60]  ]
// expect [  [10,25] , [30,35] , [40,45] , [50,60]  ]

/*---- Second part of problem ----*/
const first_array=[15, 60];
const second_array=[[25,30], [30,40], [45,55]];

// [[15, 60]]
// [[15, 25], [30, 60]]
// [[15, 25], [30, 30], [40, 60]]
//output// [[15, 25], [30, 30], [40, 45], [55, 60]]

Answer 1

首先我加入数组，然后对它们进行排序和拆分

var a=[[10,25], [30,45], [50,60]]
var b=[35, 40];

var sorted=[].concat.apply([], a,b).sort();

var pairs = [];

for(var i = 0; i < sorted.length; i += 2)
{
    pairs.push(sorted.slice(i, i + 2));
}

Answer 2

您可以使用Generator作为数组，并为嵌套数组使用相同的生成器。

然后检查值是否有序并通过检查收集器数组的长度来更新结果数组。

继续，直到两台发电机都返回完成。

function combine(leftArray, rightArray) {

    function* getElements(array) {
        var i = 0;
        while (i < array.length) {
            if (Array.isArray(array[i])) {
                yield* getElements(array[i])
            } else {
                yield array[i];
            }
            i++;
        }
    }

    function update(value) {
        temp.push(value);
        if (temp.length === 2) {
            result.push(temp);
            temp = [];
        }
    }

    var left = getElements(leftArray),
        right = getElements(rightArray),
        l = left.next(),
        r = right.next(),
        temp = [],
        result = [];

    while (!l.done || !r.done) {
        if (r.done || !l.done && l.value < r.value) {
            update(l.value);
            l = left.next();
            continue;
        }
        if (l.done || !r.done && r.value < l.value) {
            update(r.value);
            r = right.next();
        }
    }
    if (temp.length) {
        result.push(temp);
    }
    return result;
}

console.log(combine([[10, 25], [30, 45], [50, 60]], [[12, 42], [67, 69]]));

.as-console-wrapper { max-height: 100% !important; top: 0; }

对于未排序的数组，您可以对阵列进行平坦处理，对其进行排序和分组。

function combine(left, right) {
    const flat = (r, a) => Array.isArray(a) ? a.reduce(flat, r) : [...r, a];
    return [left, right]
        .reduce(flat, [])
        .sort((a, b) => a - b)
        .reduce((r, a, i) => (i & 1 ? r[r.length - 1].push(a) : r.push([a]), r), []);
}

console.log(combine([[20, 19], [30, 45], [9, 5]], [[12, 42], [67, 69]]));

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 3

这是一种有趣的方法，我希望它很快。

我们有一个数组scaner函数函数，它像地图一样工作。采用一个函数来修改每个元素，同时更新一个保持在关闭状态的累加器。我们在这里使用的函数是一个分拣机，它采用2个数组的大小，并将最小的项目排在一个，其余项目在另一个中。因此sorter([1,5], [3,7])会[1,3]，而累加器会更改为[5,7]。这是;

＆＃13;

var first_array  = [[10,25], [30,45], [50,60]],
    second_array = [28,46],
    merger       = (a,f,t) => a.map((t => e => f(e,t))(t)).concat([t]),
    sorter       = (a,b) => a[1] < b[1] ? a[1] < b[0] ? a
                                                      : a[0] < b[0] ? ([a[1],b[0]] = [b[0],a[1]], a)
                                                                    : ([a[1],b[0]] = [b[0],a[1]], a.reverse())
                                        : a[0] > b[1] ? ([a[0],b[0]] = [b[0],a[0]], [a[1],b[1]] = [b[1],a[1]], a)
                                                      : a[0] > b[0] ? ([a[0],b[1]] = [b[1],a[0]], [a[0],b[0]] = [b[0],a[0]], [a[1],b[1]] = [b[1],a[1]], a)
                                                                    : ([a[1],b[0]] = [b[0],a[1]], b.reverse(), a),
    result       = merger(first_array,sorter,second_array);
console.log(JSON.stringify(result));

＆＃13;

Answer 4

使用reduce代替map

const first_array=[[10,25], [30,45], [50,60]];
const second_array=[35, 40];

const result = first_array.reduce((a, record) => {
  if (second_array[0] > record[0] && second_array[0] < record[1]) {
    a.push([record[0], second_array[0]])
    a.push([second_array[1], record[1]])
  } else {
    a.push(record)
  }

  return a
}, [])

console.log(result)

根据元素的数字顺序合并两个数组

4 个答案: