Solving programming problems is one of the really fun things we programmers really like doing. The good ol' number to words conversion is one such problem - in management lingo - one such challenge. No matter what the buzzword - docker, kubenetes etc., the basics never go away.
Long time ago ...
I was in college when my friend and I worked on this program as a challenge who would finish it first. I think both of us took a good 5 - 6 hours, he finished it 15 minutes before me but his algorithm topped out at a lesser limit than mine. I really miss those days ...
Doing it again ...
While going through some C++ training material, I came across this problem today and thought how I would fare 17 years later. To my surprise I completed the problem in less than 15 minutes and with a whole lot more confidence that the program will perform correctly. I also noticed that my approach to problem solving has changed so much. I distinctly remember how I was trying to create a for-next loop for breaking a large number like 5406189921 into its parts - units, tens, hundreds. Back in college I think this is what I felt as the first complexity that needed solving. However this time around I hardly thought about this, I was rather identifying parts of the answer and not the problem which are unique e.g. 1 is one and 2 is two .. and 9 is nine. 20 is twenty and numbers between 100 and 999 (inclusive) hundreds. I think this was more in line with TDD which I have been following for the past few years and I was glad that my thinking (right or wrong) has changed. Pretty soon I had the various rules put down and using recursion to break the problem up came almost naturally without any thought.
The point ...
We all are learning lots of things at a tremendous pace but we don't realize that this is happening. Maybe others sometimes notice this but we ourselves seem to be oblivious of this. Going back to things which we did earlier and then looking at them with a new understanding is a great way to appreciate how each one of us is learning & growing. I think its really important we appreciate the world, the opportunities, each other and most of all our self as we move on in this fast paced life.
The code ...
OK, so getting to the code, here it is. I am sure you'll be able to write an even more efficient version of this, but here goes...
typedef __int64 numeric;
const std::string NumericToString(const numeric l) {
switch (l) {
case 0:
return "zero";
case 1:
return "one";
case 2:
return "two";
case 3:
return "three";
case 4:
return "four";
case 5:
return "five";
case 6:
return "six";
case 7:
return "seven";
case 8:
return "eight";
case 9:
return "nine";
case 10:
return "ten";
case 11:
return "eleven";
case 12:
return "twelve";
case 13:
return "thirteen";
case 14:
return "fourteen";
case 15:
return "fifteen";
case 16:
return "sixteen";
case 17:
return "seventeen";
case 18:
return "eighteen";
case 19:
return "nineteen";
case 20:
return "twenty";
case 30:
return "thirty";
case 40:
return "forty";
case 50:
return "fifty";
case 60:
return "sixty";
case 70:
return "seventy";
case 80:
return "eighty";
case 90:
return "ninety";
}
if (l > 9999999 && l < 10000000000) {
numeric crore_part;
numeric remaining_part;
crore_part = l / 10000000;
remaining_part = l % 10000000;
return NumericToString(crore_part) + (crore_part == 1 ? " crore " : " crores ") + NumericToString(remaining_part);
}
else if (l > 99999 && l < 10000000) {
numeric lakh_part;
numeric remaining_part;
lakh_part = l / 100000;
remaining_part = l % 100000;
return NumericToString(lakh_part) + (lakh_part == 1 ? " lakh " : " lakhs ") + NumericToString(remaining_part);
}
else if (l > 999 && l < 100000) {
numeric thousand_part;
numeric remaining_part;
thousand_part = l / 1000;
remaining_part = l % 1000;
return NumericToString(thousand_part) + " thousand " + NumericToString(remaining_part);
}
else if (l > 99 && l < 1000) {
if (l == 100) {
return "hundred";
}
else {
numeric hundred_digit = l / 100;
numeric remaining_digits = l % 100;
return NumericToString(hundred_digit) + " hundred " + NumericToString(remaining_digits);
}
}
else if (l < 100) {
numeric first_digit = l / 10 * 10;
numeric second_digit = l % 10;
return NumericToString(first_digit) + "-" + NumericToString(second_digit);
}
else {
return "out-of-range";
}
}
Sample output
5406189921 is five hundred forty crores sixty-one lakhs eighty-nine thousand nine hundred twenty-one
As of now the program tops out at 9999999999.