LOOKS LIKE RE TREEING IS WORKING FOR VISTAARS OF RAGA

 

public class TreeGroupingGenerator___CATALANING______BRACKETING_REGROUPING_COPILOTS

    {

       

        public static StringBuilder PUBLIC_STATIC_STRINGBUILDER____RAW_CATALANING___CATALANING______BRACKETING_REGROUPING_COPILOTS = new StringBuilder();

        public static StringBuilder PUBLIC_STATIC_STRINGBUILDER___ONLY_INDIANNOTES_GROUPINGS___CATALANED_TREES______BRACKETING_REGROUPING_COPILOTS = new StringBuilder();

        public static string ReformatAndExpandForestSyntax_Stagewise(string input)

        {

            var output = new StringBuilder();

            // Step 1: Normalize multiple consecutive pipes to a single pipe

            string cleanedInput = System.Text.RegularExpressions.Regex.Replace(input, @"\|{2,}", "|");

            output.Append(cleanedInput); // Start with original cleaned forest

            int start = -1;

            for (int i = 0; i < cleanedInput.Length; i++)

            {

                if (cleanedInput[i] == '|')

                {

                    if (start == -1)

                    {

                        start = i + 1;

                    }

                    else

                    {

                        string treeContent = cleanedInput.Substring(start, i - start);

                        string[] tokens = treeContent.Split(new[] { ' ', ',', ';' }, StringSplitOptions.RemoveEmptyEntries);

                        if (tokens.Length == 0)

                        {

                            start = -1;

                            continue;

                        }

                        // 1. |-a b c|

                        string treeStartDash = "|-" + string.Join(" ", tokens) + "|";

                        output.Append(" ").Append(treeStartDash);

                        // 2. Stage-wise internal dash insertions

                        for (int j = 0; j < tokens.Length - 1; j++)

                        {

                            var stagedTokens = new List<string>();

                            for (int k = 0; k < tokens.Length; k++)

                            {

                                stagedTokens.Add(tokens[k]);

                                if (k == j)

                                {

                                    stagedTokens.Add("-");

                                }

                            }

                            string stagedTree = "|" + string.Join(" ", stagedTokens) + "|";

                            output.Append(" ").Append(stagedTree);

                        }

                        // 3. |a b c-|

                        string treeEndDash = "|" + string.Join(" ", tokens) + "-|";

                        output.Append(" ").Append(treeEndDash);

                        start = -1;

                    }

                }

            }

            return output.ToString();

        }//public static string ReformatAndExpandForestSyntax_Stagewise(string input)

        public static string DISCARDING_TO_HANDLE_MULTIPLE_CONSEQUETIVE_PIPES_WITH_SINGLE_PIPES___ReformatAndExpandForestSyntax_Stagewise(string input)

        {

            var output = new StringBuilder();

            output.Append(input); // Start with original forest

            int start = -1;

            for (int i = 0; i < input.Length; i++)

            {

                if (input[i] == '|')

                {

                    if (start == -1)

                    {

                        start = i + 1;

                    }

                    else

                    {

                        string treeContent = input.Substring(start, i - start);

                        string[] tokens = treeContent.Split(new[] { ' ', ',', ';' }, StringSplitOptions.RemoveEmptyEntries);

                        // 1. |-a b c|

                        string treeStartDash = "|-" + string.Join(" ", tokens) + "|";

                        output.Append(treeStartDash);

                        // 2. Stage-wise internal dash insertions

                        for (int j = 0; j < tokens.Length - 1; j++)

                        {

                            var stagedTokens = new List<string>();

                            for (int k = 0; k < tokens.Length; k++)

                            {

                                stagedTokens.Add(tokens[k]);

                                if (k == j)

                                {

                                    stagedTokens.Add("-");

                                }//if (k == j)

                            }//for (int k = 0; k < tokens.Length; k++)

                            string stagedTree = "|" + string.Join(" ", stagedTokens) + "|";

                            output.Append(stagedTree);

                        }//for (int j = 0; j < tokens.Length - 1; j++)

                        // 3. |a b c-|

                        string treeEndDash = "|" + string.Join(" ", tokens) + "-|";

                        output.Append(treeEndDash);

                        start = -1;

                    }//if (start == -1)

                }//if (input[i] == '|')

            }//for (int i = 0; i < input.Length; i++)

            return output.ToString();

        }//public static string ReformatAndExpandForestSyntax_Stagewise(string input)

        public static string TreeGroupingGenerator___CATALANING______BRACKETING_REGROUPING_COPILOTS_Main(string input_forest_string)

        {

            PUBLIC_STATIC_STRINGBUILDER____RAW_CATALANING___CATALANING______BRACKETING_REGROUPING_COPILOTS = new StringBuilder();

            PUBLIC_STATIC_STRINGBUILDER____RAW_CATALANING___CATALANING______BRACKETING_REGROUPING_COPILOTS.Clear();

            PUBLIC_STATIC_STRINGBUILDER___ONLY_INDIANNOTES_GROUPINGS___CATALANED_TREES______BRACKETING_REGROUPING_COPILOTS = new StringBuilder();

            PUBLIC_STATIC_STRINGBUILDER___ONLY_INDIANNOTES_GROUPINGS___CATALANED_TREES______BRACKETING_REGROUPING_COPILOTS.Clear();

            //Console.WriteLine("Enter tree syntax (e.g., |a b c| |d e|):");

            string input = input_forest_string.Replace("(", " ").Replace(")", " ").Replace("&","") ;//Console.ReadLine();

            var trees = ParseTrees(input);

            int treeIndex = 1;

            foreach (var tree in trees)

            {

                Console.WriteLine($"\r\nTree {treeIndex++}: {string.Join(" ", tree)}");

                        PUBLIC_STATIC_STRINGBUILDER____RAW_CATALANING___CATALANING______BRACKETING_REGROUPING_COPILOTS

                        .AppendLine

                        ($"\r\nTree {treeIndex++}: {string.Join(" ", tree)}");

                PUBLIC_STATIC_STRINGBUILDER___ONLY_INDIANNOTES_GROUPINGS___CATALANED_TREES______BRACKETING_REGROUPING_COPILOTS

                    .AppendLine

                    (

                    $"\r\n{string.Join(" ", tree)}"

                    );

                var groupings = GenerateGroupings(tree);

                foreach (var grouping in groupings)

                {

                    Console.WriteLine(grouping);

                    PUBLIC_STATIC_STRINGBUILDER____RAW_CATALANING___CATALANING______BRACKETING_REGROUPING_COPILOTS

                        .AppendLine

                        (grouping);

                    PUBLIC_STATIC_STRINGBUILDER___ONLY_INDIANNOTES_GROUPINGS___CATALANED_TREES______BRACKETING_REGROUPING_COPILOTS

                        .AppendLine

                        (

                       grouping

                        );

                }//foreach (var grouping in groupings)

            }//foreach (var tree in trees)

            

                return

                PUBLIC_STATIC_STRINGBUILDER____RAW_CATALANING___CATALANING______BRACKETING_REGROUPING_COPILOTS

                .ToString();

        }//public static string TreeGroupingGenerator___CATALANING______BRACKETING_REGROUPING_COPILOTS_Main(string input_forest_string)

        public static List<List<string>> ParseTrees(string input)

        {

            var trees = new List<List<string>>();

            int start = -1;

            for (int i = 0; i < input.Length; i++)

            {

                if (input[i] == '|')

                {

                    if (start == -1)

                    {

                        start = i + 1;

                    }

                    else

                    {

                        string treeContent = input.Substring(start, i - start);

                        var symbols = treeContent.Split(new[] { ' ', ',',';' }, StringSplitOptions.RemoveEmptyEntries).ToList();

                        trees.Add(symbols);

                        start = -1;

                    }//end of else of if (start == -1)

                }//if (input[i] == '|')

            }//for (int i = 0; i < input.Length; i++)

            return trees;

        }//public static List<List<string>> ParseTrees(string input)

        public static List<string> GenerateGroupings(List<string> symbols)

        {

            var results = new List<string>();

            Generate(symbols, results);

            return results;

        }//public static List<string> GenerateGroupings(List<string> symbols)

        public static void Generate(List<string> symbols, List<string> results)

        {

            if (symbols.Count == 1)

            {

                results.Add(symbols[0]);

                return;

            }//if (symbols.Count == 1)

            for (int i = 1; i < symbols.Count; i++)

            {

                var left = symbols.Take(i).ToList();

                var right = symbols.Skip(i).ToList();

                var leftGroupings = GenerateGroupings(left);

                var rightGroupings = GenerateGroupings(right);

                foreach (var l in leftGroupings)

                {

                    foreach (var r in rightGroupings)

                    {

                        results.Add("(" + l + " " + r + ")");

                    }//foreach (var r in rightGroupings)

                }//foreach (var l in leftGroupings)

            }//for (int i = 1; i < symbols.Count; i++)

        }//public static void Generate(List<string> symbols, List<string> results)

    }//public class TreeGroupingGenerator___CATALANING______BRACKETING_REGROUPING_COPILOTS

/// <summary>

/// ///////////////////////////////////////////////////////////////

/// </summary>

    //frieze seeding numbers

    //https://www.youtube.com/watch?v=0mXz-NP-raY