Convertir palabras (cadena) a Int

Estoy seguro de que esto se ha hecho cientos de veces, pero espero que haya una manera realmente simple de lograrlo. Estoy queriendo cambiar las palabras a un int.

Como el siguiente ejemplo

Uno = 1 Dos = 2 Tres = 3

Entonces, básicamente, si tengo la cadena "Uno", se convierte en 1, incluso si pudiera recuperar una cadena "1", puedo convertirla.

preguntado el 30 de junio de 12 a las 23:06

¿Cuántos números necesitas admitir? 10 o mas? -

Bueno, esencialmente todos los números como si tuviera cien mil seiscientos...

¿Estarán bien formados o serán aportados por el usuario? -

5 Respuestas

Hice esto por diversión... probablemente haya muchos casos extremos que fallarían...

private static Dictionary<string,long> numberTable=
    new Dictionary<string,long>
        {{"zero",0},{"one",1},{"two",2},{"three",3},{"four",4},
        {"five",5},{"six",6},{"seven",7},{"eight",8},{"nine",9},
        {"ten",10},{"eleven",11},{"twelve",12},{"thirteen",13},
        {"fourteen",14},{"fifteen",15},{"sixteen",16},
        {"seventeen",17},{"eighteen",18},{"nineteen",19},{"twenty",20},
        {"thirty",30},{"forty",40},{"fifty",50},{"sixty",60},
        {"seventy",70},{"eighty",80},{"ninety",90},{"hundred",100},
        {"thousand",1000},{"million",1000000},{"billion",1000000000},
        {"trillion",1000000000000},{"quadrillion",1000000000000000},
        {"quintillion",1000000000000000000}};
public static long ToLong(string numberString)
{
    var numbers = Regex.Matches(numberString, @"\w+").Cast<Match>()
         .Select(m => m.Value.ToLowerInvariant())
         .Where(v => numberTable.ContainsKey(v))
         .Select(v => numberTable[v]);
    long acc = 0,total = 0L;
    foreach(var n in numbers)
    {
        if(n >= 1000)
        {
            total += (acc * n);
            acc = 0;
        }
        else if(n >= 100){
            acc *= n;
        }
        else acc += n;          
    }
    return (total + acc)  * ( numberString.StartsWith("minus",
          StringComparison.InvariantCultureIgnoreCase) ? -1 : 1);
}

Respondido 01 Jul 12, 01:07

¿Por qué tienes el doble? continue;? Podrías usar elses. (y +1, por supuesto.) - Ry-

Sí, estoy de acuerdo... mejor con las declaraciones else (¡y también reduce el tamaño del código y satisface mi obsesión por no tener barras de desplazamiento en mi respuesta!) - donante

Tenga en cuenta que the quick brown fox y zero ambos regresan 0. - Eric J.

@EricJ. Quizás el uso de "borde" arriba fue un error. ¡Hay un conjunto casi infinito de casos que fallarán! - donante

Decepcionado, esta función no hace frente a sextillones, septillones, octillones, nonillones ... etc. ;) - davidg

Aquí hay un método que hace eso. Si necesita un rango más amplio, es fácilmente extensible; solo usa un long, ulong, O incluso un BigInty agregue más elementos a la modifiers diccionario.

static int ParseEnglish(string number) {
    string[] words = number.ToLower().Split(new char[] {' ', '-', ','}, StringSplitOptions.RemoveEmptyEntries);
    string[] ones = {"one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
    string[] teens = {"eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
    string[] tens = {"ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
    Dictionary<string, int> modifiers = new Dictionary<string, int>() {
        {"billion", 1000000000},
        {"million", 1000000},
        {"thousand", 1000},
        {"hundred", 100}
    };

    if(number == "eleventy billion")
        return int.MaxValue; // 110,000,000,000 is out of range for an int!

    int result = 0;
    int currentResult = 0;
    int lastModifier = 1;

    foreach(string word in words) {
        if(modifiers.ContainsKey(word)) {
            lastModifier *= modifiers[word];
        } else {
            int n;

            if(lastModifier > 1) {
                result += currentResult * lastModifier;
                lastModifier = 1;
                currentResult = 0;
            }

            if((n = Array.IndexOf(ones, word) + 1) > 0) {
                currentResult += n;
            } else if((n = Array.IndexOf(teens, word) + 1) > 0) {
                currentResult += n + 10;
            } else if((n = Array.IndexOf(tens, word) + 1) > 0) {
                currentResult += n * 10;
            } else if(word != "and") {
                throw new ApplicationException("Unrecognized word: " + word);
            }
        }
    }

    return result + currentResult * lastModifier;
}

Respondido 01 Jul 12, 00:07

Aquí hay una versión C# del algoritmo anterior. Cambié el nombre y reescribí parte del código para mayor claridad y agregué soporte para números negativos, números con guión, cero y combinaciones de palabras de texto y dígitos (como "100 y 5"). Gracias a Ry- por el gran comienzo.

  /// <summary>
  /// Convert text number strings to integer numbers. Credit to stackoverflow
  /// for the main algorithm.
  /// </summary>
  public static int
    WordNumberToInt (string number) {
    // define arrays of keywords to translate text words to integer positions
    // in the arrays. Thus, ordering of words in the array is important.
    string[] ones = {
      "one", "two", "three", "four", "five", "six",
      "seven", "eight", "nine"
    };
    string[] teens = {
      "eleven", "twelve", "thirteen", "fourteen", "fifteen",
      "sixteen", "seventeen", "eighteen", "nineteen"
    };
    string[] tens = {
      "ten", "twenty", "thirty", "forty", "fifty", "sixty",
      "seventy", "eighty", "ninety"
    };
    var bigscales = new Dictionary<string, int> () {
      {"hundred", 100}, {"hundreds", 100}, {"thousand", 1000},
      {"million", 1000000}, {"billion", 1000000000},
    };
    string[] minusWords = {"minus", "negative"};
    var splitchars = new char[] {' ', '-', ','};

    // flip all words to lowercase for proper matching
    var lowercase = number.ToLower ();
    var inputwords = lowercase.Split (splitchars, StringSplitOptions.RemoveEmptyEntries);

    // initalize loop variables and flags
    int result = 0;
    int currentResult = 0;
    int bigMultiplierValue = 1;
    bool bigMultiplierIsActive = false;
    bool minusFlag = false;

    foreach (string curword in inputwords) {
      // input words are either bigMultipler words or little words
      //
      if (bigscales.ContainsKey (curword)) {
        bigMultiplierValue *= bigscales[curword];
        bigMultiplierIsActive = true;
      }

      else {
        // multiply the current result by the previous word bigMultiplier
        // and disable the big multiplier until next time
        if (bigMultiplierIsActive) {
          result += currentResult * bigMultiplierValue;
          currentResult = 0;
          bigMultiplierValue = 1; // reset the multiplier value
          bigMultiplierIsActive = false; // turn it off until next time
        }

        // translate the incoming text word to an integer
        int n;
        if ((n = Array.IndexOf (ones, curword) + 1) > 0) {
          currentResult += n;
        }
        else if ((n = Array.IndexOf (teens, curword) + 1) > 0) {
          currentResult += n + 10;
        }
        else if ((n = Array.IndexOf (tens, curword) + 1) > 0) {
          currentResult += n * 10;
        }
        // allow for negative words (like "minus") 
        else if (minusWords.Contains (curword)) {
          minusFlag = true;
        }
        // allow for phrases like "zero 500" hours military time
        else if (curword == "zero") {
          continue;
        }
        // allow for text digits too, like "100 and 5"
        else if (int.TryParse (curword, out int tmp)) {
          currentResult += tmp;
        }
        else if (curword != "and") {
          throw new ApplicationException ("Expected a number: " + curword);
        }
      }
    }

    var final = result + currentResult * bigMultiplierValue;
    if (minusFlag)
      final *= -1;
    return final;
  }

Aquí hay algunos casos de prueba que ejecuté.

  -20 = minus twenty
 -261 = minus two hundred sixty one
 1965 = nineteen hundred and sixty five
   45 = forty five
   55 = fifty-five
   21 = twenty-one
   55 = fifty five
    0 = zero
  105 = one hundred 5
  105 = 100 and 5

Respondido el 03 de diciembre de 19 a las 20:12

Tomé un enfoque ligeramente diferente para el manejo de errores...

  public static bool ParseEnglishNumberPhrase(string pNumberPhrase, out int pValue) {
     pValue = 0;
     string[]
        temporaryWords = pNumberPhrase.ToLower().Split(new char[] { '_', ' ', '-', ',' }, StringSplitOptions.RemoveEmptyEntries),
        ones = { "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" },
        teens = { "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" },
        tens = { "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" },
        minusWords = { "minus", "negative", "hyphen" };
     List<string> words = temporaryWords.ToList();
     bool minusFlag = false;
     Dictionary<string, int> modifiers = new Dictionary<string, int>() {
        { "billion", 1000000000 },
        { "million", 1000000 },
        { "thousand", 1000 },
        { "hundred", 100 } };
     int result = 0, currentResult = 0, lastModifier = 1;


     if (pNumberPhrase.Equals("eleventy billion")) {
        pValue = int.MaxValue; // 110,000,000,000 is out of range for an int!
        return false;
     }
     if (words[0].Equals("zero") && (words.Count == 1)) {
        pValue = 0;
        return true;
     }
     else if (words[0].Equals("zero"))
        words.RemoveAt(0);
     if (pNumberPhrase.StartsWith("-"))
        minusFlag = true;
     foreach (string word in minusWords) {
        if (pNumberPhrase.Contains(word)) {
           minusFlag = true;
           words.Remove(word);
        }
     }
     if (words.Count == 1) {
        if (int.TryParse(words[0], out int pOutValue)) {
           pValue = pOutValue;
           if (minusFlag)
              pValue *= -1;
           return true;
        }
     }
     foreach (string word in words) {
        if (modifiers.ContainsKey(word))
           lastModifier *= modifiers[word];
        else {
           int n;

           if (lastModifier > 1) {
              result += currentResult * lastModifier;
              lastModifier = 1;
              currentResult = 0;
           }
           if ((n = Array.IndexOf(ones, word) + 1) > 0)
              currentResult += n;
           else if ((n = Array.IndexOf(teens, word) + 1) > 0)
              currentResult += n + 10;
           else if ((n = Array.IndexOf(tens, word) + 1) > 0)
              currentResult += n * 10;
           else if (word != "and") {
              pValue = -1;
              return false;
           }
        }
     }
     pValue = result + currentResult * lastModifier;
     if (minusFlag)
        pValue *= -1;
     return true;
  }

Respondido 08 Feb 22, 17:02

Creo que una solución mucho más fácil de entender es la siguiente:

public static int ParseInt(string s)
{
  var wordArray = s.Split(' ', '-');
  int finalNumber = 0;
  
  Dictionary<string, int> additionWords = new Dictionary<string, int>{
    {"one" , 1}, {"two", 2},{"three", 3},{"four", 4},{"five", 5},{"six", 6},
    {"seven", 7},{"eight", 8},{"nine", 9},{"ten", 10},{"eleven", 11},{"twelve", 12},
    {"thirteen", 13},{"fourteen", 14},{"fifteen", 15},{"sixteen", 16},{"seventeen", 17},
    {"eighteen", 18},{"nineteen", 19},{"twenty", 20},{"thirty", 30},{"forty", 40},
    {"fifty", 50},{"sixty", 60},{"seventy", 70},{"eighty", 80},{"ninety", 90}  
  };
  
  Dictionary<string, int> multiplicationWords = new Dictionary<string, int>{
    {"hundred", 100},{"thousand", 1000},{"million", 1000000}
  };
  
  int multiplier = 1;
  
  for (int i = wordArray.Length - 1; i >= 0; i--){
    if (additionWords.ContainsKey(wordArray[i])){
      finalNumber += additionWords[wordArray[i]] * multiplier;
    }
    if (multiplicationWords.ContainsKey(wordArray[i])){          
      if (multiplicationWords[wordArray[i]] < multiplier){
        multiplier *= multiplicationWords[wordArray[i]];
      }else{
        multiplier = multiplicationWords[wordArray[i]];
      }
    }
  }    
  return finalNumber;
}

Respondido 10 Feb 22, 23:02

Tal como está escrito actualmente, su respuesta no está clara. Por favor editar para agregar detalles adicionales que ayudarán a otros a comprender cómo esto aborda la pregunta formulada. Puede encontrar más información sobre cómo escribir buenas respuestas. en el centro de ayuda. - Comunidad

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.