 # Daily Coding Challenge: Weight for weight – written in JavaScript Posted by

2 min read ~ Hello readers! It’s really important for me to continue my practice and learning. Lately, I have been completing a coding challenge a day with codewars. This helps me keep my skills sharp and see how other devs all over the planet would solve these problems. Being able to see other solutions expands my mind for solving future problems in a clever and efficient way. Today. the problem set focuses on JavaScript and some of the important functions that we can leverage in our applications.

Weight for weight

My friend John and I are members of the “Fat to Fit Club (FFC)”. John is worried because each month a list with the weights of members is published and each month he is the last on the list which means he is the heaviest.

I am the one who establishes the list so I told him: “Don’t worry any more, I will modify the order of the list”. It was decided to attribute a “weight” to numbers. The weight of a number will be from now on the sum of its digits.

For example `99` will have “weight” `18``100` will have “weight” `1` so in the list `100` will come before `99`. Given a string with the weights of FFC members in normal order can you give this string ordered by “weights” of these numbers?

Example:

`"56 65 74 100 99 68 86 180 90"` ordered by numbers weights becomes: `"100 180 90 56 65 74 68 86 99"`

When two numbers have the same “weight”, let us class them as if they were strings (alphabetical ordering) and not numbers: `100` is before `180` because its “weight” (1) is less than the one of `180` (9) and `180` is before `90` since, having the same “weight” (9), it comes before as a string.

All numbers in the list are positive numbers and the list can be empty.

Notes:

it may happen that the input string have leading, trailing whitespaces and more than a unique whitespace between two consecutive numbers

JavaScript solution:

```function orderWeight(strng) {
// generate new obj
let obj = {};
// use truthy to check for value
if (strng) {
// split string and iterate over each index of integers
strng.split(" ").forEach( (str) => {
// convert the string into a number and reduce the numbers into one value
let total = str.split('').map(Number).reduce((accumulator, currentValue) => accumulator + currentValue )
// because JS only allows unique keys in objects, this lets us relate multiple
!obj[total] ? obj[total] = [str] : obj[total].push(str)
});
}

let orderedObj = {};
Object.keys(obj).sort().forEach( (key) => {
orderedObj[key] = obj[key];
});

let finalArr = [];
Object.keys(orderedObj).forEach( (key) => {
orderedObj[key].length > 1 ? finalArr = [...finalArr, ...orderedObj[key].sort()] : finalArr.push(orderedObj[key])
});

return finalArr.join(' ')
}
```

The above algorithm was great fun to solve! Notably, because we get to use the reduce function to evaluate all of the potential integers that we are iterating over to get their sum.