Twitter Interview Question
Software Engineer / DevelopersCountry: United States
Interview Type: Phone Interview
Another implementation in C++. Same idea as uuuouou.
#include <iostream>
#include <list>
#include <string>
using namespace std;
string strRep[] = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven",
"twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "ninteen" };
string lessThanaHundred[] = {"", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninenty" };
string getStrRep(long long x)
{
if (x < 20ll)
return (x?strRep[x]:"");
if (x < 100ll)
return (lessThanaHundred[x / 10] + (x % 10 ? "-"+strRep[x % 10] : ""));
x /= 1000;
switch (x){
case 1:
return "";
case 1000:
return " thousand";
case 1000000:
return " million";
case 1000000000:
return " billion";
default:
return " thrillion";
}
}
string solve(long long ipt)
{
if (ipt == 0)
return "zero";
list <string> parts;
long long curMod = 1000;
while (curMod / 1000ll <=ipt)
{
long long tmp = ipt % curMod;
tmp /= (curMod / 1000ll);
string curPart = "";
if (!tmp)
{
curMod *= 1000ll;
continue;
}
if (tmp >= 100)
{
curPart += getStrRep(tmp / 100) + " hundred";
if (tmp % 100)
curPart += " and ";
}
curPart += getStrRep(tmp % 100);
curPart += getStrRep(curMod);
parts.push_front(curPart);
curMod *= 1000ll;
}
string ans = "";
for (auto y : parts)
ans += y + " ";
ans.pop_back();
return ans;
}
int main()
{
long long ipt;
while (cin >> ipt)
cout << solve(ipt) << endl;
}
1 #!/usr/bin/python
2
3 import sys
4
5 l_dictionary = {}
6 l_dictionary[1] = "One"
7 l_dictionary[2] = "Two"
8 l_dictionary[3] = "Three"
9 l_dictionary[4] = "Four"
10 l_dictionary[5] = "Five"
11 l_dictionary[6] = "Six"
12 l_dictionary[7] = "Seven"
13 l_dictionary[8] = "Eight"
14 l_dictionary[9] = "Nine"
15 l_dictionary[10] = "Ten"
16 l_dictionary[11] = "Eleven"
17 l_dictionary[12] = "Twelve"
18 l_dictionary[13] = "Thirteen"
19 l_dictionary[14] = "Fourteen"
20 l_dictionary[15] = "Fifteen"
21 l_dictionary[16] = "Sixteen"
22 l_dictionary[17] = "Seventeen"
23 l_dictionary[18] = "Eighteen"
24 l_dictionary[19] = "Nineteen"
25 l_dictionary[20] = "Twenty"
26 l_dictionary[30] = "Thirty"
27 l_dictionary[40] = "Forty"
28 l_dictionary[50] = "Fifty"
29 l_dictionary[60] = "Sixty"
30 l_dictionary[70] = "Seventy"
31 l_dictionary[80] = "Eighty"
32 l_dictionary[90] = "Ninty"
33 l_dictionary[100] = "Hundred"
34 l_dictionary[1000] = "Thousand"
35 l_dictionary[1000000] = "Million"
36 l_dictionary[1000000000] = "Billion"
37 l_dictionary[1000000000000] = "Trillion"
38
39 l_decimal = [1000000000000, 1000000000, 1000000, 1000, 100, 10, 1]
40
41 def printUsage():
42 print sys.argv[0] + " <Number>"
43
44
45 if len(sys.argv) != 2:
46 printUsage()
47 sys.exit(0)
48
49 l_input = int(sys.argv[1])
50
51 def print_in_words(x, i):
52 if i == 1:
53 print l_dictionary[x]
54 elif i == 10:
55 print l_dictionary[i*x]
56 else:
57 print l_dictionary[x] + " " + l_dictionary[i]
58
59
60 def iterate_over(number, array):
61 for i in array:
62 if number - i >= 0:
63 x = number / i
64 if x > 10 and x < 20:
65 print l_dictionary[x] + " " + l_dictionary[i]
66 elif x >= 20:
67 iterate_over(x, l_decimal)
68 print l_dictionary[i]
69 else:
70 print_in_words(x, i)
71
72 number = number - (x * i)
73
74 if l_input < 20:
75 print l_dictionary[l_input]
76 else:
77 iterate_over(l_input, l_decimal)
basically dictionary created for translation and then there is an iterate loop which is called recursively to print the number in words.
class ReadNumbers{
string readOneNumber(long number){
switch(number){
case 1: return "one"; break;
case 2: return "two"; break;
case 3: return "three"; break;
case 4: return "four"; break;
case 5: return "five"; break;
case 6: return "six"; break;
case 7: return "seven"; break;
case 8: return "eight"; break;
case 9: return "nine"; break;
case 10: return "ten"; break;
case 11: return "eleven"; break;
case 12: return "twelve"; break;
case 13: return "thirteen"; break;
case 14: return "fourteen"; break;
case 15: return "fifteen"; break;
case 16: return "sixteen"; break;
case 17: return "seventeen"; break;
case 18: return "eighteen"; break;
case 19: return "nineteen"; break;
}
return "";
}
string readTy(long number){
switch (number) {
case 2:
return "twenty";
break;
case 3:
return "thirty";
break;
case 4:
return "fourty";
break;
case 5:
return "fifty";
break;
case 6:
return "sixty";
break;
case 7:
return "seventy";
break;
case 8:
return "eighty";
break;
case 9:
return "ninety";
break;
default:
break;
}
return "";
}
string readBase(long num){
switch (num) {
case 0:
return "hundred";
break;
case 1:
return "thousand";
break;
case 2:
return "million";
break;
case 3:
return "billion";
break;
default:
break;
}
return "";
}
string readTwoNumbers(long num){
if(num < 20) return readOneNumber(num);
else{
string first = readTy(num/10);
string second = readOneNumber(num%10);
if(second.length() == 0) return first;
return first + "-" + second;
}
}
string readThreeNumbers(long num){
if(num < 100) return readTwoNumbers(num);
long val = num/100;
string hstr = readOneNumber(val);
return hstr+" " + readBase(0)+" and " + readTwoNumbers(num%100);
}
public:
string driver(long number){
string result;
long modd = 1000;
int count = 0;
while(number != 0){
string part = readThreeNumbers(number%modd) + " " + readBase(count);
result = part + " " + result;
number /= 1000;
modd = 1000;
count++;
}
return result;
}
};
val thouMap = Map(0 -> "",
1 -> "thousand",
2 -> "million",
3 -> "billion")
def recurseThou(i:Int):String = {
// recursive version of chopping off every thousand
// in this version we dont actually know the thousandth factor until the next call chain
// for example
// recursThou(15299)
// (s = 15,fact = 1)
// (15 + thouMap(1) + zeroTo999(299), fact = 0)
def recursThouHelper(i:Int)(factor:Int):(String, Int) = {
if(i/1000 == 0) {
(zeroTo999(i%1000), factor)
} else {
val (s, fact) = recursThouHelper(i/1000)(factor + 1)
( s + " " + thouMap(fact) + " "+ zeroTo999(i%1000), fact -1)
}
}
recursThouHelper(i)(0)._1
}
// alternative to the recusive thousand call
def iterativeThou(i:Int):String = {
var quot1000 = i
var thousandFactor = 0
var word:String = ""
while(quot1000 != 0) {
word = zeroTo999(quot1000%1000) + thouMap(thousandFactor) + word
quot1000 = quot1000/1000
thousandFactor = thousandFactor +1
}
word
}
def zeroTo999(i:Int):String = {
val sMap = Map(
0 ->"zero",
1->"one",
2->"two",
3->"three",
4->"four",
5->"five",
6->"six",
7->"seven",
8->"eight",
9 -> "nine", // digit 9,factor 0
10 -> "ten", // digit 0, factor 0
11 -> "eleven", // digit 1, factor 1, digit 1, factor 0
12 -> "twelve", // digit 1, factor 1, digit 2, factor 0
13 -> "thirteen", // digit 1 factor 1, digit 3, factor 0
14 -> "fourteen",
15 -> "fifteen",
16 -> "sixteen",
17 -> "seventeen",
18 -> "eighteen",
19 -> "nineteen",
20 -> "twenty",
30 -> "thirty",
40 -> "forty",
50 -> "fifty",
60 -> "sixty",
70 -> "seventy",
80 -> "eighty",
90 -> "ninety"
)
if(i > 999){
throw new Exception("Only valid for 0 - 999")
}
if(i <20)
sMap(i)
else if(i>=20 && i <= 99) {
if(i%10 != 0)
sMap(i/10 *10) + sMap(i%10) // i.e. 21, 22, 23
else
sMap(i/10 * 10) // 20, 30, 40
} else {
// 100 - 999
if(i%100 == 0)
sMap(i/100) + " hundred "
else
sMap(i/100) + " hundred " + zeroTo999(i%100)
}
}
implicit val recurse:Int => String = recurseThou
// idea here is that we chop of every 1000 and calculate how to say that with some map of which thousandnth factor
// we are in. We also introduce a string calculator for any word between 0-999
// so we have calculate0to999 + f(thousandthfactor) which returns thousand, million, etc
// i.e. 1,234,001,999
// ^ 1 + thousandthfactor is 3 (billion)
// ^ 234 + thousandthFactor is 2 (million)
// ^ 1 + thousandthFactor is 1 (thousand)
// ^ 999 + thousandthFactor is 0
def equivalentNumtoString(i:Int)(implicit f:Int => String):String = {
f(i)
}
static String intToString(int num) {
String[] base = { "", " Throusand ", " Million ", " Billion " };
String digit[] = { "Zero", "One", "Two", "Three", "Four", "Five",
"Six", "Seven", "Eight", "Nine" };
String teen[] = { "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen",
"Fifteen", "Sixteen", "Eighteen", "Nineteen" };
String ty[] = { "", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty",
"Seventy", "Eighty", "Ninety" };
int count = 0;
StringBuilder sb = new StringBuilder();
while (num > 0) {
String s = null;
int x = num % 1000;
if (x < 10) {
s = digit[x];
} else if (x < 20) {
s = teen[x % 10];
} else if (x < 100) {
s = ty[x / 10] + "-" + digit[x % 10];
} else if (x < 1000) {
s = digit[x / 100] + " Hundred And " + intToString(x % 100);
}
sb.insert(0,s+base[count++]);
num /= 1000;
}
return sb.toString();
}
I parse the integer to a string, and use recursion to get the result. The number can be larger, but since the problem clarifies that it is an "integer", so I set the limit to billion. It could be neater, I think.
import java.util.*;
public class IntegerToString {
private static Map<Integer, String> numbers;
static{
numbers = new HashMap<Integer, String> ();
numbers.put(0, "zero");
numbers.put(1, "one");
numbers.put(2, "two");
numbers.put(3, "three");
numbers.put(4, "four");
numbers.put(5, "five");
numbers.put(6, "six");
numbers.put(7, "seven");
numbers.put(8, "eight");
numbers.put(9, "nine");
numbers.put(10, "ten");
numbers.put(11, "eleven");
numbers.put(12, "twelve");
numbers.put(13, "thirteen");
numbers.put(14, "fourteen");
numbers.put(15, "fifteen");
numbers.put(16, "sixteen");
numbers.put(17, "seventeen");
numbers.put(18, "eighteen");
numbers.put(19, "nineteen");
numbers.put(20, "twenty");
numbers.put(30, "thirty");
numbers.put(40, "forty");
numbers.put(50, "fifty");
numbers.put(60,"sixty");
numbers.put(70, "seventy");
numbers.put(80, "eighty");
numbers.put(90, "ninety");
}
public static String read(int n){
return read(String.valueOf(n));
}
public static String read(String nStr){
int len = nStr.length();
if(len < 2)
return numbers.get(Integer.parseInt(nStr));
else if(len < 3) {
int tenth = Character.getNumericValue(nStr.charAt(0)) * 10;
if (tenth == 0)
return read(nStr.substring(1));
if(tenth < 20)
return numbers.get(Integer.parseInt(nStr));
int single = Character.getNumericValue(nStr.charAt(1));
return single == 0 ? numbers.get(tenth) : numbers.get(tenth) + numbers.get(single);
}
else if(len < 4){
if(Integer.parseInt(nStr) == 0)
return "";
int hund = Character.getNumericValue(nStr.charAt(0));
if(Integer.parseInt(nStr.substring(1)) == 0)
return numbers.get(hund) + " hundred";
return hund == 0 ? read(nStr.substring(1)) : numbers.get(hund) + " hundred and " + read(nStr.substring(1));
}
else if(len < 7){
if(Integer.parseInt(nStr) == 0)
return "";
return read(nStr.substring(0, len - 3)) + " thousand " + read(nStr.substring(len - 3, len));
}
else if(len < 10){
if(Integer.parseInt(nStr) == 0)
return "";
return read(nStr.substring(0, len - 6)) + " million " + read(nStr.substring(len - 6, len));
}
else
return read(nStr.substring(0, 1)) + " billion " + read(nStr.substring(1));
}
public static void main(String[] args) {
System.out.println(read(1));
System.out.println(read(11));
System.out.println(read(100));
System.out.println(read(1000));
System.out.println(read(1111));
System.out.println(read(10000));
System.out.println(read(11111));
System.out.println(read(1000000));
System.out.println(read(1111111));
System.out.println(read(10000000));
System.out.println(read(11111111));
System.out.println(read(100000000));
System.out.println(read(111111111));
System.out.println(read(1000000000));
System.out.println(read(1111111111));
}
}
import java.util.*;
public class IntegerToString {
private static Map<Integer, String> numbers;
static{
numbers = new HashMap<Integer, String> ();
numbers.put(0, "zero");
numbers.put(1, "one");
numbers.put(2, "two");
numbers.put(3, "three");
numbers.put(4, "four");
numbers.put(5, "five");
numbers.put(6, "six");
numbers.put(7, "seven");
numbers.put(8, "eight");
numbers.put(9, "nine");
numbers.put(10, "ten");
numbers.put(11, "eleven");
numbers.put(12, "twelve");
numbers.put(13, "thirteen");
numbers.put(14, "fourteen");
numbers.put(15, "fifteen");
numbers.put(16, "sixteen");
numbers.put(17, "seventeen");
numbers.put(18, "eighteen");
numbers.put(19, "nineteen");
numbers.put(20, "twenty");
numbers.put(30, "thirty");
numbers.put(40, "forty");
numbers.put(50, "fifty");
numbers.put(60,"sixty");
numbers.put(70, "seventy");
numbers.put(80, "eighty");
numbers.put(90, "ninety");
}
public static String read(int n){
return read(String.valueOf(n));
}
public static String read(String nStr){
int len = nStr.length();
if(len < 2)
return numbers.get(Integer.parseInt(nStr));
else if(len < 3) {
int tenth = Character.getNumericValue(nStr.charAt(0)) * 10;
if (tenth == 0)
return read(nStr.substring(1));
if(tenth < 20)
return numbers.get(Integer.parseInt(nStr));
int single = Character.getNumericValue(nStr.charAt(1));
return single == 0 ? numbers.get(tenth) : numbers.get(tenth) + numbers.get(single);
}
else if(len < 4){
if(Integer.parseInt(nStr) == 0)
return "";
int hund = Character.getNumericValue(nStr.charAt(0));
if(Integer.parseInt(nStr.substring(1)) == 0)
return numbers.get(hund) + " hundred";
return hund == 0 ? read(nStr.substring(1)) : numbers.get(hund) + " hundred and " + read(nStr.substring(1));
}
else if(len < 7){
if(Integer.parseInt(nStr) == 0)
return "";
return read(nStr.substring(0, len - 3)) + " thousand " + read(nStr.substring(len - 3, len));
}
else if(len < 10){
if(Integer.parseInt(nStr) == 0)
return "";
return read(nStr.substring(0, len - 6)) + " million " + read(nStr.substring(len - 6, len));
}
else
return read(nStr.substring(0, 1)) + " billion " + read(nStr.substring(1));
}
public static void main(String[] args) {
System.out.println(read(1));
System.out.println(read(11));
System.out.println(read(100));
System.out.println(read(1000));
System.out.println(read(1111));
System.out.println(read(10000));
System.out.println(read(11111));
System.out.println(read(1000000));
System.out.println(read(1111111));
System.out.println(read(10000000));
System.out.println(read(11111111));
System.out.println(read(100000000));
System.out.println(read(111111111));
System.out.println(read(1000000000));
System.out.println(read(1111111111));
}
}
The thought is to split the number by billion, million and thousand. Code in C++:
- uuuouou April 19, 2014