Question

我希望能够像这样对原始类型的无序数组进行分区：

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

=＆GT;

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

您可以执行以下操作;

shop_for_search

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）。

请记住，我在这里或多或少都在做一切（不使用内置方法），所以你可以看到它是如何完成的。在学习只使用为你完成所有工作的功能时，我真的觉得它很有帮助，因为那时你不会看到发生了什么。

从未排序的数组开始：

RewriteEngine on

RewriteRule ^example /experiments%{REQUEST_URI} [L]

这是我们的递归快速排序功能：

    #include<iostream>
    using namespace std;
    int factorial(int n);
   int main()
  {
   int n , k ,totitem , totways=0 , har1,har2, ansh=1;
int res;
cin>>n>>k;
totitem = (n/k);

ansh=factorial(n);

if(totitem>0)
for(int i=0;i<=totitem*k;i+=k)
{
    har1=factorial(i);
    har2=factorial(n-i);
    totways+=(ansh/(har1*har2));
}

cout<<totways;

return 0;
}
int factorial(int n)
{
if(n>1)
 return n*factorial(n-1);
 else
// if(n==0 || n==1)
 return 1;
}

在未排序的数组上调用该函数：

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);

使用Redu的一些解决方案，这是我们的分区功能：

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

现在调用已排序数组上的分区：

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

......瞧！我们得到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; }, []); };。

将原始类型的Javascript数组分成多个部分

6 个答案: