將原始類型的Javascript數組分成多個部分

Question

我希望能夠像這樣對無序的基本類型數組進行分區：

var array = [102,103,104,201,203,204,303,301,302,405,406,408,101];

=>

newArray = [[101,102,103,104],[201,203,204],[303,301,302],[405,406,408]]

根據第一個整數將數組划分為段。

該數組將根據類似於此表達式的內容進行分區：

array[i]/100|0 === j;

其中j可以是1,2,3或4。

例如。 405/100|0 === 4 // partition into the array starting with 4.

有沒有人知道我可以根據第一個數字有效地過濾這個數組的方式？

我知道我可以將lodash分區函數與集合一起使用，但我需要將初始數組作為速度的原始類型。 即使這樣，分區也只會將數組分成兩部分。

提前致謝！

Answer 1

您可以這樣做;

 var arr = [102,103,104,201,203,204,303,301,302,405,406,408,101], result = arr.reduce((res,e) => { var idx = e/100|0; res[idx-1] = res[idx-1] ? res[idx-1].concat(e) : [e]; return res; },[]) .map(subarr => subarr.sort((a,b) => ab)); console.log(result); 

Answer 2

似乎要調用Array.reduce ：

var a = [102,103,104,201,203,204,303,301,302,405,406,408,101];

a.reduce (
  function (r, v) { 
    var d = +v.toString ().slice (0,1);
    r[d] && r[d].push (v) || (r[d] = [v]);
    return r; 
  }, [])

Answer 3

你可以使用lodash函數鏈接

var array = [404,101,102,103,104,201,203,204,303,301,302,405,406,408];
var newArray = _(array)
  .groupBy(function (x) { return x / 100 | 0; })
  .values()
  .value();

Answer 4

如我錯了請糾正我。 你有一個包含像[101,102,103,201,202,203]這樣的整數的數組，並且你想將它轉換為包含以[[101,102,103]，[201]相同整數開頭的整數的數組數組，202,203]]。

所以，這是一個簡單的解決方案：

// This object will contain partitioned array
var newObject = {};

for(var i = 0; i < arr.length; i++) {
  var index = arr[i] / 100;
  if(index in newObj)
    newObj[index].push(arr[i]);
  else
    newObj[index] = [arr[i]];
}

在此之后，您將獲得一個具有1,2,3等屬性的對象，作為回報，它將包含從索引1,2,3開始的數字數組。

現在，如果你想要數組的數組

var newArr = [];
$(newObj).each(function() {newArr.push(this)});

如果您有任何疑問，請告訴我。

Answer 5

這使用了lodash的groupBy功能：

var array = [404,101,102,103,104,201,203,204,303,301,302,405,406,408];

var grouped = _.groupBy(array, function(x) {return x.toString()[0]});

var newArray = []
for (var key in grouped) {
    newArray.push(grouped[key]);
}

Answer 6

首先，您需要對數組進行排序。 你可以這樣做，但是對於這個例子，我會使用quicksort。 時間復雜度為O（n * log n）。

請記住，我在這里或多或少都在做一切（不使用內置方法），所以你可以看到它是如何完成的。 在學習只使用為你完成所有工作的函數時，我並不覺得它有用，因為那時你看不到發生了什么。

從未排序的數組開始：

let unsortedArray = [403, 101, 203, 102, 302, 103, 201, 202, 301, 303, 401, 402];

這是我們的遞歸快速排序功能：

let quicksort = arr => {
        if (arr.length < 2) {
            return arr;
    }

    let pivotIndex = rand(0, arr.length),
        pivot = arr[pivotIndex],
        less = [],
        more = [],
        sorted = [];

    for (let i = 0, len = arr.length; i < len; i++) {
        if (pivotIndex !== i) {
            if (arr[i] > pivot) {
                more.push(arr[i]);
            } else {
                less.push(arr[i]);
            }
        }
    }

    return sorted.concat(quicksort(less)).concat([pivot]).concat(quicksort(more));
};

let rand = (min, max) => {
    return Math.floor( Math.random() * (min - max) + max );
};

在未排序的數組上調用該函數：

let sortedArray = quicksort(unsortedArray);

現在我們得到：

[101, 102, 103, 201, 202, 203, 301, 302, 303, 401, 402, 403]

好的，所以現在數組已經排序了。

讓我們將這個數組分成幾組，使它看起來像這樣：

[ [101, 102, 103], [201, 202, 203], [301, 302, 303], [401, 402, 403] ]

使用一點Redu的解決方案，這是我們的分區功能：

let partition = arr => { 
    return arr.reduce((prev, curr) => { 
        let remainder = curr % 100;

        if (prev[remainder - 1]) {
            prev[remainder - 1] = prev[remainder - 1].concat(curr);
        } else {
            prev[remainder - 1] = [curr];
        }

        return prev;
    }, []);
};

現在調用排序數組上的分區：

let partitionedArray = partition(sortedArray);

......瞧！ 我們得到[ [101, 102, 103], [201, 202, 203], [301, 302, 303], [401, 402, 403] ] 。