Twitter Interview Question for Software Engineer / Developers


Country: United States
Interview Type: Phone Interview




Comment hidden because of low score. Click to expand.
1
of 1 vote

The thought is to split the number by billion, million and thousand. Code in C++:

#include <iostream>
#include <string>
using namespace std;

class NumberReader{
private:
    static const string digit[10];
    static const string teen[10];
    static const string ty[8];
private:
    string read(int n){// 0 < n < 1000
        string s;
        if(n > 99){
            s = digit[n / 100];
            s.append(" hundred");
            n %= 100;
            if(n > 0) s.append(" and ");
        }
        if(n == 0) ;
        else if(n < 10) s.append(digit[n]);
        else if(n < 20) s.append(teen[n - 10]);
        else{
            s.append(ty[n / 10 - 2]);
            n %= 10;
            if(n > 0){
                s.append("-");
                s.append(digit[n]);
            }
        }
        return s;
    }
public:
    string readUnsignedInt(unsigned int num){//0 <= num <= 4294967295
        if(num == 0) return "zero";
        
        string s;
        if(num > 999999999){
            s.append(read(num / 1000000000));
            s.append(" billion");
            num %= 1000000000;
            if(num > 0){
                s.append(" ");
                s.append(readUnsignedInt(num));
            }
        }
        else if(num > 999999){
            s.append(read(num / 1000000));
            s.append(" million");
            num %= 1000000;
            if(num > 0){
                s.append(" ");
                s.append(readUnsignedInt(num));
            }
        }
        else if(num > 999){
            s.append(read(num / 1000));
            s.append(" thousand");
            num %= 1000;
            if(num > 0){
                if(num > 100) s.append(" ");
                else s.append(" and ");
                s.append(readUnsignedInt(num));
            }
        }
        else s = read(num);
        
        return s;
    }
    string readInt(int num){// -2147483648 <= num < 2147483647
        if(num == 0) return "zero";
        
        string s;
        unsigned int n = num;
        if(num < 0) s = "negative ";
        s.append(readUnsignedInt(n));
        return s;
    }
};
const string NumberReader::digit[10] = {
    "zero",
    "one",
    "two",
    "three",
    "four",
    "five",
    "six",
    "seven",
    "eight",
    "nine"
};
const string NumberReader::teen[10] = {
    "ten",
    "eleven",
    "twelve",
    "thirteen",
    "fourteen",
    "fifteen",
    "sixteen",
    "seventeen",
    "eighteen",
    "nineteen"
};
const string NumberReader::ty[8] = {
    "tweenty",
    "thirty",
    "forty",
    "fifty",
    "sixty",
    "seventy",
    "eighty",
    "ninety"
};

int main()
{
    int num;
    NumberReader reader;
    
    while(cin >> num){
        cout << reader.readInt(num) << endl;
    }
    
    return 0;
}

- uuuouou April 19, 2014 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 votes

Nice code! Have a suggestion, though. Add long long support to be able to process the example provided by the OP.

- iroodaz April 19, 2014 | Flag
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
}

- iroodaz April 19, 2014 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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.

- samipshah86 April 19, 2014 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
    }
};

- wwu October 28, 2014 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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)
  }

- flipCoder December 18, 2014 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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();
	}

- Charlie January 28, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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));
	}
}

- DoraShine March 11, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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));
	}
}

- DoraShine March 11, 2015 | Flag Reply


Add a Comment
Name:

Writing Code? Surround your code with {{{ and }}} to preserve whitespace.

Books

is a comprehensive book on getting a job at a top tech company, while focuses on dev interviews and does this for PMs.

Learn More

Videos

CareerCup's interview videos give you a real-life look at technical interviews. In these unscripted videos, watch how other candidates handle tough questions and how the interviewer thinks about their performance.

Learn More

Resume Review

Most engineers make critical mistakes on their resumes -- we can fix your resume with our custom resume review service. And, we use fellow engineers as our resume reviewers, so you can be sure that we "get" what you're saying.

Learn More

Mock Interviews

Our Mock Interviews will be conducted "in character" just like a real interview, and can focus on whatever topics you want. All our interviewers have worked for Microsoft, Google or Amazon, you know you'll get a true-to-life experience.

Learn More