miércoles, 22 de febrero de 2012

Convertir numero en letra





Objetivo
Convertir números en su respectiva letras

Vista Previa
Blogger
 
Código C#
 
using System;
using System.Globalization;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;

namespace ConvNumLetra
{
    public partial class NumeroEnLetraForm : Form
    {
        private static int comas;           // Cantidad de comas en el valor
        private static string[] digitos;    // Grupon de digito en el valor
        private static int td = 1;

        #region Enu_Digitos, Enumeracion con todos los digitos contenido en un numero
        enum Unidad { Cero = 0, Uno = 1, Dos = 2, Tres = 3, Cuatro = 4, Cinco = 5, Seis = 6, Siente = 7, Ocho = 8, Nueve = 9 };
        enum Decena { Once = 11, Dosce = 12, Trece = 13, Cotorce = 14, Quince = 15 };
        enum DecenaEntero { Diez = 10, Veinte = 20, Treinta = 30, Cuarenta = 40, Cincuenta = 50, Sesenta = 60, Setenta = 70, Ochenta = 80, Noventa = 90 };
        enum Centena { Cien = 100, Doscientos = 200, Trecientos = 300, Cuatrocientos = 400, Quinientos = 500, Seiscientos = 600, Seteciento = 700, Ochocientos = 800, novecientos = 900 };
        enum GroupSeparator { None = 0, Mil = 1, Millones = 2, Billones = 4, Trillones = 6, Cuatrillones = 8, Quintillones = 10, Sextillones = 12, Septillones = 14, Octillones = 16, Nonillones = 18 };

        #endregion Enu_Digitos, Enumeracion con todos los digitos contenido en un numero

        /// 
        /// Contructor
        /// 
        public NumeroEnLetraForm()
        {
            InitializeComponent();
            textBox1.Focus();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            textBox1.Focus();
            richTextBox1.Text = ProccessStringMethod(textBox1.Text);
            comas = 0;
            digitos = null;
        }

        private string ProccessStringMethod(string value)
        {
            if (value.Contains(".") || (value.Contains(".") && value.Contains(",")))
            {
                //double dou = Convert.ToDouble(value);

                decimal de = Convert.ToDecimal(value);

                string worknumber = de.ToString("#,#.##", CultureInfo.CurrentCulture);

                string entero = worknumber.Substring(0, worknumber.IndexOf(CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator));

                string dec = worknumber.Substring(worknumber.IndexOf(CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator) + 1);

                Regex rex = new Regex("[0-9]");

                MatchCollection mc = rex.Matches(entero);

                StringBuilder sb2 = new StringBuilder();

                foreach (var item in mc)
                {
                    sb2.Append(item);
                }

                return DoConvertMethod(sb2.ToString()) + "con " + dec + "/100";
            }

            else
            {
                return DoConvertMethod(value) + "con 00/100";
            }
        }

        private string DoConvertMethod(string value)
        {
            Regex ex = new Regex(",");

            //double dou = Convert.ToDouble(value);

            decimal de = Convert.ToDecimal(value);

            /****************************************************************************
             * Realizar cualquiera operacion matematica o invocar un metodo que         *
             * la realice sobre el double, en este punto.                              *
             *                                                                          *
             ***************************************************************************/

            comas = ex.Matches(de.ToString("#,#.##", CultureInfo.CurrentCulture)).Count; // cantidad de comas

            char[] groupSeparator = new char[] { (CultureInfo.CurrentCulture.NumberFormat.CurrencyGroupSeparator).ToCharArray()[0] }; // separador decimal de la referencia cultural actual

            digitos = de.ToString("#,#.##", CultureInfo.CurrentCulture).Split(groupSeparator);

            StringBuilder sb = new StringBuilder();

            foreach (string item in digitos)
            {
                try
                {
                    if (comas == 0) // No hay coma, entonce es un numero comun, ejemplo: 512
                    {
                        sb.Append(ProccessDigitMethod(item) + " ");
                        comas--;
                        break;
                    }

                    else
                    {
                        if (comas % 2 == 0)
                        {
                            // Cantidad de comas pares. Importante para la posicion en el diccionario.
                            comas = HelpDoConvertMethod(false, comas, sb, item);

                        }

                        else
                        {
                            // Cantidad de comas impares. Importante para la posicion en el diccionario.
                            comas = HelpDoConvertMethod(true, 01, sb, item);
                        }
                    }
                }
                catch (DivideByZeroException err)
                {
                    sb.Append(ProccessDigitMethod(item) + " " + (Enum.GetName(typeof(GroupSeparator), comas)) + " ");
                    comas--;
                }
            }
            return sb.ToString().ToLower();
        }

        private int HelpDoConvertMethod(bool mpm, int igs, StringBuilder sb, string item)
        {
            #region ItemLeght
            switch (item.Length)
            {
                #region Un Digito
                case 1:
                    if (item == "0")
                    {
                        sb.Append(ProccessDigitMethod(item));
                        comas--;
                    }
                    else
                    {
                        if ((item == "1") && comas >= 1) // singular en los millares que contienen la unidad 1
                        {
                            if (mpm == true)
                            {
                                string rs = ProccessDigitMethod(item).ToLower().Replace("uno", "un");
                                sb.Append(rs + " " + (Enum.GetName(typeof(GroupSeparator), igs)) + " ");
                                comas--;
                            }

                            else
                            {
                                string gs = (Enum.GetName(typeof(GroupSeparator), igs));
                                string rs = ProccessDigitMethod(item).ToLower().Replace("uno", "un");
                                sb.Append(rs + " " + gs.Substring(0, gs.Length - 2) + " ");
                                comas--;
                            }
                        }
                        else
                        {
                            sb.Append(ProccessDigitMethod(item) + " " + (Enum.GetName(typeof(GroupSeparator), igs)) + " ");
                            comas--;
                        }
                    }
                    break;
                #endregion Un Digito

                #region Dos Digitos
                case 2:
                    if (item == "00")
                    {
                        sb.Append(ProccessDigitMethod(item));
                        comas--;
                    }
                    else
                    {
                        if ((item == "01") && comas > 1) // singular en los millares que contienen la unidad 1
                        {
                            if (mpm == true)
                            {
                                string rs = ProccessDigitMethod(item).ToLower().Replace("uno", "un");
                                sb.Append(rs + " " + (Enum.GetName(typeof(GroupSeparator), igs)) + " ");
                                comas--;
                            }

                            else
                            {
                                string gs = (Enum.GetName(typeof(GroupSeparator), igs));
                                string rs = ProccessDigitMethod(item).ToLower().Replace("uno", "un");
                                sb.Append(rs + " " + gs.Substring(0, gs.Length - 2) + " ");
                                comas--;
                            }
                        }
                        else
                        {
                            sb.Append(ProccessDigitMethod(item) + " " + (Enum.GetName(typeof(GroupSeparator), igs)) + " ");
                            comas--;
                        }
                    }
                    break;
                #endregion Dos Digitos

                #region Tres Digitos
                case 3:
                    if (item == "000")
                    {
                        //int x = comas;
                        if (digitos[comas - 1] != "000") // item anterior al actual en la matriz.
                        {                            
                            if (comas % 2 == 0)
                            {
                                sb.Append(ProccessDigitMethod(item) + (Enum.GetName(typeof(GroupSeparator), comas)) + " ");
                                comas--;
                            }

                            else
                            {
                                sb.Append(ProccessDigitMethod(item) + " ");
                                comas--;
                            }
                        }

                        else
                        {
                            sb.Append(ProccessDigitMethod(item));
                            //comas--;

                            if (td>0 && td <= 3)
                            {
                                sb.Append((Enum.GetName(typeof(GroupSeparator), comas)) + " ");
                                //comas--;
                                td += td;
                            }
                            comas--;
                        }
                    }
                    else
                    {
                        if ((item == "001" || item.Substring(1, 2) == "01") && comas > 1)
                        {
                            if (mpm == true)
                            {
                                string rs = ProccessDigitMethod(item).ToLower().Replace("uno", "un");
                                sb.Append(rs + " " + (Enum.GetName(typeof(GroupSeparator), igs)) + " ");
                                comas--;
                            }

                            else
                            {
                                string gs = (Enum.GetName(typeof(GroupSeparator), igs));
                                string rs = ProccessDigitMethod(item).ToLower().Replace("uno", "un");
                                sb.Append(rs + " " + gs.Substring(0, gs.Length - 2) + " ");
                                comas--;
                            }
                        }
                        else
                        {
                            sb.Append(ProccessDigitMethod(item) + " " + (Enum.GetName(typeof(GroupSeparator), igs)) + " ");
                            comas--;
                        }
                    }
                    break;
                    #endregion Tres Digitos
            }
            #endregion ItemLeght
            return comas;
        }

        private string ProccessDigitMethod(string value)
        {
            string re = string.Empty;

            #region ValueLeght
            switch (value.Length)
            {
                #region Un Digito
                case 1:
                    if (value == "0")
                    {
                        re = string.Empty;
                    }
                    else
                    {
                        re = (Enum.GetName(typeof(Unidad), Convert.ToInt32(value)));
                    }
                    break;
                #endregion Un Digito

                #region Dos Digitos
                case 2:
                    if (value == "00")
                    {
                        re = string.Empty;
                    }

                    else
                    {
                        re = ProccessTwoDigitMethod(value);
                    }
                    break;
                #endregion Dos Digitos

                #region Tres Digitos
                case 3:
                    Regex rex2 = new Regex("0");

                    if (value.Contains("0")) // contiene cero
                    {
                        switch (rex2.Matches(value).Count) // cantidad de ceros
                        {
                            #region un cero
                            case 1: // un cero
                                Regex rex3 = new Regex(@"0"); // localizamo el cero

                                switch (value.IndexOf(rex3.Match(value).ToString())) // Posicion del cero
                                {
                                    case 0: // A la izquierda, ej: 011
                                        re = ProccessTwoDigitMethod(value.Substring(1, 2));
                                        break;

                                    case 1: // Centro, ej: 101
                                        if (Convert.ToInt32(value.Substring(0, 1)) == 5) // lleva el prefijo ciento
                                        {
                                            re = (Enum.GetName(typeof(Centena), (Convert.ToInt32(value.Substring(0, 1) + "00")))) + " " + Enum.GetName(typeof(Unidad), Convert.ToInt32(value.Substring(2, 1))).ToLower();
                                        }

                                        else
                                        {
                                            if (Convert.ToInt32(value.Substring(0, 1)) == 1)
                                            {
                                                re = "Ciento " + (Enum.GetName(typeof(Unidad), Convert.ToInt32(value.Substring(2, 1))).ToLower());
                                            }
                                            else
                                            {
                                                re = (Enum.GetName(typeof(Unidad), Convert.ToInt32(value.Substring(0, 1)))) + "Ciento " + (Enum.GetName(typeof(Unidad), Convert.ToInt32(value.Substring(2, 1))));
                                            }
                                        }
                                        break;

                                    case 2: // A la derecha, ej: 110
                                        if (Convert.ToInt32(value.Substring(0, 1)) == 5) // lleva el prefijo ciento
                                        {
                                            re = (Enum.GetName(typeof(Centena), (Convert.ToInt32(value.Substring(0, 1) + "00")))) + " " + ProccessTwoDigitMethod(value.Substring(1, 2)).ToLower();
                                        }

                                        else
                                        {
                                            if (Convert.ToInt32(value.Substring(0, 1)) == 1)
                                            {
                                                re = "Ciento " + ProccessTwoDigitMethod(value.Substring(1, 2)).ToLower();
                                            }
                                            else
                                            {
                                                re = (Enum.GetName(typeof(Centena), Convert.ToInt32(value.Substring(0, 1) + "00"))) + " " + ProccessTwoDigitMethod(value.Substring(1, 2)).ToLower(); ;
                                            }
                                        }
                                        break;
                                }
                                break;
                            #endregion un cero

                            #region Dos ceros
                            case 2: // Dos ceros
                                Regex rex = new Regex(@"[1-9]"); // localizamos numero diferente de cero

                                switch (value.IndexOf(rex.Match(value).ToString())) // Posicion del numero
                                {
                                    case 0: // A la izquierda, ej: 100
                                        re = (Enum.GetName(typeof(Centena), Convert.ToInt32(value)));
                                        break;

                                    case 1: // Centro, ej: 010
                                        re = (Enum.GetName(typeof(DecenaEntero), Convert.ToInt32(value.Substring(1, 2))));
                                        break;

                                    case 2: // A la derecha, ej: 001
                                        re = (Enum.GetName(typeof(Unidad), Convert.ToInt32(value.Substring(2, 1))));
                                        break;
                                }
                                break;
                            #endregion Dos ceros

                            #region Tres ceros
                            case 3: // Tres ceros
                                re = string.Empty;
                                break;
                                #endregion Tres ceros
                        }
                    }

                    else // no contiene cero
                    {
                        if ((value.Substring(0, 1)) == "1")  // sufijo ciento
                        {
                            re = "Ciento " + ProccessTwoDigitMethod(value.Substring(1, 2)).ToLower();
                        }

                        else
                        {
                            re = (Enum.GetName(typeof(Centena), (Convert.ToInt32(value.Substring(0, 1) + "00")))) + " " + ProccessTwoDigitMethod(value.Substring(1, 2));
                        }
                    }
                    break;
                #endregion Tres Digitos

                #region Cero Digitos
                default:
                    re = "Instroduzca un numero";
                    break;
                    #endregion Cero Digitos
            }
            #endregion ValueLeght

            return re;
        }

        private static string ProccessTwoDigitMethod(string value)
        {
            if (value.Contains("0")) // Contiene cero
            {
                if (value == "00") // dos cero, eje: 00
                {
                    return string.Empty;
                }

                else
                {
                    if (value.IndexOf("0") == 0) // cero a la izquierda, eje: 01
                    {
                        return (Enum.GetName(typeof(Unidad), Convert.ToInt32(value.Substring(1, 1))));
                    }

                    else // cero a la derecha, eje: 10
                    {
                        return (Enum.GetName(typeof(DecenaEntero), Convert.ToInt32(value)));
                    }
                }
            }

            else // No contiene cero
            {
                if (Convert.ToInt32(value) > 10 && Convert.ToInt32(value) < 16) // busco en el grupo de decena 
                {
                    return Enum.GetName(typeof(Decena), Convert.ToInt32(value));
                }

                else
                {
                    if (Convert.ToInt32(value) > 15 && Convert.ToInt32(value) < 20)
                    {
                        return "Dieci" + (Enum.GetName(typeof(Unidad), Convert.ToInt32(value.Substring(1, 1)))).ToLower();
                    }

                    else
                    {
                        if ((value.Substring(0, 1)) == "2")
                        {
                            return "Veinti" + (Enum.GetName(typeof(Unidad), Convert.ToInt32(value.Substring(1, 1)))).ToLower();
                        }

                        else
                        {
                            return (Enum.GetName(typeof(DecenaEntero), Convert.ToInt32(value.Substring(0, 1) + 0))) + " y " + Enum.GetName(typeof(Unidad), Convert.ToInt32(value.Substring(1, 1))).ToLower();
                        }
                    }
                }
            }
        }
    }
}
Descarga
Csahrp (C#) Visual basic (VB)
Descripción: