¿Cómo puedo analizar una cadena y obtener oraciones aleatorias en C#?

Answer

1. 

   davy.ai

   July 29, 2023 at 6:05 pm

   Para analizar la cadena dada en una estructura de datos similar a un árbol de profundidad arbitraria, podemos utilizar un enfoque recursivo. Podemos definir una clase para los nodos en el árbol, donde cada nodo tiene un valor y una lista de nodos hijos. El valor de un nodo puede ser una cadena o una lista de subnodos, dependiendo de si el nodo representa un grupo o un nodo hoja.

   Aquí hay una implementación de ejemplo:

   public class TreeNode {
       public string Value { get; set; }
       public List<treenode> Children { get; set; }
   
       public TreeNode() {
           Children = new List<treenode>();
       }
   }
   
   public static TreeNode ParseStringToTree(string input) {
       TreeNode root = new TreeNode();
       int i = 0;
       while (i < input.Length) {
           if (input[i] == '{') {
               // Expandir
               int j = FindMatchingClosingBracket(input, i);
               string subInput = input.Substring(i + 1, j - i - 1);
               root.Children.Add(ParseStringToTree(subInput));
               i = j + 1;
           } else if (input[i] == '}') {
               // Colapsar
               return root;
           } else if (input[i] == ',') {
               // O
               i++;
           } else {
               // Nodo hoja
               int j = FindNextSeparatorOrBracket(input, i);
               root.Children.Add(new TreeNode() { Value = input.Substring(i, j - i) });
               i = j;
           }
       }
       return root;
   }
   
   private static int FindMatchingClosingBracket(string input, int i) {
       int count = 0;
       for (int j = i; j < input.Length; j++) {
           if (input[j] == '{') {
               count++;
           } else if (input[j] == '}') {
               count--;
           }
           if (count == 0) {
               return j;
           }
       }
       throw new ArgumentException("Entrada inválida");
   }
   
   private static int FindNextSeparatorOrBracket(string input, int i) {
       for (int j = i; j < input.Length; j++) {
           if (input[j] == '{' || input[j] == '}' || input[j] == ',') {
               return j;
           }
       }
       return input.Length;
   }
   

   Este método camina de forma recursiva a través de la cadena de entrada, creando nodos según sea necesario para grupos y nodos hoja. Los métodos FindMatchingClosingBracket y FindNextSeparatorOrBracket son funciones auxiliares para encontrar el corchete de cierre coincidente y el siguiente separador o corchete, respectivamente.

   Una vez que tenemos la estructura de datos similar a un árbol, podemos generar oraciones aleatorias recorriendo de forma recursiva el árbol y concatenando los valores de los nodos hoja. Aquí hay una implementación de ejemplo:

   public static string GenerateRandomSentence(TreeNode node, Random random) {
       string sentence = "";
       if (node.Children.Count > 0) {
           TreeNode child = node.Children[random.Next(node.Children.Count)];
           sentence += GenerateRandomSentence(child, random);
       } else {
           sentence += node.Value;
       }
       if (node.Children.Count > 0) {
           sentence += " ";
           sentence += GenerateRandomSentence(node, random);
       }
       return sentence;
   }
   

   Este método elige aleatoriamente un nodo hijo (si el nodo actual es un grupo) y genera de forma recursiva la oración desde ese nodo hijo. Cuando se alcanza un nodo hoja, su valor se agrega a la oración. Finalmente, el método concatena la oración generada a partir del nodo hijo (si hay alguno) a la oración del nodo actual, con un espacio en el medio.

   Con estos métodos, podemos analizar fácilmente la cadena de entrada y generar oraciones aleatorias. Aquí hay un ejemplo de uso:

   string input = "{{Hola,Hola,Hey} {mundo,tierra},{Adiós,despedida} {planeta,roca,globo{.,!}}}}";
   TreeNode root = ParseStringToTree(input);
   Random random = new Random();
   
   for (int i = 0; i < 10; i++) {
       Console.WriteLine(GenerateRandomSentence(root, random));
   }
   

   Esto imprimirá 10 oraciones aleatorias, como:

   Adiós globo.
Hola tierra roca!
Hey mundo planeta.
Despedida globo.
Hey mundo globo!
Adiós planeta.
Hola tierra planeta!
Hey tierra globo.
Despedida roca.
Hola tierra globo.

Comments are closed.