Konvertieren Sie Ganzzahlen in geschriebene Zahlen

  • Gibt es eine effiziente Methode zum Konvertieren einer ganzen Zahl in die geschriebenen Zahlen, zum Beispiel:

     string Written = IntegerToWritten(21);
     

    würde "Einundzwanzig" zurückgeben.

    Gibt es eine Möglichkeit, dies ohne massive Suchtabelle zu tun?

    31 January 2012
    AbbasEki Eqbal
11 answers
  • Dies sollte einigermaßen gut funktionieren:

     public static class HumanFriendlyInteger
    {
        static string[] ones = new string[] { "", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine" };
        static string[] teens = new string[] { "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen" };
        static string[] tens = new string[] { "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety" };
        static string[] thousandsGroups = { "", " Thousand", " Million", " Billion" };
    
        private static string FriendlyInteger(int n, string leftDigits, int thousands)
        {
            if (n == 0)
            {
                return leftDigits;
            }
    
            string friendlyInt = leftDigits;
    
            if (friendlyInt.Length > 0)
            {
                friendlyInt += " ";
            }
    
            if (n < 10)
            {
                friendlyInt += ones[n];
            }
            else if (n < 20)
            {
                friendlyInt += teens[n - 10];
            }
            else if (n < 100)
            {
                friendlyInt += FriendlyInteger(n % 10, tens[n / 10 - 2], 0);
            }
            else if (n < 1000)
            {
                friendlyInt += FriendlyInteger(n % 100, (ones[n / 100] + " Hundred"), 0);
            }
            else
            {
                friendlyInt += FriendlyInteger(n % 1000, FriendlyInteger(n / 1000, "", thousands+1), 0);
                if (n % 1000 == 0)
                {
                    return friendlyInt;
                }
            }
    
            return friendlyInt + thousandsGroups[thousands];
        }
    
        public static string IntegerToWritten(int n)
        {
            if (n == 0)
            {
                return "Zero";
            }
            else if (n < 0)
            {
                return "Negative " + IntegerToWritten(-n);
            }
    
            return FriendlyInteger(n, "", 0);
        }
    }
     

    (Bearbeitet, um einen Fehler mit Millionen zu beheben , Milliarden usw.)

    15 October 2016
    Wedge
  • Ich verwende diese praktische Bibliothek namens Humanizer.

    https://github.com/Humanizr/Humanizer

    Es unterstützt mehrere Kulturen und konvertiert nicht nur Zahlen in Wörter, sondern auch Datum. Es ist sehr einfach zu verwenden.

    So geht's Ich benutze es:

     int someNumber = 543;
    var culture = System.Globalization.CultureInfo("en-US");
    var result = someNumber.ToWords(culture); // 543 -> five hundred forty-three
     

    Und voilá!

    07 October 2016
    Mari Faleiros
  • Ich verwende diesen Code. Es ist VB-Code, aber Sie können ihn leicht in C # übersetzen. Es funktioniert

     Function NumberToText(ByVal n As Integer) As String
    
       Select Case n
    Case 0
      Return ""
    
    Case 1 To 19
      Dim arr() As String = {"One","Two","Three","Four","Five","Six","Seven", _
        "Eight","Nine","Ten","Eleven","Twelve","Thirteen","Fourteen", _
          "Fifteen","Sixteen","Seventeen","Eighteen","Nineteen"}
      Return arr(n-1) & " "
    
    Case 20 to 99
      Dim arr() as String = {"Twenty","Thirty","Forty","Fifty","Sixty","Seventy","Eighty","Ninety"}
      Return arr(n\10 -2) & " " & NumberToText(n Mod 10)
    
    Case 100 to 199
      Return "One Hundred " & NumberToText(n Mod 100)
    
    Case 200 to 999
      Return NumberToText(n\100) & "Hundreds " & NumberToText(n mod 100)
    
    Case 1000 to 1999
      Return "One Thousand " & NumberToText(n Mod 1000)
    
    Case 2000 to 999999
      Return NumberToText(n\1000) & "Thousands " & NumberToText(n Mod 1000)
    
    Case 1000000 to 1999999
      Return "One Million " & NumberToText(n Mod 1000000)
    
    Case 1000000 to 999999999
      Return NumberToText(n\1000000) & "Millions " & NumberToText(n Mod 1000000)
    
    Case 1000000000 to 1999999999
      Return "One Billion " & NumberTotext(n Mod 1000000000)
    
    Case Else
      Return NumberToText(n\1000000000) & "Billion " _
        & NumberToText(n mod 1000000000)
    End Select
    End Function
     

    Hier ist der Code in c #

     public static string AmountInWords(double amount)
    {
            var n = (int)amount;
    
            if (n == 0)
                return "";
            else if (n > 0 && n <= 19)
            {
                var arr = new string[] { "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen" };
                return arr[n - 1] + " ";
            }
            else if (n >= 20 && n <= 99)
            {
                var arr = new string[] { "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety" };
                return arr[n / 10 - 2] + " " + AmountInWords(n % 10);
            }
            else if (n >= 100 && n <= 199)
            {
                return "One Hundred " + AmountInWords(n % 100);
            }
            else if (n >= 200 && n <= 999)
            {
                return AmountInWords(n / 100) + "Hundred " + AmountInWords(n % 100);
            }
            else if (n >= 1000 && n <= 1999)
            {
                return "One Thousand " + AmountInWords(n % 1000);
            }
            else if (n >= 2000 && n <= 999999)
            {
                return AmountInWords(n / 1000) + "Thousand " + AmountInWords(n % 1000);
            }
            else if (n >= 1000000 && n <= 1999999)
            {
                return "One Million " + AmountInWords(n % 1000000);
            }
            else if (n >= 1000000 && n <= 999999999)
            {
                return AmountInWords(n / 1000000) + "Million " + AmountInWords(n % 1000000);
            }
            else if (n >= 1000000000 && n <= 1999999999)
            {
                return "One Billion " + AmountInWords(n % 1000000000);
            }
            else
            {
                return AmountInWords(n / 1000000000) + "Billion " + AmountInWords(n % 1000000000);
            }
        }
     
    22 May 2015
    Nick Masao
  • Justin Rogers hat eine "NumbersToEnglish" -Klasse, die die Arbeit für Sie gut machen sollte!

    Erste Veröffentlichung.
    http://weblogs.asp.net/justin_rogers/archive/2004/06/ 09 / 151675.aspx

    Abgeschlossener Quellcode
    http://weblogs.asp.net/justin_rogers/articles/151757.aspx

    Es hat eine etwas von einer internen Nachschlagetabelle, aber ich weiß nicht wirklich, wie Sie davon abkommen können.

    06 August 2008
    Calanus
  • Warum massive Nachschlagetabelle?

     string GetWrittenInteger(int n)
    {
      string[] a = new string[] {"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine" }
      string[] b = new string[] { "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen" }
      string[] c = new string[] {"Twenty", "Thirty", "Forty", "Sixty", "Seventy", "Eighty", "Ninety"};
      string[] d = new string[] {"Hundred", "Thousand", "Million"}
      string s = n.ToString();
    
      for (int i = 0; i < s.Length; i++)
      {
        // logic (too lazy but you get the idea)
      }
    }
     
    07 February 2016
    Markus SafarMHop
  • Die akzeptierte Antwort scheint nicht perfekt zu funktionieren. Es behandelt keine Striche in Zahlen wie einundzwanzig, es setzt nicht das Wort "und" in Zahlen wie "Einhundertein" ein, und es ist rekursiv.

    Hier ist meine Antwort auf die Antwort. Es fügt das Wort "und" intelligent hinzu und trennt die Zahlen entsprechend. Lassen Sie mich wissen, ob Änderungen erforderlich sind.

    So rufen Sie es auf (natürlich möchten Sie dies irgendwo in einer Klasse angeben):

     for (int i = int.MinValue+1; i < int.MaxValue; i++)
    {
        Console.WriteLine(ToWords(i));
    }
     

    Hier ist der Code:

     private static readonly string[] Ones = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
    
    private static readonly string[] Teens =
    {
        "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen",
        "Seventeen", "Eighteen", "Nineteen"
    };
    
    private static readonly string[] Tens =
    {
        "", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty",
        "Ninety"
    };
    
    public static string ToWords(int number)
    {
        if (number == 0)
            return "Zero";
    
        var wordsList = new List<string>();
    
        if (number < 0)
        {
            wordsList.Add("Negative");
            number = Math.Abs(number);
        }
    
        if (number >= 1000000000 && number <= int.MaxValue) //billions
        {
            int billionsValue = number / 1000000000;
            GetValuesUnder1000(billionsValue, wordsList);
            wordsList.Add("Billion");
            number -= billionsValue * 1000000000;
    
            if (number > 0 && number < 10)
                wordsList.Add("and");
        }
    
        if (number >= 1000000 && number < 1000000000) //millions
        {
            int millionsValue = number / 1000000;
            GetValuesUnder1000(millionsValue, wordsList);
            wordsList.Add("Million");
            number -= millionsValue * 1000000;
    
            if (number > 0 && number < 10)
                wordsList.Add("and");
        }
    
        if (number >= 1000 && number < 1000000) //thousands
        {
            int thousandsValue = number/1000;
            GetValuesUnder1000(thousandsValue, wordsList);
            wordsList.Add("Thousand");
            number -= thousandsValue * 1000;
    
            if (number > 0 && number < 10)
                wordsList.Add("and");
        }
    
        GetValuesUnder1000(number, wordsList);
    
        return string.Join(" ", wordsList);
    }
    
    private static void GetValuesUnder1000(int number, List<string> wordsList)
    {
        while (number != 0)
        {
            if (number < 10)
            {
                wordsList.Add(Ones[number]);
                number -= number;
            }
            else if (number < 20)
            {
                wordsList.Add(Teens[number - 10]);
                number -= number;
            }
            else if (number < 100)
            {
                int tensValue = ((int) (number/10))*10;
                int onesValue = number - tensValue;
    
                if (onesValue == 0)
                {
                    wordsList.Add(Tens[tensValue/10]);
                }
                else
                {
                    wordsList.Add(Tens[tensValue/10] + "-" + Ones[onesValue]);
                }
    
                number -= tensValue;
                number -= onesValue;
            }
            else if (number < 1000)
            {
                int hundredsValue = ((int) (number/100))*100;
                wordsList.Add(Ones[hundredsValue/100]);
                wordsList.Add("Hundred");
                number -= hundredsValue;
    
                if (number > 0)
                    wordsList.Add("and");
            }
        }
    }
     
    07 February 2016
    Markus SafarMHop
  •  using System;
    using System.Collections.Generic; 
    using System.Linq; 
    using System.Text; 
    
    namespace tryingstartfror4digits 
    { 
        class Program 
        { 
            static void Main(string[] args)
            {
                Program pg = new Program();
                Console.WriteLine("Enter ur number");
                int num = Convert.ToInt32(Console.ReadLine());
    
                if (num <= 19)
                {
                    string g = pg.first(num);
                    Console.WriteLine("The number is " + g);
                }
                else if ((num >= 20) && (num <= 99))
                {
                        if (num % 10 == 0)
                        {
                            string g = pg.second(num / 10);
                            Console.WriteLine("The number is " + g);
                        }
                        else
                        {
                            string g = pg.second(num / 10) + pg.first(num % 10);
                            Console.WriteLine("The number is " + g);
                        }
                }
                else if ((num >= 100) && (num <= 999))
                {
                    int k = num % 100;
                    string g = pg.first(num / 100) +pg.third(0) + pg.second(k / 10)+pg.first(k%10);
                    Console.WriteLine("The number is " + g);
                }
                else if ((num >= 1000) && (num <= 19999))
                {
                    int h = num % 1000;
                    int k = h % 100;
                    string g = pg.first(num / 1000) + "Thousand " + pg.first(h/ 100) + pg.third(k) + pg.second(k / 10) + pg.first(k % 10);
                    Console.WriteLine("The number is " + g);
                }
    
                Console.ReadLine();
            }
    
            public string first(int num)
            {
                string name;
    
                if (num == 0)
                {
                    name = " ";
                }
                else
                {
                    string[] arr1 = new string[] { "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine" , "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};
                    name = arr1[num - 1];
                }
    
                return name;
            }
    
            public string second(int num)
            {
                string name;
    
                if ((num == 0)||(num==1))
                {
                     name = " ";
                }
                else
                {
                    string[] arr1 = new string[] { "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety" };
                    name = arr1[num - 2];
                }
    
                return name;
            }
    
            public string third(int num)
            {
                string name ;
    
                if (num == 0)
                {
                    name = "";
                }
                else
                {
                    string[] arr1 = new string[] { "Hundred" };
                    name = arr1[0];
                }
    
                return name;
            }
        }
    }
     

    dies funktioniert gut von 1 bis 19999 und wird bald nach dem Abschluss aktualisiert

    07 February 2016
    Markus SafarMHop
  • Der folgende App-Code für die C # -Konsole akzeptiert einen Geldwert in Zahlen bis zu 2 Dezimalstellen und druckt ihn auf Englisch. Dies konvertiert nicht nur Integer in das entsprechende englische Äquivalent, sondern auch als Geldwert in Dollar und Cent.

      namespace ConsoleApplication2
    {
        using System;
        using System.Collections.Generic;
        using System.Linq;
        using System.Text.RegularExpressions;
        class Program
        {
           static void Main(string[] args)
            {
                bool repeat = true;
                while (repeat)
                {
                    string inputMonetaryValueInNumberic = string.Empty;
                    string centPart = string.Empty;
                    string dollarPart = string.Empty;
                    Console.Write("\nEnter the monetary value : ");
                    inputMonetaryValueInNumberic = Console.ReadLine();
                    inputMonetaryValueInNumberic = inputMonetaryValueInNumberic.TrimStart('0');
    
                    if (ValidateInput(inputMonetaryValueInNumberic))
                    {
    
                        if (inputMonetaryValueInNumberic.Contains('.'))
                        {
                            centPart = ProcessCents(inputMonetaryValueInNumberic.Substring(inputMonetaryValueInNumberic.IndexOf(".") + 1));
                            dollarPart = ProcessDollar(inputMonetaryValueInNumberic.Substring(0, inputMonetaryValueInNumberic.IndexOf(".")));
                        }
                        else
                        {
                            dollarPart = ProcessDollar(inputMonetaryValueInNumberic);
                        }
                        centPart = string.IsNullOrWhiteSpace(centPart) ? string.Empty : " and " + centPart;
                        Console.WriteLine(string.Format("\n\n{0}{1}", dollarPart, centPart));
                    }
                    else
                    {
                        Console.WriteLine("Invalid Input..");
                    }
    
                    Console.WriteLine("\n\nPress any key to continue or Escape of close : ");
                    var loop = Console.ReadKey();
                    repeat = !loop.Key.ToString().Contains("Escape");
                    Console.Clear();
                }
    
            }
    
            private static string ProcessCents(string cents)
            {
                string english = string.Empty;
                string dig3 = Process3Digit(cents);
                if (!string.IsNullOrWhiteSpace(dig3))
                {
                    dig3 = string.Format("{0} {1}", dig3, GetSections(0));
                }
                english = dig3 + english;
                return english;
            }
            private static string ProcessDollar(string dollar)
            {
                string english = string.Empty;
                foreach (var item in Get3DigitList(dollar))
                {
                    string dig3 = Process3Digit(item.Value);
                    if (!string.IsNullOrWhiteSpace(dig3))
                    {
                        dig3 = string.Format("{0} {1}", dig3, GetSections(item.Key));
                    }
                    english = dig3 + english;
                }
                return english;
            }
            private static string Process3Digit(string digit3)
            {
                string result = string.Empty;
                if (Convert.ToInt32(digit3) != 0)
                {
                    int place = 0;
                    Stack<string> monetaryValue = new Stack<string>();
                    for (int i = digit3.Length - 1; i >= 0; i--)
                    {
                        place += 1;
                        string stringValue = string.Empty;
                        switch (place)
                        {
                            case 1:
                                stringValue = GetOnes(digit3[i].ToString());
                                break;
                            case 2:
                                int tens = Convert.ToInt32(digit3[i]);
                                if (tens == 1)
                                {
                                    if (monetaryValue.Count > 0)
                                    {
                                        monetaryValue.Pop();
                                    }
                                    stringValue = GetTens((digit3[i].ToString() + digit3[i + 1].ToString()));
                                }
                                else
                                {
                                    stringValue = GetTens(digit3[i].ToString());
                                }
                                break;
                            case 3:
                                stringValue = GetOnes(digit3[i].ToString());
                                if (!string.IsNullOrWhiteSpace(stringValue))
                                {
                                    string postFixWith = " Hundred";
                                    if (monetaryValue.Count > 0)
                                    {
                                        postFixWith = postFixWith + " And";
                                    }
                                    stringValue += postFixWith;
                                }
                                break;
                        }
                        if (!string.IsNullOrWhiteSpace(stringValue))
                            monetaryValue.Push(stringValue);
                    }
                    while (monetaryValue.Count > 0)
                    {
                        result += " " + monetaryValue.Pop().ToString().Trim();
                    }
                }
                return result;
            }
            private static Dictionary<int, string> Get3DigitList(string monetaryValueInNumberic)
            {
                Dictionary<int, string> hundredsStack = new Dictionary<int, string>();
                int counter = 0;
                while (monetaryValueInNumberic.Length >= 3)
                {
                    string digit3 = monetaryValueInNumberic.Substring(monetaryValueInNumberic.Length - 3, 3);
                    monetaryValueInNumberic = monetaryValueInNumberic.Substring(0, monetaryValueInNumberic.Length - 3);
                    hundredsStack.Add(++counter, digit3);
                }
                if (monetaryValueInNumberic.Length != 0)
                    hundredsStack.Add(++counter, monetaryValueInNumberic);
                return hundredsStack;
            }
            private static string GetTens(string tensPlaceValue)
            {
                string englishEquvalent = string.Empty;
                int value = Convert.ToInt32(tensPlaceValue);
                Dictionary<int, string> tens = new Dictionary<int, string>();
                tens.Add(2, "Twenty");
                tens.Add(3, "Thirty");
                tens.Add(4, "Forty");
                tens.Add(5, "Fifty");
                tens.Add(6, "Sixty");
                tens.Add(7, "Seventy");
                tens.Add(8, "Eighty");
                tens.Add(9, "Ninty");
                tens.Add(10, "Ten");
                tens.Add(11, "Eleven");
                tens.Add(12, "Twelve");
                tens.Add(13, "Thrteen");
                tens.Add(14, "Fourteen");
                tens.Add(15, "Fifteen");
                tens.Add(16, "Sixteen");
                tens.Add(17, "Seventeen");
                tens.Add(18, "Eighteen");
                tens.Add(19, "Ninteen");
                if (tens.ContainsKey(value))
                {
                    englishEquvalent = tens[value];
                }
    
                return englishEquvalent;
    
            }
            private static string GetOnes(string onesPlaceValue)
            {
                int value = Convert.ToInt32(onesPlaceValue);
                string englishEquvalent = string.Empty;
                Dictionary<int, string> ones = new Dictionary<int, string>();
                ones.Add(1, " One");
                ones.Add(2, " Two");
                ones.Add(3, " Three");
                ones.Add(4, " Four");
                ones.Add(5, " Five");
                ones.Add(6, " Six");
                ones.Add(7, " Seven");
                ones.Add(8, " Eight");
                ones.Add(9, " Nine");
    
                if (ones.ContainsKey(value))
                {
                    englishEquvalent = ones[value];
                }
    
                return englishEquvalent;
            }
            private static string GetSections(int section)
            {
                string sectionName = string.Empty;
                switch (section)
                {
                    case 0:
                        sectionName = "Cents";
                        break;
                    case 1:
                        sectionName = "Dollars";
                        break;
                    case 2:
                        sectionName = "Thousand";
                        break;
                    case 3:
                        sectionName = "Million";
                        break;
                    case 4:
                        sectionName = "Billion";
                        break;
                    case 5:
                        sectionName = "Trillion";
                        break;
                    case 6:
                        sectionName = "Zillion";
                        break;
                }
                return sectionName;
            }
            private static bool ValidateInput(string input)
            {
                return Regex.IsMatch(input, "[0-9]{1,18}(\\.[0-9]{1,2})?"))
            }
        }
    }
     
    07 June 2017
    Santhosh
  • Holen Sie sich diese Zeichenfolge und konvertieren Sie sie mit der Zeichenfolge wie . s = txtNumber.Text.Tostring (); int i = Convert.ToInt32 (s.Tostring ()); Schreibt nur den ganzen Integer-Wert

    20 November 2017
    Dhiraj D B
  • Hier ist eine C # Konsolenanwendung , die ganze Zahlen sowie Dezimalzahlen zurückgibt.

    14 August 2012
    Joe Meyer