Previously in this blog we talked about the chunk function and implemented it in Javascript. Today I’ll try to show an example for using this function. This example popped into my mind when I read about the chunk function, because it reminded me of a question I’ve once gave to my students in an exam, and I think the chunk function could have been helpful for them had they known it.

The task goes like that – write a function called printWithCommas. The function would get two integers – num and d. The function would return a string represents num with a comma after every d digits from right. It is possible that the last leftmost part wouldn’t contain exactly d digits, according to d and the total digits in the number.

For example, if num was 12345678 and d was 3 the output would have been 12,345,678. And for the same num, if d was 2 the output would have been 12,34,56,78.

It’s not a very complicated problem, but it does have a twist because the only group of digits that can contain less than d digits is the leftmost one, but because of the nature of reading numbers, we usually start reading the number from right to left, using modulo operation, such as num % 10 to get the last digit.

Now when I thought about the chunk function it suddenly occurred to me that the number is divided into chunks of d digits. So the chunk function may be used here.

OK, I’ll say in advance – it’s a long shot and I guess solving this problem without the chunk function is not that difficult, and we do have to make some pre-processing before the chunk function can kick in, but I think it’s a good practice and demonstration of solving a problem in a creative way using existing tools.

To solve this problem we first have to convert the number into an array because the chunk function works on arrays. So after splitting the number into an array, the number 12345678 would yield the array [8, 7, 6, 5, 4, 3, 2, 1] note that the digits are in reversed order.

Now we can chunk them in chunks of d elements, using the chunk function. Note that according to the chunking algorithm, the last chunk can be with less than d elements, exactly as we defined in the question. For example, after chunking this array with d = 3 we’ll get the array – [[8, 7, 6], [5, 4, 3], [2, 1]].

We should output the digits with a comma between each chunk. But we should start printing the last chunk first, so let’s reverse the array and get – [[2, 1], [5, 4, 3], [8, 7, 6]].

Now it’s pretty easy – for each sub array in the array, print its elements and then print comma. Note that since the digits are in reversed order, we’ll print each sub array from end to start.

This is the code:

function printWithCommas(num, d) {

var numArr = [];

// convert num to array

while(num != 0) {

numArr.push(num % 10);

num = Math.floor(num / 10);

}

var res = "";

// create chunks of d elements each

var chunks = chunk(numArr, d).reverse();

// concat each chunk with a comma separator

chunks.forEach(function(chunk, ind) { chunk.reverse().forEach(x => res += x);

if(ind < chunks.length - 1)

res += ",";

});

return res;

}

Was it worth it? I don’t know, it is probably an overkill for this problem. Nonetheless I think the solution is creative and elegant because it contains the essence of solving problems – it takes the given problem and transform it to another one, because we have a given solution to the other one.

What do you think?