Given an integer N, the task is to convert the given number into words.
Examples :
Input: N = 438237764
Output: Four Hundred Thirty Eight Million Two Hundred Thirty Seven Thousand Seven Hundred Sixty FourInput: N = 1000
Output: One Thousand
Approach: This approach is valid for converting number into words for up to 20 digits, and is basically based on Brute Force Logic.
The idea is to break down the number into International Number System, i.e., smaller groups of three digits (hundreds, tens, and ones), and convert each group into words.
Consider the below illustration:
Suppose N = 1234567
Now, process this number N in groups of three digits from right to left.
Iteration 1:
- Current Group: 567
- Word Representation: Five Hundred Sixty-Seven
- Multiplier: “”
At this point, the partial word representation is “Five Hundred Sixty-Seven”.
Iteration 2:
- Current Group: 234
- Word Representation: Two Hundred Thirty-Four
- Multiplier: Thousand
The updated word representation becomes “Two Hundred Thirty-Four Thousand Five Hundred Sixty-Seven”.
Iteration 3:
- Current Group: 1
- English Representation: One
- Multiplier: Million
Hence, finally the given number into words becomes “One Million Two Hundred Thirty-Four Thousand Five Hundred Sixty-Seven“.
NOTE: The following code supports numbers up to 15 digits, i.e., numbers from 0 to trillions. The code prints according to the western number system.
Below is the implementation of the above approach:
#include <bits/stdc++.h> using namespace std;
string numberToWords( long long int n)
{ long long int limit = 1000000000000, curr_hun, t = 0;
// If zero return zero
if (n == 0)
return ( "Zero" );
// Array to store the powers of 10
string multiplier[] = { "" , "Trillion" , "Billion" ,
"Million" , "Thousand" };
// Array to store numbers till 20
string first_twenty[] = {
"" , "One" , "Two" , "Three" ,
"Four" , "Five" , "Six" , "Seven" ,
"Eight" , "Nine" , "Ten" , "Eleven" ,
"Twelve" , "Thirteen" , "Fourteen" , "Fifteen" ,
"Sixteen" , "Seventeen" , "Eighteen" , "Nineteen"
};
// Array to store multiples of ten
string tens[]
= { "" , "Twenty" , "Thirty" , "Forty" , "Fifty" ,
"Sixty" , "Seventy" , "Eighty" , "Ninety" };
// If number is less than 20, return without any further
// computation
if (n < 20)
return (first_twenty[n]);
// Answer variable to store the conversion
string answer = "" ;
for ( long long int i = n; i > 0;
i %= limit, limit /= 1000) {
// Store the value in multiplier[t], i.e n =
// 1000000, then r = 1, for multiplier(million), 0
// for multipliers(trillion and billion)
curr_hun = i / limit;
// It might be possible that the current multiplier
// is bigger than your number
while (curr_hun == 0) {
// Set i as the remainder obtained when n was
// divided by the limit
i %= limit;
// Divide the limit by 1000, shifts the
// multiplier
limit /= 1000;
// Get the current value in hundreds, as
// English system works in hundreds
curr_hun = i / limit;
// Shift the multiplier
++t;
}
// If current hundred is greater than 99, Add the
// hundreds' place
if (curr_hun > 99)
answer += (first_twenty[curr_hun / 100]
+ " Hundred " );
// Bring the current hundred to tens
curr_hun = curr_hun % 100;
// If the value in tens belongs to [1,19], add using
// the first_twenty
if (curr_hun > 0 && curr_hun < 20)
answer += (first_twenty[curr_hun] + " " );
// If curr_hun is now a multiple of 10, but not 0
// Add the tens' value using the tens array
else if (curr_hun % 10 == 0 && curr_hun != 0)
answer += (tens[curr_hun / 10 - 1] + " " );
// If the value belongs to [21,99], excluding the
// multiples of 10 Get the ten's place and one's
// place, and print using the first_twenty array
else if (curr_hun > 20 && curr_hun < 100)
answer += (tens[curr_hun / 10 - 1] + " "
+ first_twenty[curr_hun % 10] + " " );
// If Multiplier has not become less than 1000,
// shift it
if (t < 4)
answer += (multiplier[++t] + " " );
}
return (answer);
} // Driver code. int main()
{ // Input 1
long long int n = 36;
cout << numberToWords(n) << '\n' ;
// Input 2
n = 123456789;
cout << numberToWords(n) << '\n' ;
// Input 3
n = 10101010110001;
cout << numberToWords(n) << '\n' ;
// Input 4
n = 999999999;
cout << numberToWords(n) << '\n' ;
return 0;
} // This Code is contributed by Alok Khansali |
public class GFG {
static String numberToWords( long n)
{
long limit = 1000000000000L, curr_hun, t = 0 ;
// If zero return zero
if (n == 0 )
return ( "Zero" );
// Array to store the powers of 10
String multiplier[] = { "" , "Trillion" , "Billion" ,
"Million" , "Thousand" };
// Array to store numbers till 20
String first_twenty[] = {
"" , "One" , "Two" , "Three" ,
"Four" , "Five" , "Six" , "Seven" ,
"Eight" , "Nine" , "Ten" , "Eleven" ,
"Twelve" , "Thirteen" , "Fourteen" , "Fifteen" ,
"Sixteen" , "Seventeen" , "Eighteen" , "Nineteen"
};
// Array to store multiples of ten
String tens[] = { "" , "Twenty" , "Thirty" ,
"Forty" , "Fifty" , "Sixty" ,
"Seventy" , "Eighty" , "Ninety" };
// If number is less than 20, return without any
// further computation
if (n < 20L)
return (first_twenty[( int )n]);
String answer = "" ;
for ( long i = n; i > 0 ; i %= limit, limit /= 1000 ) {
// Store the value in multiplier[t], i.e n =
// 1000000, then r = 1, for multiplier(million),
// 0 for multipliers(trillion and billion)
// multiplier here refers to the current
// accessible limit
curr_hun = i / limit;
// It might be possible that the current
// multiplier is bigger than your number
while (curr_hun == 0 ) {
// Set i as the remainder obtained when n
// was divided by the limit
i %= limit;
// Divide the limit by 1000, shifts the
// multiplier
limit /= 1000 ;
// Get the current value in hundreds, as
// English system works in hundreds
curr_hun = i / limit;
// Shift the multiplier
++t;
}
// If current hundred is greater than 99, Add
// the hundreds' place
if (curr_hun > 99 )
answer += (first_twenty[( int )curr_hun / 100 ]
+ " Hundred " );
// Bring the current hundred to tens
curr_hun = curr_hun % 100 ;
// If the value in tens belongs to [1,19], add
// using the first_twenty
if (curr_hun > 0 && curr_hun < 20 )
answer
+= (first_twenty[( int )curr_hun] + " " );
// If curr_hun is now a multiple of 10, but not
// 0 Add the tens' value using the tens array
else if (curr_hun % 10 == 0 && curr_hun != 0 )
answer
+= (tens[( int )curr_hun / 10 - 1 ] + " " );
// If the value belongs to [21,99], excluding
// the multiples of 10 Get the ten's place and
// one's place, and print using the first_twenty
// array
else if (curr_hun > 20 && curr_hun < 100 )
answer
+= (tens[( int )curr_hun / 10 - 1 ] + " "
+ first_twenty[( int )curr_hun % 10 ]
+ " " );
// If Multiplier has not become less than 1000,
// shift it
if (t < 4 )
answer += (multiplier[( int )++t] + " " );
}
return (answer);
}
// Driver code
public static void main(String args[])
{
// Input 1
long n = 36L;
System.out.println(numberToWords(n));
// Input 2
n = 123456789 ;
System.out.println(numberToWords(n));
// Input 3
n = 10101010110001L;
System.out.println(numberToWords(n));
// Input 4
n = 999999999 ;
System.out.println(numberToWords(n));
}
} // This Code is contributed by Alok Khansali |
def numberToWords(n):
limit, t = 1000000000000 , 0
# If zero print zero
if (n = = 0 ):
print ( "zero" )
return
# Array to store the powers of 10
multiplier = [" ", " Trillion ", " Billion ", " Million ", " Thousand"]
# Array to store numbers till 20
first_twenty = [" ", " One ", " Two",
"Three" , "Four" , "Five" ,
"Six" , "Seven" , "Eight" ,
"Nine" , "Ten" , "Eleven" ,
"Twelve" , "Thirteen" , "Fourteen" ,
"Fifteen" , "Sixteen" , "Seventeen" ,
"Eighteen" , "Nineteen" ]
# Array to store multiples of ten
tens = [" ", " Twenty ", " Thirty ", " Forty ", " Fifty",
"Sixty" , "Seventy" , "Eighty" , "Ninety" ]
# If number is less than 20, print without any
if (n < 20 ):
print (first_twenty[n])
return
answer = ""
i = n
while (i > 0 ):
'''
Store the value in multiplier[t], i.e n = 1000000,
then r = 1, for multiplier(million), 0 for multipliers(trillion and billion)
multiplier here refers to the current accessible limit
'''
curr_hun = i / / limit
# It might be possible that the current multiplier is bigger than your number
while (curr_hun = = 0 ):
# Set i as the remainder obtained when n was divided by the limit
i % = limit
# Divide the limit by 1000, shifts the multiplier
limit / = 1000
# Get the current value in hundreds, as English system works in hundreds
curr_hun = i / / limit
# Shift the multiplier
t + = 1
# If current hundred is greater than 99, Add the hundreds' place
if (curr_hun > 99 ):
answer + = (first_twenty[curr_hun / / 100 ] + " tensundred " )
# Bring the current hundred to tens
curr_hun = curr_hun % 100
# If the value in tens belongs to [1,19], add using the first_twenty
if (curr_hun > 0 and curr_hun < 20 ):
answer + = (first_twenty[curr_hun] + " " )
# If curr_hun is now a multiple of 10, but not 0
# Add the tens' value using the tens array
elif (curr_hun % 10 = = 0 and curr_hun ! = 0 ):
answer + = (tens[(curr_hun / / 10 ) - 1 ] + " " )
# If the value belongs to [21,99], excluding the multiples of 10
# Get the ten's place and one's place, and print using the first_twenty array
elif (curr_hun > 19 and curr_hun < 100 ):
answer + = (tens[(curr_hun / / 10 ) - 1 ] + " " +
first_twenty[curr_hun % 10 ] + " " )
# If Multiplier has not become less than 1000, shift it
if (t < 4 ):
answer + = (multiplier[t] + " " )
i = i % limit
limit = limit / / 1000
print (answer)
# Input 1 n = 36
numberToWords(n) # Input 2 n = 123456789
numberToWords(n) # Input 3 n = 10101010110001
numberToWords(n) # Input 4 n = 999999999
numberToWords(n) # This code is contributed by Alok Khansali |
// Include namespace system using System;
public class numtowords {
public static String numberToWords( long n)
{
var limit = 1000000000000L;
long curr_hun;
var t = 0;
// If zero return zero
if (n == 0) {
return ( "Zero" );
}
// Array to store the powers of 10
String[] multiplier = { "" , "Trillion" , "Billion" ,
"Million" , "Thousand" };
// Array to store numbers till 20
String[] first_twenty = {
"" , "One" , "Two" , "Three" ,
"Four" , "Five" , "Six" , "Seven" ,
"Eight" , "Nine" , "Ten" , "Eleven" ,
"Twelve" , "Thirteen" , "Fourteen" , "Fifteen" ,
"Sixteen" , "Seventeen" , "Eighteen" , "Nineteen"
};
// Array to store multiples of ten
String[] tens = { "" , "Twenty" , "Thirty" ,
"Forty" , "Fifty" , "Sixty" ,
"Seventy" , "Eighty" , "Ninety" };
// If number is less than 20, return without any
// further computation
if (n < 20L) {
return (first_twenty[( int )n]);
}
var answer = "" ;
for ( long i = n; i > 0; i %= limit, limit /= 1000) {
// Store the value in multiplier[t], i.e n =
// 1000000, then r = 1, for multiplier(million),
// 0 for multipliers(trillion and billion)
// multiplier here refers to the current
// accessible limit
curr_hun = i / limit;
// It might be possible that the current
// multiplier is bigger than your number
while (curr_hun == 0) {
// Set i as the remainder obtained when n
// was divided by the limit
i %= limit;
// Divide the limit by 1000, shifts the
// multiplier
limit /= 1000;
// Get the current value in hundreds, as
// English system works in hundreds
curr_hun = i / limit;
// Shift the multiplier
++t;
}
// If current hundred is greater than 99, Add
// the hundreds' place
if (curr_hun > 99) {
answer += (first_twenty[( int )(( int )curr_hun
/ 100)]
+ " Hundred " );
}
// Bring the current hundred to tens
curr_hun = curr_hun % 100;
// If the value in tens belongs to [1,19], add
// using the first_twenty
if (curr_hun > 0 && curr_hun < 20) {
answer
+= (first_twenty[( int )curr_hun] + " " );
}
else if (curr_hun % 10 == 0 && curr_hun != 0) {
answer
+= (tens[( int )(( int )curr_hun / 10) - 1]
+ " " );
}
else if (curr_hun > 20 && curr_hun < 100) {
answer
+= (tens[( int )(( int )curr_hun / 10) - 1]
+ " "
+ first_twenty[( int )curr_hun % 10]
+ " " );
}
// If Multiplier has not become less than 1000,
// shift it
if (t < 4) {
answer += (multiplier[( int )++t] + " " );
}
}
return (answer);
}
// Driver code
public static void Main(String[] args)
{
// Input 1
var n = 36L;
Console.WriteLine(numtowords.numberToWords(n));
// Input 2
n = 123456789;
Console.WriteLine(numtowords.numberToWords(n));
// Input 3
n = 10101010110001L;
Console.WriteLine(numtowords.numberToWords(n));
// Input 4
n = 999999999;
Console.WriteLine(numtowords.numberToWords(n));
}
} |
function numberToWords(n)
{ let limit = 1000000000000, t = 0
// If zero console.log zero
if (n == 0)
{
console.log( "zero" )
return
}
// Array to store the powers of 10
let multiplier = [ "" , "Trillion" , "Billion" , "Million" , "Thousand" ]
// Array to store numbers till 20
let first_twenty = [ "" , "One" , "Two" ,
"Three" , "Four" , "Five" ,
"Six" , "Seven" , "Eight" ,
"Nine" , "Ten" , "Eleven" ,
"Twelve" , "Thirteen" , "Fourteen" ,
"Fifteen" , "Sixteen" , "Seventeen" ,
"Eighteen" , "Nineteen" ]
// Array to store multiples of ten
let tens = [ "" , "Twenty" , "Thirty" , "Forty" , "Fifty" ,
"Sixty" , "Seventy" , "Eighty" , "Ninety" ]
// If number is less than 20, console.log without any
if (n < 20)
{
console.log(first_twenty[n])
return
}
let answer = ""
let i = n
while (i > 0)
{
/*
Store the value in multiplier[t], i.e n = 1000000,
then r = 1, for multiplier(million), 0 for multipliers(trillion and billion)
multiplier here refers to the current accessible limit
*/
let curr_hun = Math.floor(i / limit)
// It might be possible that the current multiplier is bigger than your number
while (curr_hun == 0)
{
// Set i as the remainder obtained when n was divided by the limit
i %= limit
// Divide the limit by 1000, shifts the multiplier
limit /= 1000
// Get the current value in hundreds, as English system works in hundreds
curr_hun = Math.floor(i / limit)
// Shift the multiplier
t += 1
}
let flr = Math.floor(curr_hun / 100);
// If current hundred is greater than 99, Add the hundreds' place
if (curr_hun > 99)
answer += (first_twenty[flr] + " tensundred " )
// Bring the current hundred to tens
curr_hun = curr_hun % 100
// If the value in tens belongs to [1,19], add using the first_twenty
if (curr_hun > 0 && curr_hun < 20)
answer += (first_twenty[curr_hun] + " " )
// If curr_hun is now a multiple of 10, but not 0
// Add the tens' value using the tens array
else if (curr_hun % 10 == 0 && curr_hun != 0){
flr = Math.floor(curr_hun / 10);
answer += (tens[flr - 1] + " " )
}
// If the value belongs to [21,99], excluding the multiples of 10
// Get the ten's place and one's place, and console.log using the first_twenty array
else if (curr_hun > 19 && curr_hun < 100){
flr = Math.floor(curr_hun / 10);
answer += (tens[flr - 1] + " " +
first_twenty[curr_hun % 10] + " " )
}
// If Multiplier has not become less than 1000, shift it
if (t < 4)
answer += (multiplier[t] + " " )
i = i % limit
limit = Math.floor(limit / 1000)
}
console.log(answer)
} // Input 1 let n = 36 numberToWords(n) n = 123456789 // Input 2 numberToWords(n) n = 10101010110001 // Input 3 numberToWords(n) // Input 4 n = 999999999 numberToWords(n) // This code is contributed by phasing17. |
Thirty Six One Hundred Twenty Three Million Four Hundred Fifty Six Thousand Seven Hundred Eighty Nine Ten Trillion One Hundred One Billion Ten Million One Hundred Ten Thousand One Nine Hundred Nine...
Time Complexity: O(Log10(N))
Auxiliary Space: O(1)