Difference between revisions of "Convert an integer into words"

From CodeCodex

 
(Perl)
 
(14 intermediate revisions by 8 users not shown)
Line 1: Line 1:
 +
{{Infobox See Also String}}
 
The following code will turn integer numerals (eg. 1, 2, 3) into spelled out, words (eg. "one", "two", "three").
 
The following code will turn integer numerals (eg. 1, 2, 3) into spelled out, words (eg. "one", "two", "three").
  
 
==Implementations==
 
==Implementations==
===Java===
 
====English====
 
{{Copyright|Réal Gagnon|http://www.rgagnon.com/javadetails/java-0426.html}}
 
<pre>
 
class EnglishDecimalFormat {
 
  private static final String[] majorNames = {
 
    "",
 
    " thousand",
 
    " million",
 
    " billion",
 
    " trillion",
 
    " quadrillion",
 
    " quintillion"
 
    };
 
  
  private static final String[] tensNames = {
+
===Algol 68===
    "",
+
    " ten",
+
    " twenty",
+
    " thirty",
+
    " fourty",
+
    " fifty",
+
    " sixty",
+
    " seventy",
+
    " eighty",
+
    " ninety"
+
    };
+
  
   private static final String[] numNames = {
+
<pre>PROC number words =
    "",
+
   (
    " one",
+
    INT n
    " two",
+
  ) STRING :
    " three",
+
    # returns a string representation of n in words. Currently
    " four",
+
    deals with anything from 0 to 999 999 999. #
    " five",
+
    BEGIN
    " six",
+
        [] STRING digits =
    " seven",
+
            [] STRING (
    " eight",
+
                "zero",
    " nine",
+
                "one",
    " ten",
+
                "two",
    " eleven",
+
                "three",
    " twelve",
+
                "four",
    " thirteen",
+
                "five",
    " fourteen",
+
                "six",
    " fifteen",
+
                "seven",
    " sixteen",
+
                "eight",
    " seventeen",
+
                "nine"
    " eighteen",
+
            )[@0];
    " nineteen"
+
        [] STRING teens =
    };
+
            [] STRING (
 +
                "ten",
 +
                "eleven",
 +
                "twelve",
 +
                "thirteen",
 +
                "fourteen",
 +
                "fifteen",
 +
                "sixteen",
 +
                "seventeen",
 +
                "eighteen",
 +
                "nineteen"
 +
            )[@0];
 +
        [] STRING decades =
 +
            [] STRING (
 +
                "twenty",
 +
                "thirty",
 +
                "forty",
 +
                "fifty",
 +
                "sixty",
 +
                "seventy",
 +
                "eighty",
 +
                "ninety"
 +
            )[@2];
  
private String convertLessThanOneThousand(int number) {
+
        PROC three digits =
     String soFar;
+
          (
 +
            INT n
 +
          ) STRING :
 +
            # does the conversion for n from 0 to 999. #
 +
            BEGIN
 +
                INT tens = n MOD 100 OVER 10;
 +
                INT units = n MOD 10;
 +
                IF n >= 100 THEN
 +
                        digits[n OVER 100]
 +
                    +
 +
                        " "
 +
                    +
 +
                        "hundred"
 +
                    +
 +
                        IF n MOD 100 /= 0 THEN
 +
                            " and "
 +
                        ELSE
 +
                            ""
 +
                        FI
 +
                ELSE
 +
                    ""
 +
                FI
 +
            +
 +
                IF tens /= 0 THEN
 +
                    IF tens = 1 THEN
 +
                        teens[units]
 +
                    ELSE
 +
                            decades[tens]
 +
                        +
 +
                            IF units /= 0 THEN
 +
                                "-"
 +
                            ELSE
 +
                                ""
 +
                            FI
 +
                    FI
 +
                FI
 +
            +
 +
                IF units /= 0 AND tens /= 1 OR n = 0 THEN
 +
                    digits[units]
 +
                ELSE
 +
                    ""
 +
                FI
 +
            END;
 +
        INT n3 = n OVER 1 000 000;
 +
        INT n2 = n MOD 1 000 000 OVER 1000;
 +
        INT n1 = n MOD 1000;
 +
            IF n3 /= 0 THEN
 +
                three digits(n3) + " million"
 +
            ELSE
 +
                ""
 +
            FI
 +
        +
 +
            IF n3 /= 0 AND (n2 /= 0 OR n1 >= 100) THEN
 +
                ", "
 +
            ELSE
 +
                ""
 +
            FI
 +
        +
 +
            IF n2 /= 0 THEN
 +
                three digits(n2) + " thousand"
 +
            ELSE
 +
                ""
 +
            FI
 +
        +
 +
            IF (n3 /= 0 OR n2 /= 0) AND n1 > 0 AND n1 < 100 THEN
 +
                " and "
 +
            ELIF n2 /= 0 AND n1 /= 0 THEN
 +
                ", "
 +
            ELSE
 +
                ""
 +
            FI
 +
        +
 +
            IF n1 /= 0 OR n = 0 THEN
 +
                three digits(n1)
 +
            ELSE
 +
                ""
 +
            FI
 +
     END;
  
    if (number % 100 < 20){
+
DO # until user hits EOF #
        soFar = numNames[number % 100];
+
     on logical file end(standin, (REF FILE f) BOOL : GOTO finish);
        number /= 100;
+
     on value error(standin, (REF FILE f) BOOL : GOTO finish);
      }
+
     INT n;
     else {
+
     print("n? ");
        soFar = numNames[number % 10];
+
     read((n, new line));
        number /= 10;
+
     print((number words(n), new line))
 
+
OD;
        soFar = tensNames[number % 10] + soFar;
+
finish:
        number /= 10;
+
SKIP
      }
+
    if (number == 0) return soFar;
+
    return numNames[number] + " hundred" + soFar;
+
}
+
 
+
public String convert(int number) {
+
    /* special case */
+
    if (number == 0) { return "zero"; }
+
 
+
    String prefix = "";
+
 
+
    if (number < 0) {
+
        number = -number;
+
        prefix = "negative";
+
      }
+
 
+
    String soFar = "";
+
    int place = 0;
+
 
+
    do {
+
      int n = number % 1000;
+
      if (n != 0){
+
        String s = convertLessThanOneThousand(n);
+
        soFar = s + majorNames[place] + soFar;
+
        }
+
      place++;
+
      number /= 1000;
+
      } while (number > 0);
+
 
+
    return (prefix + soFar).trim();
+
}
+
 
+
public static void main(String[] args) {
+
    EnglishDecimalFormat f = new EnglishDecimalFormat();
+
    System.out.println("*** " + f.convert(0));
+
     System.out.println("*** " + f.convert(1));
+
    System.out.println("*** " + f.convert(16));
+
     System.out.println("*** " + f.convert(100));
+
     System.out.println("*** " + f.convert(118));
+
     System.out.println("*** " + f.convert(200));
+
     System.out.println("*** " + f.convert(219));
+
    System.out.println("*** " + f.convert(800));
+
    System.out.println("*** " + f.convert(801));
+
    System.out.println("*** " + f.convert(1316));
+
    System.out.println("*** " + f.convert(1000000));
+
    System.out.println("*** " + f.convert(2000000));
+
    System.out.println("*** " + f.convert(3000200));
+
    System.out.println("*** " + f.convert(700000));
+
    System.out.println("*** " + f.convert(9000000));
+
    System.out.println("*** " + f.convert(123456789));
+
    System.out.println("*** " + f.convert(-45));
+
    /*
+
    *** zero
+
    *** one
+
    *** sixteen
+
    *** one hundred
+
    *** one hundred eighteen
+
    *** two hundred
+
    *** two hundred nineteen
+
    *** eight hundred
+
    *** eight hundred one
+
    *** one thousand three hundred sixteen
+
    *** one million
+
    *** two million
+
    *** three million two hundred
+
    *** seven hundred thousand
+
    *** nine million
+
    *** one hundred twenty three million four hundred fifty six thousand seven hundred eighty nine
+
    *** negative fourty five
+
    */
+
    }
+
}
+
 
</pre>
 
</pre>
  
====French====
+
===Perl===
{{Copyright|Réal Gagnon|http://www.rgagnon.com/javadetails/java-0426.html}}
+
<pre class="perl">
<pre>
+
use Lingua::EN::Numbers qw(num2en);
import java.text.*;
+
num2en 234;
 
+
class FrenchDecimalFormat {
+
  private static final String[] dizaineNames = {
+
    "",
+
    "",
+
    "vingt",
+
    "trente",
+
    "quarante",
+
    "cinquante",
+
    "soixante",
+
    "soixante",
+
    "quatre-vingt",
+
    "quatre-vingt"
+
    };
+
 
+
  private static final String[] uniteNames1 = {
+
    "",
+
    "un",
+
    "deux",
+
    "trois",
+
    "quatre",
+
    "cinq",
+
    "six",
+
    "sept",
+
    "huit",
+
    "neuf",
+
    "dix",
+
    "onze",
+
    "douze",
+
    "treize",
+
    "quatorze",
+
    "quinze",
+
    "seize",
+
    "dix-sept",
+
    "dix-huit",
+
    "dix-neuf"
+
    };
+
 
+
  private static final String[] uniteNames2 = {
+
    "",
+
    "",
+
    "deux",
+
    "trois",
+
    "quatre",
+
    "cinq",
+
    "six",
+
    "sept",
+
    "huit",
+
    "neuf",
+
    "dix"
+
    };
+
 
+
private String convertZeroToHundred(int number) {
+
 
+
    int laDizaine = number / 10;
+
    int lUnite = number % 10;
+
    String resultat = "";
+
 
+
    switch (laDizaine) {
+
        case 1 :
+
        case 7 :
+
        case 9 :
+
          lUnite = lUnite + 10;
+
          break;
+
        default:
+
    }
+
 
+
    // séparateur "-" "et"  ""
+
    String laLiaison = "";
+
    if (laDizaine > 1) {
+
      laLiaison = "-";
+
    }
+
    // cas particuliers
+
    switch (lUnite) {
+
      case 0:
+
          laLiaison = "";
+
          break;
+
      case 1 :
+
          if (laDizaine == 8) {
+
            laLiaison = "-";
+
          }
+
          else {
+
            laLiaison = " et ";
+
          }
+
          break;
+
      case 11 :
+
          if (laDizaine==7) {
+
              laLiaison = " et ";
+
          }
+
          break;
+
      default:
+
    }
+
 
+
    // dizaines en lettres
+
    switch (laDizaine) {
+
        case 0:
+
          resultat = uniteNames1[lUnite];
+
          break;
+
        case 8 :
+
          if (lUnite == 0) {
+
            resultat = dizaineNames[laDizaine];
+
          }
+
          else {
+
            resultat = dizaineNames[laDizaine] + laLiaison + uniteNames1[lUnite];
+
          }
+
          break;
+
        default :
+
          resultat = dizaineNames[laDizaine] + laLiaison + uniteNames1[lUnite];
+
    }
+
 
+
 
+
    return resultat;
+
}
+
 
+
private String convertLessThanOneThousand(int number) {
+
 
+
    int lesCentaines = number / 100;
+
    int leReste = number % 100;
+
    String sReste = convertZeroToHundred(leReste);
+
 
+
    String resultat;
+
    switch (lesCentaines) {
+
        case 0:
+
          resultat = sReste;
+
          break;
+
        case 1 :
+
          if (leReste > 0) {
+
              resultat = "cent " + sReste;
+
          }
+
          else {
+
              resultat = "cent";
+
          }
+
          break;
+
        default :
+
          if (leReste > 0) {
+
              resultat = uniteNames2[lesCentaines] + " cent " + sReste;
+
          }
+
          else {
+
                resultat = uniteNames2[lesCentaines] + " cents";
+
          }
+
    }
+
    return resultat;
+
}
+
 
+
public String convert(long number) {
+
    // 0 à 999 999 999 999
+
    if (number == 0) { return "zéro"; }
+
 
+
    String snumber = Long.toString(number);
+
 
+
    // pad des "0"
+
    String mask = "000000000000";
+
    DecimalFormat df = new DecimalFormat(mask);
+
    snumber = df.format(number);
+
 
+
    int lesMilliards = Integer.parseInt(snumber.substring(0,3)); // XXXnnnnnnnnn
+
    int lesMillions  = Integer.parseInt(snumber.substring(3,6)); // nnnXXXnnnnnn
+
    int lesCentMille = Integer.parseInt(snumber.substring(6,9)); // nnnnnnXXXnnn
+
    int lesMille = Integer.parseInt(snumber.substring(9,12));    // nnnnnnnnnXXX
+
 
+
    String tradMilliards;
+
    switch (lesMilliards) {
+
        case 0:
+
          tradMilliards = "";
+
          break;
+
        case 1 :
+
          tradMilliards = convertLessThanOneThousand(lesMilliards) + " milliard ";
+
          break;
+
        default :
+
          tradMilliards = convertLessThanOneThousand(lesMilliards) + " milliards ";
+
    }
+
    String resultat =  tradMilliards;
+
 
+
    String tradMillions;
+
    switch (lesMillions) {
+
        case 0:
+
          tradMillions = "";
+
          break;
+
        case 1 :
+
          tradMillions = convertLessThanOneThousand(lesMillions) + " million ";
+
          break;
+
        default :
+
          tradMillions = convertLessThanOneThousand(lesMillions) + " millions ";
+
    }
+
    resultat =  resultat + tradMillions;
+
 
+
    String tradCentMille;
+
    switch (lesCentMille) {
+
        case 0:
+
            tradCentMille = "";
+
            break;
+
        case 1 :
+
            tradCentMille = "mille ";
+
            break;
+
        default :
+
            tradCentMille = convertLessThanOneThousand(lesCentMille) + " mille ";
+
    }
+
    resultat =  resultat + tradCentMille;
+
 
+
    String tradMille;
+
    tradMille = convertLessThanOneThousand(lesMille);
+
    resultat =  resultat + tradMille;
+
 
+
    return resultat;
+
}
+
 
+
public static void main(String[] args) {
+
    FrenchDecimalFormat f = new FrenchDecimalFormat();
+
    System.out.println("*** " + f.convert(0));
+
    System.out.println("*** " + f.convert(9));
+
    System.out.println("*** " + f.convert(19));
+
    System.out.println("*** " + f.convert(21));
+
    System.out.println("*** " + f.convert(28));
+
    System.out.println("*** " + f.convert(71));
+
    System.out.println("*** " + f.convert(72));
+
    System.out.println("*** " + f.convert(80));
+
    System.out.println("*** " + f.convert(81));
+
    System.out.println("*** " + f.convert(89));
+
    System.out.println("*** " + f.convert(90));
+
    System.out.println("*** " + f.convert(91));
+
    System.out.println("*** " + f.convert(97));
+
    System.out.println("*** " + f.convert(100));
+
    System.out.println("*** " + f.convert(101));
+
    System.out.println("*** " + f.convert(110));
+
    System.out.println("*** " + f.convert(120));
+
    System.out.println("*** " + f.convert(200));
+
    System.out.println("*** " + f.convert(201));
+
    System.out.println("*** " + f.convert(232));
+
    System.out.println("*** " + f.convert(999));
+
    System.out.println("*** " + f.convert(1000));
+
    System.out.println("*** " + f.convert(1001));
+
    System.out.println("*** " + f.convert(10000));
+
    System.out.println("*** " + f.convert(10001));
+
    System.out.println("*** " + f.convert(100000));
+
    System.out.println("*** " + f.convert(2000000));
+
    System.out.println("*** " + f.convert(3000000000L));
+
    /*
+
    *** OUTPUT
+
    *** zéro
+
    *** neuf
+
    *** dix-neuf
+
    *** vingt et un
+
    *** vingt-huit
+
    *** soixante et onze
+
    *** soixante-douze
+
    *** quatre-vingt
+
    *** quatre-vingt-un
+
    *** quatre-vingt-neuf
+
    *** quatre-vingt-dix
+
    *** quatre-vingt-onze
+
    *** quatre-vingt-dix-sept
+
    *** cent
+
    *** cent un
+
    *** cent dix
+
    *** cent vingt
+
    *** deux cents
+
    *** deux cent un
+
    *** deux cent trente-deux
+
    *** neuf cent quatre-vingt-dix-neuf
+
    *** mille
+
    *** mille un
+
    *** dix mille
+
    *** dix mille un
+
    *** cent mille
+
    *** deux millions
+
    *** trois milliards
+
    */
+
    }
+
}
+
 
</pre>
 
</pre>
  
[[Category:Java]]
+
[[Category:Algol 68]]
 +
[[Category:Perl]]
 
[[Category:Language]]
 
[[Category:Language]]
 
[[Category:String]]
 
[[Category:String]]
 
[[Category:Numbers]]
 
[[Category:Numbers]]

Latest revision as of 04:59, 6 December 2010

Related content:

The following code will turn integer numerals (eg. 1, 2, 3) into spelled out, words (eg. "one", "two", "three").

Implementations[edit]

Algol 68[edit]

PROC number words =
  (
    INT n
  ) STRING :
    # returns a string representation of n in words. Currently
    deals with anything from 0 to 999 999 999. #
    BEGIN
        [] STRING digits =
            [] STRING (
                "zero",
                "one",
                "two",
                "three",
                "four",
                "five",
                "six",
                "seven",
                "eight",
                "nine"
            )[@0];
        [] STRING teens =
            [] STRING (
                "ten",
                "eleven",
                "twelve",
                "thirteen",
                "fourteen",
                "fifteen",
                "sixteen",
                "seventeen",
                "eighteen",
                "nineteen"
            )[@0];
        [] STRING decades =
            [] STRING (
                "twenty",
                "thirty",
                "forty",
                "fifty",
                "sixty",
                "seventy",
                "eighty",
                "ninety"
            )[@2];

        PROC three digits =
          (
            INT n
          ) STRING :
            # does the conversion for n from 0 to 999. #
            BEGIN
                INT tens = n MOD 100 OVER 10;
                INT units = n MOD 10;
                IF n >= 100 THEN
                        digits[n OVER 100]
                    +
                        " "
                    +
                        "hundred"
                    +
                        IF n MOD 100 /= 0 THEN
                            " and "
                        ELSE
                            ""
                        FI
                ELSE
                    ""
                FI
            +
                IF tens /= 0 THEN
                    IF tens = 1 THEN
                        teens[units]
                    ELSE
                            decades[tens]
                        +
                            IF units /= 0 THEN
                                "-"
                            ELSE
                                ""
                            FI
                    FI
                FI
            +
                IF units /= 0 AND tens /= 1 OR n = 0 THEN
                    digits[units]
                ELSE
                    ""
                FI
            END;
        INT n3 = n OVER 1 000 000;
        INT n2 = n MOD 1 000 000 OVER 1000;
        INT n1 = n MOD 1000;
            IF n3 /= 0 THEN
                three digits(n3) + " million"
            ELSE
                ""
            FI
        +
            IF n3 /= 0 AND (n2 /= 0 OR n1 >= 100) THEN
                ", "
            ELSE
                ""
            FI
        +
            IF n2 /= 0 THEN
                three digits(n2) + " thousand"
            ELSE
                ""
            FI
        +
            IF (n3 /= 0 OR n2 /= 0) AND n1 > 0 AND n1 < 100 THEN
                " and "
            ELIF n2 /= 0 AND n1 /= 0 THEN
                ", "
            ELSE
                ""
            FI
        +
            IF n1 /= 0 OR n = 0 THEN
                three digits(n1)
            ELSE
                ""
            FI
    END;

DO # until user hits EOF #
    on logical file end(standin, (REF FILE f) BOOL : GOTO finish);
    on value error(standin, (REF FILE f) BOOL : GOTO finish);
    INT n;
    print("n? ");
    read((n, new line));
    print((number words(n), new line))
OD;
finish:
SKIP

Perl[edit]

use Lingua::EN::Numbers qw(num2en);
num2en 234;