Difference between revisions of "Convert an integer into words"

From CodeCodex

(Perl)
 
(13 intermediate revisions by 7 users not shown)
Line 3: Line 3:
  
 
==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;