To begin, it's important to organize your array by sorting it. There are various ways to do this, but in this instance, I'll demonstrate using quicksort. The time complexity for this operation is O (n * log n).
Keep in mind that everything demonstrated here is done manually without utilizing built-in methods. This allows for a clear understanding of the process rather than relying on pre-existing functions.
We start with an unsorted array:
let unsortedArray = [403, 101, 203, 102, 302, 103, 201, 202, 301, 303, 401, 402];
This is our recursive quicksort function:
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 );
};
The function is then applied to the unsorted array:
let sortedArray = quicksort(unsortedArray);
The resulting sorted array is:
[101, 102, 103, 201, 202, 203, 301, 302, 303, 401, 402, 403]
With the array now sorted, we proceed to partition it into groups as follows:
[ [101, 102, 103], [201, 202, 203], [301, 302, 303], [401, 402, 403] ]
Utilizing Redu's solution, here is the partition function implemented:
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;
}, []);
};
We then apply the partition function to the sorted array:
let partitionedArray = partition(sortedArray);
Resulting in the grouped array:
[ [101, 102, 103], [201, 202, 203], [301, 302, 303], [401, 402, 403] ]
.