Facebook Interview Question
Software EngineersCountry: United States
Interview Type: Phone Interview
package main
import (
"fmt"
)
func main() {
fmt.Println(convert(2203, 0))
}
var (
numbs = []string{"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"}
teens = []string{"ten", "eleven", "twelve", "thirteen", "fourteen", "fifthteen", "eighteen", "nineteen"}
tens = []string{"", "", "twenty", "thirty", "fourty", "fifty", "sixty", "seventy", "eigty", "ninety"}
bases = []string{"", "", "hundred", "thousand", "million", "billion"}
)
func teens_str(number int) string {
if number < 10 {
return numbs[number]
} else if number < 20 {
return teens[number%10]
} else {
return tens[number/10] + " " + numbs[number%10]
}
}
func convert(number int, power int) string {
teens_num := number % 100
out := teens_str(teens_num)
return convert_recursion(number/100, 2) + " " + out
}
func convert_recursion(number int, power int) string {
fmt.Printf("Convert(%d, %d)\n", number, power)
if number == 0 {
return ""
}
fmt.Printf("Convert(%d, %d)\n", number, power)
digit := number % 10
out := ""
out = numbs[digit] + " " + bases[power]
leading := convert_recursion(number/10, power+1)
fmt.Printf("Convert(%d, %d) = %s\n", number, power, out)
return leading + " " + out
}
#include<iostream>
#include<stack>
#include<string>
using namespace std;
class Solution
{
private:
static const string _n2sL10[] ;
static const string _n2sTens[] ;
static const string _n2sTeens[] ;
static void num2StringL10(int num)
{
cout <<_n2sL10[num];
}
static void num2StringTeens(stack<int>& myStack)
{
int n1 = myStack.top(); myStack.pop();
int n2 = myStack.top(); myStack.pop();
n1 = n1*10 + n2;
cout <<_n2sTeens[n1 - 10];
}
static void num2StringTens(int num)
{
cout <<_n2sTens[num];
}
static void num2String(stack<int>& myStack, int size)
{
stack<int> newStack;
switch(size)
{
case 1:
num2StringL10(myStack.top());
myStack.pop();
return;
break;
case 2:
{
int num = myStack.top();
if(num == 0)
{
myStack.pop();
num2StringL10(myStack.top());
cout<<" ";
myStack.pop();
return;
}
if(num == 1)
{
num2StringTeens(myStack);
cout<< " ";
return;
}
else
{
num2StringTens(myStack.top());
myStack.pop();
if(myStack.top() == 0)
{
myStack.pop();
return;
}
cout<<" ";
num2StringL10(myStack.top());
cout<<" ";
myStack.pop();
return;
}
}
break;
case 3:
{
int n = myStack.top();
num2StringL10(myStack.top());
myStack.pop();
if(n != 0)
{ cout<<" Hundred";
cout<<" And ";
}
num2String(myStack, 2);
cout<< " ";
}
break;
case 4:
num2String(myStack, 1);
cout << " Thousand ";
num2String(myStack, myStack.size());
break;
case 5:
num2String(myStack, 2);
cout<<" Thousand ";
num2String(myStack, myStack.size());
break;
case 6:
num2String(myStack, 3);
cout<<" Thousand ";
num2String(myStack, myStack.size());
break;
default:
break;
}
}
public:
static void numToString(int N)
{
//Special
switch(N)
{
case 0:
cout<<"Zero"; return;
case 100:
cout<<"One Hundred"; return;
case 1000:
cout<<"One Thousand"; return;
case 1000000:
cout<<"One Million"; return;
case 1000000000:
cout<<"One Billion"; return;
default:
break;
}
stack<int> myStack;
int num = N;
while(num)
{
myStack.push(num%10);
num/=10;
}
num2String(myStack, myStack.size());
}
};
const string Solution::_n2sL10[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
const string Solution::_n2sTens[] = {"", "", "Twenty", "Thirty", "Fourty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};
const string Solution::_n2sTeens[] = {"Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};
int main()
{
int num, n;
cin >> num;
cin >>n;
for(int i = num; i<=n; ++i)
{ Solution::numToString(i); cout<<endl;}
cout<< endl;
}
//purely iterative php
function number_to_string($num)
{
if($num > 999999999999999)
return "number overflow";
if($num===0)
return "zero";
$numbers = array('zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine');
$firstten = array('eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen');
$tens = array('', 'ten', 'twenty', 'thirty', 'fourty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety');
$exp3 = array('', 'thousand', 'million', 'billion', 'trillion');
$num = strrev($num);
$len = strlen($num);
$parts = array();
$rest = $done = 0;
$i = 0;
$milcount = -1;
do
{
$p1 = $p2 = $p3 = '';
$p1 = $num{$i};
$i++;
if($i<$len)
{
$p2 = $num{$i};
$i++;
}
if($i<$len)
{
$p3 = $num{$i};
$i++;
}
echo "$p1 $p2 $p3\n";
$str = '';
//if($p3 !== '' && $numbers[$p3] != 'zero')
if($p3 !== '')
$str .= $numbers[$p3] . ' hundred';
if($p2!=='') $str1 = $tens[$p2];
if($p1!=='') $str2 = $numbers[$p1];
if($p2==1) $str .= ' ' . $firstten[$p1-1];
else
{
if($p2!=='') $str .= " " . $tens[$p2];
if($numbers[$p1] != 'zero')
$str .= " " . $numbers[$p1];
}
//aggiungere la base 1000
$milcount++;
$str .= " " . $exp3[$milcount];
$parts[] = $str;
} while($i < $len);
$parts = array_reverse($parts);
return join($parts, ", ");
}
$num = rand(0, 9999999999);
echo "Num: $num\n";
$str = number_to_string($num);
echo "number: $str\n";
def to_arabic(number):
"""
>>> to_arabic(1)
'one'
>>> to_arabic(21)
'twenty one'
>>> to_arabic(99)
'ninety nine'
>>> to_arabic(100)
'one hundred'
>>> to_arabic(121)
'one hundred twenty one'
>>> to_arabic(299)
'two hundred ninety nine'
>>> to_arabic(2099)
'two thousand ninety nine'
>>> to_arabic(3299)
'three thousand two hundred ninety nine'
"""
translate = [
"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
"ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"
]
dizaines = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]
mtc = [
(1000000, "million"),
(1000, "thousand"),
(100, "hundred"),
]
if number < 0:
return "minus " + to_arabic(-number)
if number < 20:
return translate[number]
elif number < 100:
return dizaines[number // 10] + " " + translate[number % 10]
else:
arabic = []
for base, unit in mtc:
n = number // base
if n:
arabic.append(to_arabic(n) + " " + unit)
number = number % base
if number:
arabic.append(to_arabic(number))
return " ".join(arabic)
class IntToWord
ONES = [ "", "one", "two", "three", "four", "five", "six", "seven", "eitgh", "nine" ]
TENS = [ "", "twenty", "thirdy", "fourty", "fifty", "sixty", "seventy", "eighty", "ninety" ]
TEEN = [ "ten", "twelve", "thirteen", "fourteen", "fiveteen", "sixteen", "seventeen", "eighteen", "nineteen" ]
HUND = "hundread"
THOU = "thousand"
MILL = "million"
def initialize(n)
@word = []
@n = n.to_i
@n_array = []
end
def run_unit()
div_thou()
@word << write_hund() if @n.to_s.length >= 10
@word << write_tens(-7) if @n.to_s.length >= 9 and @n.to_s.split(//)[-7].to_i >= 2
@word << write_ones() if @n.to_s.length >= 8
@word << write_teen(9) if @n.to_s.length == 9 and @n.to_s.split(//)[-6].to_i < 2
@word << write_mill() if @n.to_s.length >= 7
@word << write_thou() if @n.to_s.length >= 4
@word << write_hund() if @n.to_s.length >= 3
@word << write_tens() if @n.to_s.length >= 2 and @n.to_s.split(//)[-2].to_i >= 2
@word << write_ones() if @n.to_s.length >= 1
@word << write_teen() if @n.to_s.length == 2 and @n.to_s.split(//)[-1].to_i < 2
@n_array.each_with_index do |thou, idx|
if idx == 2
@word << write_tens() if @n_array[idx].to_s.length >= 2 and @n_array[idx].to_s.split(//)[-2].to_i >= 2
@word << write_ones() if @n_array[idx].to_s.length >= 1
@word << write_teen() if @n_array[idx].to_s.length == 2 and @n_array[idx].to_s.split(//)[-1].to_i < 2
end
def div_thou()
@n_array = @n.to_s.reverse!.scan(/.{1,3}/)
@n_array.each_index do |idx|
@n_array[idx].reverse!
end
end
def write_mill()
return MILL
end
def write_thou()
return THOU
end
def write_hund()
return HUND
end
def write_tens()
TENS.each_index do |num|
if @n.to_s.split(//)[-2] == (num.to_s)
return TENS[num-1]
end
end
end
def write_teen()
TEEN.each_index do |num|
if @n.to_s.split(//)[-1] == (num.to_s)
return TEES[num]
end
end
end
def write_ones()
ONES.each_index do |num|
if @n.to_s.split(//)[-1] == (num.to_s)
return ONES[num]
end
end
end
end
a = IntToWord.new(12123123)
a.run_unit
class IntToWord
ONES = [ "", "one", "two", "three", "four", "five", "six", "seven", "eitgh", "nine" ]
TENS = [ "", "twenty", "thirdy", "fourty", "fifty", "sixty", "seventy", "eighty", "ninety" ]
TEEN = [ "ten", "twelve", "thirteen", "fourteen", "fiveteen", "sixteen", "seventeen", "eighteen", "nineteen" ]
HUND = "hundread"
THOU = "thousand"
MILL = "million"
def initialize(n)
@word = []
@n = n.to_i
@n_array = []
end
def run_unit()
div_thou()
@word << write_hund() if @n.to_s.length >= 10
@word << write_tens(-7) if @n.to_s.length >= 9 and @n.to_s.split(//)[-7].to_i >= 2
@word << write_ones() if @n.to_s.length >= 8
@word << write_teen(9) if @n.to_s.length == 9 and @n.to_s.split(//)[-6].to_i < 2
@word << write_mill() if @n.to_s.length >= 7
@word << write_thou() if @n.to_s.length >= 4
@word << write_hund() if @n.to_s.length >= 3
@word << write_tens() if @n.to_s.length >= 2 and @n.to_s.split(//)[-2].to_i >= 2
@word << write_ones() if @n.to_s.length >= 1
@word << write_teen() if @n.to_s.length == 2 and @n.to_s.split(//)[-1].to_i < 2
@n_array.each_with_index do |thou, idx|
if idx == 2
@word << write_tens() if @n_array[idx].to_s.length >= 2 and @n_array[idx].to_s.split(//)[-2].to_i >= 2
@word << write_ones() if @n_array[idx].to_s.length >= 1
@word << write_teen() if @n_array[idx].to_s.length == 2 and @n_array[idx].to_s.split(//)[-1].to_i < 2
end
def div_thou()
@n_array = @n.to_s.reverse!.scan(/.{1,3}/)
@n_array.each_index do |idx|
@n_array[idx].reverse!
end
end
def write_mill()
return MILL
end
def write_thou()
return THOU
end
def write_hund()
return HUND
end
def write_tens()
TENS.each_index do |num|
if @n.to_s.split(//)[-2] == (num.to_s)
return TENS[num-1]
end
end
end
def write_teen()
TEEN.each_index do |num|
if @n.to_s.split(//)[-1] == (num.to_s)
return TEES[num]
end
end
end
def write_ones()
ONES.each_index do |num|
if @n.to_s.split(//)[-1] == (num.to_s)
return ONES[num]
end
end
end
end
a = IntToWord.new(12123123)
a.run_unit
class IntToWord
ONES = [ "", "one", "two", "three", "four", "five", "six", "seven", "eitgh", "nine" ]
TENS = [ "", "twenty", "thirdy", "fourty", "fifty", "sixty", "seventy", "eighty", "ninety" ]
TEEN = [ "ten", "twelve", "thirteen", "fourteen", "fiveteen", "sixteen", "seventeen", "eighteen", "nineteen" ]
HUND = "hundread"
THOU = "thousand"
MILL = "million"
def initialize(n)
@word = []
@n = n.to_i
@n_array = []
end
def run_unit()
div_thou()
@word << write_hund() if @n.to_s.length >= 10
@word << write_tens(-7) if @n.to_s.length >= 9 and @n.to_s.split(//)[-7].to_i >= 2
@word << write_ones() if @n.to_s.length >= 8
@word << write_teen(9) if @n.to_s.length == 9 and @n.to_s.split(//)[-6].to_i < 2
@word << write_mill() if @n.to_s.length >= 7
@word << write_thou() if @n.to_s.length >= 4
@word << write_hund() if @n.to_s.length >= 3
@word << write_tens() if @n.to_s.length >= 2 and @n.to_s.split(//)[-2].to_i >= 2
@word << write_ones() if @n.to_s.length >= 1
@word << write_teen() if @n.to_s.length == 2 and @n.to_s.split(//)[-1].to_i < 2
@n_array.each_with_index do |thou, idx|
if idx == 2
@word << write_tens() if @n_array[idx].to_s.length >= 2 and @n_array[idx].to_s.split(//)[-2].to_i >= 2
@word << write_ones() if @n_array[idx].to_s.length >= 1
@word << write_teen() if @n_array[idx].to_s.length == 2 and @n_array[idx].to_s.split(//)[-1].to_i < 2
end
def div_thou()
@n_array = @n.to_s.reverse!.scan(/.{1,3}/)
@n_array.each_index do |idx|
@n_array[idx].reverse!
end
end
def write_mill()
return MILL
end
def write_thou()
return THOU
end
def write_hund()
return HUND
end
def write_tens()
TENS.each_index do |num|
if @n.to_s.split(//)[-2] == (num.to_s)
return TENS[num-1]
end
end
end
def write_teen()
TEEN.each_index do |num|
if @n.to_s.split(//)[-1] == (num.to_s)
return TEES[num]
end
end
end
def write_ones()
ONES.each_index do |num|
if @n.to_s.split(//)[-1] == (num.to_s)
return ONES[num]
end
end
end
end
a = IntToWord.new(12123123)
a.run_unit
public class NumToString {
private static final String[] teen_or_less = {"", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
"eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
private static final String[] tens = {"", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
private static final String[] thousands = {"", "thousand", "million", "billion"};
private static String convert3(int i) {
String ans = "";
if(i > 0) {
int mod100 = i % 100;
if(mod100 < 20) {
ans = NumToString.teen_or_less[mod100];
} else {
ans = NumToString.teen_or_less[i % 10];
ans = NumToString.tens[(i/10)%10] + " " + ans;
}
if(i/100 > 0) {
ans = NumToString.teen_or_less[i/100] + " hundred " + ans;
}
}
return ans.trim();
}
public static String convert(int i) throws Exception {
int level = 0;
if(i < 0) {
throw new Exception("Negative!");
}
if(i == 0) {
return "zero";
}
String ans = "";
while(i > 0) {
if(level >= NumToString.thousands.length) {
throw new Exception("Too large");
}
String t = NumToString.convert3(i % 1000);
i /= 1000;
ans = t + " " + NumToString.thousands[level] + " " + ans;
level++;
}
return ans.trim();
}
public static void test() throws Exception {
int[] t = {0, 1, 5, 10, 11, 15, 17, 19, 21, 45, 99, 100, 120, 123, 1000, 1001, 1101, 10000, 120007,
123456, 112233445};
for(int i = 0; i < t.length; i++) {
System.out.println(NumToString.convert(t[i]));
}
}
}
<?php
$digits = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten'];
$teens = ['eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'];
$tens = ['twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'];
$big = [null, 'thousand', 'million', 'billion', 'trillion'];
$number = ltrim($argv[1], 0);
$result = '';
$groups = str_split(strrev($number), 3);
$groups = array_reverse($groups);
$i = 1;
foreach ($groups as $group) {
$group = intval(strrev($group));
if ($group > 99) {
$result .= $digits[(int) floor($group / 100) - 1] . ' hundred ';
$group = $group % 100;
}
if ($group <= 99 && $group > 19) {
$result .= $tens[(int) floor($group / 10) - 2] . ' ';
$group = $group % 10;
}
if ($group <= 19 && $group > 10) {
$result .= $teens[$group % 10 - 1] . ' ';
$group = 0;
}
if ($group <= 10 && $group > 0) {
$result .= $digits[$group - 1] . ' ';
}
if (intval($number) === 0) {
$result = 'zero';
}
$result .= $big[count($groups) - $i] . ' ';
$i++;
}
echo $result . PHP_EOL;
<?php
$digits = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten'];
$teens = ['eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'];
$tens = ['twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'];
$base = [null, 'thousand', 'million', 'billion', 'trillion'];
$number = ltrim($argv[1], 0);
$result = '';
$groups = str_split(strrev($number), 3);
$groups = array_reverse($groups);
$i = 1;
foreach ($groups as $group) {
$group = intval(strrev($group));
if ($group > 99) {
$result .= $digits[(int) floor($group / 100) - 1] . ' hundred ';
$group = $group % 100;
}
if ($group <= 99 && $group > 19) {
$result .= $tens[(int) floor($group / 10) - 2] . ' ';
$group = $group % 10;
}
if ($group <= 19 && $group > 10) {
$result .= $teens[$group % 10 - 1] . ' ';
$group = 0;
}
if ($group <= 10 && $group > 0) {
$result .= $digits[$group - 1] . ' ';
}
if (intval($number) === 0) {
$result = 'zero';
}
$result .= $base[count($groups) - $i] . ' ';
$i++;
}
echo $result . PHP_EOL;
C Program :
#include <stdio.h>
/*
* power
* 0 -->
* 1 --> Tens (0-19, special handling)
* 2 --> Hundred
* 3 --> Thousand
* 4 --> Tens Thousand (0-19, special handling)
* 5 --> Hunderd Thousand
* 6 --> Miliion
* 7 --> Tens Million (0-19, special handling)
* 8 --> Hunderes Millions
* 9 --> Billion
* 10 --> Tens Billion (0-19, special handling)
* 11 --> Hundreds Billion
*/
const char *ZEROTOTEEN[] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "forteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
const char *TENS[] = {"", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
const char *BASE[] = {"", "", "hundred ", "thousand ", "", "", "million ", "", "", "billion "};
int carry = 0;
void
printnum(int n, int power)
{
int tempNum;
power++;
if (n <= 0) {
return;
} else {
printnum(n/10, power);
tempNum = n % 10;
switch (power) {
case 1: // tens
case 4: // ten thousand
case 7: // ten million
case 10: // ten billion
switch (tempNum) {
case 0:
carry = 0;
break;
case 1:
carry = 10;
break;
default:
printf("%s ", TENS[tempNum]);
break;
}
break;
case 5: // hundred thousand
case 8: // hundred million
case 11: // hundred Billion
power = 2; // hundred
default: // case 0 [0-19], case 2 [hundred], 3 [thousand], 6 [million], 9 [billion],
if ((tempNum + carry )!= 0) {
printf("%s %s", ZEROTOTEEN[tempNum + carry], BASE[power]);
carry = 0;
}
break;
}
}
}
#define MAX_NUM 21
int main ()
{
// Test data
int n[MAX_NUM] = {0, 1, 10, 11, 99, 100, 101, 110, 113, 123, 190, 999, 1000, 1245, 9999, 10000, 10200, 913913, 999999, 1000000, 1234567890};
int i;
// Test loop
for (i = 0; i < MAX_NUM; i++) {
printf("\n%13d\t", n[i]);
if (n[i] == 0) {
printf("zero"); // Handle special case of zero
} else {
printnum(n[i], -1); // Call print function
}
}
printf("\n");
return 0;
}
Output:
0 zero
1 one
10 ten
11 eleven
99 ninety nine
100 one hundred
101 one hundred one
110 one hundred ten
113 one hundred thirteen
123 one hundred twenty three
190 one hundred ninety
999 nine hundred ninety nine
1000 one thousand
1245 one thousand two hundred forty five
9999 nine thousand nine hundred ninety nine
10000 ten thousand
10200 ten thousand two hundred
913913 nine hundred thirteen thousand nine hundred thirteen
999999 nine hundred ninety nine thousand nine hundred ninety nine
1000000 one million
1234567890 one billion two hundred thirty four million five hundred sixty seven thousand eight hundred ninety
string integer_to_string(int integer) {
static const string powers[] = {"Billion", "Million", "Thousand"};
static const string tens[] = {
"", "", "Twenty", "Thirty", "Fourty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"
};
static const string ones[] = {
"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten",
"Evelen", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen",
"Nineteen"
};
if (integer == 0) {
return "Zero";
}
string result;
for (int i = 1000000000, power = 0; i > 1; i /= 1000, ++power) {
if (i > integer) {
continue;
}
int value = (integer / i);
result += integer_to_string(value) + " " + powers[power];
integer %= i;
}
if (integer / 100 > 0) {
int value = integer / 100;
result += integer_to_string(value) + " Hundred";
integer %= 100;
}
if (integer >= 20) {
int value = integer / 10;
result += " " + tens[value];
integer %= 10;
}
if (integer > 0) {
result += " " + ones[integer];
}
return result;
}
// This method converts any positive integer to the english representation
public static String convertToEnglish(int number){
String english = "";
if(number == 0){
english += "zero";
} else {
if(number < 0){
english += negative + " ";
number *= -1;
}
english += recursiveConvert(number, 0).trim();
}
return english;
}
// This method converts any positive integer to the english representation
// through recursion.
public static String recursiveConvert(int number, int powerIndex){
if(number == 0){
return "";
}
if(number / 100 == 0){
return tensToEnglish(number);
}else if(number / 1000 == 0){
return recursiveConvert(number / 100, 0).trim() + " " + powers[2] + " " + tensToEnglish(number % 100) + " ";
}else{
if(powerIndex <= 0){
powerIndex = 2;
}
return recursiveConvert(number / 1000, powerIndex + 1).trim() + " " + powers[powerIndex + 1] + " " + recursiveConvert(number % 1000, 2).trim() + " ";
}
}
// This Method converts any number below 100 to the english representation
public static String tensToEnglish(int number){
if (number < 10) {
return ones[number];
} else if (number < 20) {
return teens[number%10];
} else {
if(number%10 == 0){
return tens[number/10];
}else{
return tens[number/10] + " " + ones[number%10];
}
}
}
public static String negative = "negative";
public static String[] powers = {"", "", "hundred", "thousand", "million", "billion", "trillion"};
public static String[] tens = {"", "", "twenty", "thirty", "fourty", "fifty", "sixty", "seventy", "eigty", "ninety"};
public static String[] teens = {"ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
public static String[] ones = {"", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
// This method converts any positive integer to the english representation
public static String convertToEnglish(int number){
String english = "";
if(number == 0){
english += "zero";
} else {
if(number < 0){
english += negative + " ";
number *= -1;
}
english += recursiveConvert(number, 0).trim();
}
return english;
}
// This method converts any positive integer to the english representation
// through recursion.
public static String recursiveConvert(int number, int powerIndex){
if(number == 0){
return "";
}
if(number / 100 == 0){
return tensToEnglish(number);
}else if(number / 1000 == 0){
return recursiveConvert(number / 100, 0).trim() + " " + powers[2] + " " + tensToEnglish(number % 100) + " ";
}else{
if(powerIndex <= 0){
powerIndex = 2;
}
return recursiveConvert(number / 1000, powerIndex + 1).trim() + " " + powers[powerIndex + 1] + " " + recursiveConvert(number % 1000, 2).trim() + " ";
}
}
// This Method converts any number below 100 to the english representation
public static String tensToEnglish(int number){
if (number < 10) {
return ones[number];
} else if (number < 20) {
return teens[number%10];
} else {
if(number%10 == 0){
return tens[number/10];
}else{
return tens[number/10] + " " + ones[number%10];
}
}
}
def convertNumberToEnglish(number):
ones = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
teens = ["ten", "eleven", "twelve", "thirteen", "fourteen", "fifthteen", "sixteen", "seventeen", "eighteen", "nineteen"]
tens = ["ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]
powers = [("hundred",100), ("thousand",1000), ("million",1000000), ("billion",1000000000), ("trillion",1000000000000)]
if number < 10:
return ones[number]
elif 10 <= number < 20:
return teens[number % 10]
elif 20 <= number < 100:
if ones[number % 10] is not "zero":
return tens[number // 10 - 1]+" "+ones[number % 10]
else:
return tens[number // 10 - 1]
else:
finalNumber = []
for word, integer in reversed(powers):
if number // integer:
finalNumber.append(convertNumberToEnglish(number // integer)+" "+word)
if convertNumberToEnglish(number % integer) is not "zero":
finalNumber.append(convertNumberToEnglish(number % integer))
return " ".join(finalNumber)
print(convertNumberToEnglish(1076101))
Working algorithm .... based on the first implementation ...
public class ConvertNumbersToSpeech {
private static final String ones[] = { "Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine" };
private static final String teens[] = { "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen" };
private static final String tens[] = { "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety" };
private static final String powers[] = { "Hundred", "Thousand", "Million", "Billon", "Trillon" };
static String print(int number, int power) {
if(number == 0) {
return "";
}
int mod = number % 10;
String s = " "+ones[mod];
if(power == 0) {
int teensmod = number % 100;
if(teensmod < 20 && teensmod >= 10) {
s = " "+teens[teensmod % 10];
number /= 10;
power++;
}
}
else if(power == 1) {
s = " "+tens[mod-2];
}
else {
if(mod != 0) {
s += " "+powers[power-2];
}
else {
s = "";
}
}
return print(number / 10, power+1)+s;
}
public static String convert(int number) {
return print(number, 0).trim();
}
public static void main(String args[]) {
System.out.println("1 number: "+convert(1));
System.out.println("15 number: "+convert(15));
System.out.println("42 number: "+convert(42));
System.out.println("30042 number: "+convert(30042));
}
}
Javascript Solution
function getNumberString(numbers) {
var i;
var nums;
var numberGroups;
var results = [];
var ones = ['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Eleven', 'Twelve', 'Thirteen', 'Fourteen', 'Fifteen', 'Sixteen', 'Seventeen', 'Eighteen', 'Nineteen'];
var tens = ['Twenty', 'Thirty', 'Forty', 'Fifty', 'Sixty', 'Seventy', 'Eighty', 'Ninety', 'Hundred'];
var powers = ['', 'Thousand', 'Million', 'Billion', 'Trillion', 'Quadrillion'];
if (numbers === 0) {
return 'Zero';
}
function getNumberAsString(nums, result = []) {
var number;
if (nums.length === 0) {
return result.join(' ');
}
if (nums[0] === 0) {
nums.splice(0,1);
return getNumberAsString(nums, result);
}
if (nums.length === 1) {
result.push(ones[nums[0] - 1]);
return result.join(' ');
}
if (nums.length === 2) {
number = parseInt(nums.join(''));
if (number < 20 ) {
result.push(ones[number - 1]);
return result.join(' ');
} else {
result.push(tens[nums[0] - 2]);
nums.splice(0,1);
return getNumberAsString(nums, result);
}
}
if (nums.length === 3) {
result.push(ones[nums[0] - 1]);
result.push(tens[8]);
nums.splice(0,1);
return getNumberAsString(nums, result);
}
}
nums = numbers.toString().split('').map(Number);
numberGroups = [];
while (nums.length > 3) {
numberGroups.push(nums.splice(nums.length - 3, 3));
}
if (nums.length != 0) {
numberGroups.push(nums);
}
for (i = 0; i < numberGroups.length; i++) {
results.unshift(getNumberAsString(numberGroups[i]) + ' ' + powers[i]);
}
return results.join(' ');
}
Recursive solution for upto million. Can be easily extended to billion ... and further
public class NumberToWords {
static String[] ones = {
"",
" one",
" two",
" three",
" four",
" five",
" six",
" seven",
" eight",
" nine",
" ten",
" Eleven",
" Twelve",
" Thriteen",
" Fourteen",
" Fifteen",
" Sixteen",
" Seventeen",
" Eighteen",
" Ninetween"};
static String[] tens = {
"", // zero
"", // two
" Twenty",
" Thirty",
" Fourty",
" Fifty",
" Sixty",
" Seventy",
" Eighty",
" Ninety"};
public static String convertNumberToWords(int num){
String str = Integer.toString(num);
int len = str.length();
String result = "";
if(len == 1){
result = ones[num];
}else if(len==2){
if(num<20){
result = ones[num];
}else{
result = tens[num/10] + ones[num%10];
}
}else if(len == 3){
result += ones[num/100];
result += " Hundered";
result += convertNumberToWords(num%100);
}else if(len > 3 && len <=6 ){ // thousands . million = 6 zeros hence 1 million = 7 digits
result += convertNumberToWords(num/1000); // say 200,000 , 200 can be converted to string by calling same fun for 200
result += " Thousand";
result += convertNumberToWords(num%1000);
} else if(len > 6 && len <=9){ // until 999 million = 9 digits
result += convertNumberToWords(num/1000000);
result += " Million";
result += convertNumberToWords(num%1000000);
}
return result;
}
public static void main(String[] args) {
System.out.println(convertNumberToWords(200080680));
}
}
- Anonymouse August 10, 2016