using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;  

​

public class Program

{

    public static void Main()

    {

        string[] namespaces = new[] { // Set namespaces from types

            "Root.Sub11.Sub11.Sub3",

            "Root.Sub11.Sub11",

            "Root.Sub11.Sub21",

            "Root.Sub11.Sub21.Sub12",

            "Root.Sub11.Sub21.Sub13.Sub14",

            "Root.Sub11.Sub21.Sub13.Sub14",

            "Root.Sub11.Sub21.Sub13.Sub14",

            "Root.Sub11.Sub21.Sub13.Sub14.Sub47",

        };

        /* Should result in this list of directories:

         * Root.Sub11/Sub11/Sub3

         * Root.Sub11/Sub11

         * Root.Sub11/Sub21

         * Root.Sub11/Sub21/Sub12

         * Root.Sub11/Sub21/Sub13.Sub14

         * Root.Sub11/Sub21/Sub13.Sub14

         * Root.Sub11/Sub21/Sub13.Sub14

         * Root.Sub11/Sub21/Sub13.Sub14/Sub57

         */

        NamespacesToDirectoryStructure(namespaces.Select(n => n.Split(".")));

        var sb = new StringBuilder();

        foreach(var dir in typeNamespaceToPathMap.Values)

        {

            sb.AppendLine(new string(dir));

        }

        Console.WriteLine(sb.ToString());

    }

    private static readonly IDictionary<string[], char[]> typeNamespaceToPathMap = new Dictionary<string[], char[]>();

​

    private static void NamespacesToDirectoryStructure(IEnumerable<string[]> namespaces)

    {

        IList<string[]> processedTypeNamespaces = new List<string[]>();

        foreach (string[] segments in namespaces

                 .Distinct(new StringSequenceEqualityComparer())

                 .OrderBy(n => n.Length))

        {

            int segment = 0;

            char[] path = string.Join('.', segments).ToCharArray();

            IList<int> sharedNamespacePortionIndices;

            IList<string[]> sharedNamespacePortions = processedTypeNamespaces;

            do

            {

                // All namespaces, that share the segment and all previous with this.

                sharedNamespacePortionIndices = IndexOfAll(sharedNamespacePortions, segments, segment).ToList();

                if (segment != 0)

                {

                    // All namespaces, that share all previous segments with this.

                    IList<int> indices = sharedNamespacePortionIndices;

                    IEnumerable<string[]> removedNamespaces = TakeWhere(sharedNamespacePortions, (i, x) => !indices.Contains(i));

                    if (removedNamespaces.Any())

                    {

                        // Convert the [.] to [\] to indicate a path branching for all that share previous segments

                        int charIndex = segments.Take(segment).Select(s => s.Length).Aggregate(0, (x, y) => x + y + 1) - 1;

                        path[charIndex] = '\\';

                        foreach (char[] value in typeNamespaceToPathMap

                                 .Where(kvp => kvp.Value.Length > charIndex && (ReferenceEquals(kvp.Key, segments) || sharedNamespacePortions.Contains(kvp.Key)))

                                 .Select(kvp => kvp.Value))

                        {

                            value[charIndex] = '\\';

                        }

                    }

​

                }

                sharedNamespacePortions = TakeWhere(sharedNamespacePortions, (i, x) => sharedNamespacePortionIndices.Contains(i)).ToList();

                segment++;

            } while (segment < segments.Length && sharedNamespacePortions.Count > 0);

​

            processedTypeNamespaces.Add(segments);

            typeNamespaceToPathMap.Add(segments, path);

        }

    }

​

    private static IEnumerable<int> IndexOfAll(IList<string[]> collection, string[] test, int segment)

    {

        for (int index = 0; index < collection.Count; index++)

        {

            if (collection[index].Length > segment && String.Equals(test[segment], collection[index][segment], StringComparison.Ordinal))

            {

                yield return index;

            }

        }

    }

​

    private static IEnumerable<string[]> TakeWhere(IList<string[]> collection, Func<int, string[], bool> predicate)

    {

        for (int i = 0; i < collection.Count; i++)

        {

            if (predicate(i, collection[i]))

            {

                yield return collection[i];

            }

        }

    }

​

    private class StringSequenceEqualityComparer : IEqualityComparer<string[]>

    {

        public bool Equals(string[] x, string[] y)

        {

            if (x is null || x.Length != y?.Length)

                return false;

            Console.WriteLine(string.Join(".", x) + " <=> " + string.Join(".", y));

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

            {

                if (!x[i].Equals(y[i], StringComparison.Ordinal))

                    return false;

            }

            return true;

        }

​

        public int GetHashCode(string[] obj) => obj.GetHashCode(true);

    }

}

​

///<summary>Source: https://github.com/ProphetLamb-Organistion/Groundbeef/blob/master/src/Collections/Collections/CollectionHashing.cs</summary>

public static class CollectionHashing

{

    /// <summary>

    /// Serves as the default hash function. If <paramref name="fromValues"/> is <see cref="true"/> returns the combined hashcode of all elements widthin the <see cref="IList"/>; otherwise returns the default hashcode.

    /// </summary>

    /// <param name="list">The list containing the elements.</param>

    /// <param name="fromValues">Indicates that the hashcode should be derived from the elements of the list instead.</param>

    /// <exception cref="ArgumentNullException"></exception>

    /// <exception cref="ArgumentException"></exception>

    /// <exception cref="NullReferenceException"></exception>

    public static int GetHashCode(this IList list, bool fromValues)

    {

        if (list is null)

            throw new ArgumentNullException(nameof(list));

        if (!fromValues)

            return list.GetHashCode();

        int length = list.Count;

        if (length == 0)

            throw new ArgumentException(nameof(list), "List cannot be empty");

        int c = 0;

        for (int i = 0; i < length; i++)

        {

            object value = list[i] ?? throw new NullReferenceException("Value cannot be null");

            c = CombineHashCodes(c, value.GetHashCode());

        }

        return c;

    }

    internal static int CombineHashCodes(int h1, int h2)

    {

        return ((h1 << 5) + h1) ^ h2;

    }

}