public
Created

C++ and Haskell versions of code

  • Download Gist
Wordy.hs
Haskell
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
{-# OPTIONS_GHC -O2 #-}
{-# LANGUAGE BangPatterns, MagicHash, OverloadedStrings, UnboxedTuples #-}
 
module Main (main) where
 
import Data.Monoid (mappend, mempty)
import GHC.Base (Int(..), chr, quotInt#, remInt#)
import Prelude hiding ((!!))
import System.Environment (getArgs)
import qualified Data.ByteString.Char8 as B
import qualified Data.ByteString.Unsafe as B
import qualified Data.Vector as V
import qualified Data.Vector.Generic as G
import qualified Data.Vector.Unboxed as U
 
wordVec = V.fromList . B.words
 
ones = V.cons mempty $ wordVec "one two three four five six seven eight nine"
tens = V.cons mempty $ wordVec "ten twenty thirty forty fifty sixty seventy \
\ eighty ninety"
teens = wordVec "ten eleven twelve thirteen fourteen fifteen sixteen seventeen \
\ eighteen nineteen"
 
lengthVec :: V.Vector B.ByteString -> U.Vector Int
lengthVec = U.convert . V.map B.length
 
-- For notational convenience.
a !! b = G.unsafeIndex a b
 
-- The default definitions of quot and rem check for div-by-zero,
-- whereas we don't care.
(I# a) // (I# b) = I# (a `quotInt#` b)
(I# a) % (I# b) = I# (a `remInt#` b)
 
wordify i = go i where
go n
| n < 10 = ones !! n
| n < 20 = teens !! (n-10)
| n < 100 = (tens !! (n // 10)) `mappend` (ones !! (n % 10))
| n < 1000 = (ones !! (n // 100)) `mappend` "hundred" `mappend` go (n % 100)
| n < 1000000 = go (n // 1000) `mappend` "thousand" `mappend` go (n % 1000)
| otherwise = go (n // 1000000) `mappend` "million" `mappend` go (n % 1000000)
 
wordLength i = go i
where
go n
| n < 10 = lengthOnes !! n
| n < 20 = lengthTeens !! (n-10)
| n < 100 = (lengthTens !! (n // 10)) + (lengthOnes !! (n % 10))
| n < 1000 = (lengthOnes !! (n // 100)) + 7 + go (n % 100)
| n < 1000000 = go (n // 1000) + 8 + go (n % 1000)
| otherwise = go (n // 1000000) + 7 + go (n % 1000000)
!lengthOnes = lengthVec ones
!lengthTens = lengthVec tens
!lengthTeens = lengthVec teens
 
main = do
args <- getArgs
let target = case args of
[a] -> read a
_ -> 51000000000
let go i sumLength !sumNumbers
| i >= 999999999 = (i, sumLength, sumNumbers)
| sumLength' >= target = (i, sumLength, sumNumbers')
| otherwise = go (i+1) sumLength' sumNumbers'
where sumLength' = wordLength i + sumLength
sumNumbers' = sumNumbers + i
let (i, sumLength, sumNumbers) = go 1 0 0
putStrLn $ "Sum: " ++ show sumNumbers
let w = wordify i `B.unsafeIndex` (target - sumLength - 1)
putStrLn $ "The letter is " ++ (show . chr . fromIntegral $ w)
wordy.cc
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
// Brute force solver for the Word Number problem
 
#include <iostream>
#include <string>
 
int length_ones[10] = {0,3,3,5,4,4,3,5,5,4}; // "", one, two, three, ...
int length_tens[10] = {0,3,6,6,5,5,5,7,6,6}; // "", ten, twenty, ...
int length_teens[10] = {3,6,6,8,8,7,7,9,8,8}; // ten, eleven, twelve, ...
 
const char * ones[] = {"", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
const char * tens[] = {"", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
const char * teens[] = {"ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteeen", "nineteen"};
 
std::string wordify(long n)
{
if(n < 10) return ones[n];
else if(n < 20) return teens[n-10];
else if(n < 100) return std::string(tens[n/10]) + ones[n%10];
else if(n < 1000) return std::string(ones[n/100]) + "hundred" + wordify(n%100);
else if(n < 1000000) return wordify(n/1000) + "thousand" + wordify(n%1000);
else return wordify(n/1000000) + "million" + wordify(n%1000000);
}
 
static int word_length(long n)
{
if(n < 10) return length_ones[n];
else if(n < 20) return length_teens[n-10];
else if(n < 100) return length_tens[n/10] + length_ones[n%10];
else if(n < 1000) return length_ones[n/100] + 7 + word_length(n%100); // 7 for "hundred"
else if(n < 1000000) return word_length(n/1000) + 8 + word_length(n%1000);
else return word_length(n/1000000) + 7 + word_length(n%1000000);
}
 
int main(int argc, char **argv)
{
long sumNumbers = 0;
long sumLength = 0;
long i;
 
long target;
 
if (argc > 1)
target = atol(argv[1]);
else
target = 51000000000;
 
for(i = 1; i < 999999999; i++)
{
sumNumbers += i;
long newSumLength = word_length(i) + sumLength;
if(newSumLength >= target)
break;
 
sumLength = newSumLength;
}
 
std::cout << "Sum: " << sumNumbers << std::endl;
std::cout << "The letter is " << wordify(i)[target - sumLength - 1] << std::endl;
 
return 0;
}

Please sign in to comment on this gist.

Something went wrong with that request. Please try again.