Determine the frequency of each element in an array and arrange them in ascending order

Question

Determine the frequency of each element in an array and arrange them in ascending order

In my quest to locate occurrences of numbers within an array, I aimed to display the numbers and their respective frequencies in ascending order. Here is what I was trying to achieve:

let arr = [9,-10,2,9,6,1,2,10,-8,-10,2,9,6,1];

// {'-10': 2, '-8': 1, '1': 2, '2': 3, '6': 2, '9': 3, '10': 1}

To accomplish this task, I stored the occurrences of each number in an object. However, upon logging the numCount object, I noticed that while all the numbers were sorted in ascending order, the negative numbers did not follow suit.

/*Find occurrences*/
let numCount = {};
for(let num of arr){
    numCount[num] = numCount[num] ? numCount[num] + 1 : 1;
}
console.log(numCount);
//{ '1': 2, '2': 3, '6': 2, '9': 3, '10': 1, '-10': 2, '-8': 1 }

I researched how to sort objects and learned that one method involved storing them in an array and then sorting it. So, I attempted the following approach:

/*Store them in array and then sort it*/
let sortedArray = [];
for(let item in numCount){
    sortedArray.push([item, numCount[item]]);
}
sortedArray.sort(function(a,b){
    return a[0] - b[0];
});

/*
console.log(sortedArray);
[
  [ '-10', 2 ],
  [ '-8', 1 ],
  [ '1', 2 ],
  [ '2', 3 ],
  [ '6', 2 ],
  [ '9', 3 ],
  [ '10', 1 ]
]
*/

However, the resulting sortedObject displayed the negative numbers at the end, similar to the initial state. This is the hurdle I am currently facing.

let sortedObject = {};
sortedArray.forEach(function(item){
    sortedObject[item[0]] = item[1];
})
/*console.log(sortedObject);
{ '1': 2, '2': 3, '6': 2, '9': 3, '10': 1, '-10': 2, '-8': 1 }
*/

Here is the full code snippet:

let arr = [9,-10,2,9,6,1,2,10,-8,-10,2,9,6,1];

/*Find occurrences*/
let numCount = {};
for(let num of arr){
    numCount[num] = numCount[num] ? numCount[num] + 1 : 1;
}

/*Store them in array and then sort it*/
let sortedArray = [];
for(let item in numCount){
    sortedArray.push([item, numCount[item]]);
}
sortedArray.sort(function(a,b){
    return a[0] - b[0];
});


let sortedObject = {};
sortedArray.forEach(function(item){
    sortedObject[item[0]] = item[1];
})

console.log(sortedObject);

javascript arrays sorting object

Answer 1

Answer №1

Rules are in place for the sorting of keys/properties within an object, ensuring they are reliably ordered as long as you understand these rules.

If a property resembles a positive number (in reality, all properties are actually strings even if they appear to be numbers), it will be sorted in ascending order. Otherwise, it will maintain the order of insertion. But how does the object determine if a property value is similar to a number or not?

Let's take key '9': initially, it is converted into the number 9, then back to a string '9' - just like the original value. This categorizes it as a positive number-similar value.

Now, let's consider key '-10': when converted to a number, it becomes -10.

As it is not positive, it is considered a string... and this logic applies to the rest as well.

Hence, it becomes evident that sorting for properties resembling positive numbers was not truly necessary. Regardless of whether the input array is sorted or not, the outcome remains consistent due to the established rules.

solution:

When handling key '09': after being turned into the number 9, it differs from the initial value upon conversion back to a string. Hence, it is categorized as a string.

Therefore, a '0' should be added before every numeric-like property to convert and sort it accordingly.

sortedArray.forEach(function(item){
    let key = parseInt(item[0])>0 ? '0'+item[0] : item[0]
    sortedObject[key] = item[1];
})
//{ "-10": 2, "-8": 1, 01: 2, 02: 3, 06: 2, 09: 3, 010: 1 }

Note that the behavior of parseInt varies for numbers like 010, assuming them to be Octal.

An alternative and more effective solution involves using map - explore Maps and their distinctions from Objects further here.

Answer 2