Question

我有一个包含字母表的列表。

使用foreach输出时，我将收到此结果：

A B C
D E F
G H I

我想要实现的是

A D G
B E H
C F I

我尝试了以下内容，但实际上，我认为这是一个好的或稳定的解决方案 - 字母/索引会出现两次。

        @{
            var ie = 0;
            int sortI = 0;

}
            int columns = 3;
            int dictLength = ToShow.Count();
            int rows = dictLength/columns;

            int sortS = 1;
            List<int> hasKey = new List<int>();

            var newDict = new Dictionary<string, List<LoopItem> >();


            if( sort.Equals("alphabetically") )
            {

                while( sortI <= rows )
                {

                        <text>Column @( ToShow.Keys.ElementAt(sortI) ) - </text>

                        while( sortS <= ( columns ) )
                        {           
                                int index = (( sortS *  columns ) + sortI); //(( sortS *  columns ) + ( 1 + sortI ));

                                if( hasKey.Contains(index) ) { continue; } else
                                {

                                    <text>Column @( ToShow.Keys.ElementAt(index) ) - </text>
                                    sortS++;
                                    hasKey.Add(index);
                                }
                        }
                            <text><br /></text>
                        sortS = 1;
                        sortI++;
                }

                sortS = 1;
                sortI = 1;
                <text><hr /></text>
                foreach( var item in ToShow )
                {
                        <text><br/>::Række 1::<br /></text>
                    while( columns >= sortS )
                    {
                            <text>Indsæt @(sortI+sortS)<br /></text>
                            sortS++;
                    }

                    sortI++;
                    sortS = 1;
                }

            }

        }

这种东西有算法吗？还是一个简单的功能？

提前致谢

Answer 1

如果您知道要在每行上显示多少个字母，您可以执行以下操作：

var alphabet = new []{'A', 'B', 'C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
var rows = 3;
var alphabetIndex = 0;

for(var row = 0; row < rows; row++) {
    for(var letter = alphabetIndex; letter < 26; letter += rows) {
        Console.Out.Write(alphabet[letter] + " ");
        if(letter + rows >= 26)
            alphabetIndex = (letter + rows) - 26;
    }
    Console.Out.WriteLine();
}

行将设置您想要的行数，而不是它应该为您设置的行。

Answer 2

使用LINQ的快速示例：

 void Main()
{
     var targetNrOfRows = 3;
        var alphabet = new[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };

        var r = alphabet
        .Select((el, i) => new { row = i / targetNrOfRows, col = i % targetNrOfRows, el2 = el })//compute indices of matrix 'A B C' and so forth
        .Select(el => new { row2 = el.col, col2 = el.row, el3 = el.el2 })//Transpose said Matrix and thus obtain the desired matrix
        .OrderBy(el => el.row2).ThenBy(el => el.col2);//Order by row and then by column

        for (int i = 0; i < targetNrOfRows; i++)//print it out
        {
            var row = r.Where(el => el.row2 == i).Select(el => el.el3);//get i-th row
            foreach (var item in row)
            {
                Console.Write(item); 
            }
            Console.WriteLine();
        }
r.Dump();
}

让我知道您是否有任何问题。

Answer 3

它真的适用于能够“垂直”分组和排序任何（IComparable）集合，一系列字符，如字母表可能是最明显/最常见的字符。

根据要求，行数(Bob's answer)或每列的项数：

public static IList<IList<T>> groupCollection<T>(List<T> comparable, int groupSize, bool sortAscending = true) where T : IComparable
{
    var groups = new List<IList<T>>();
    if (comparable != null && groupSize > 0)
    {
        var items = sortAscending ? comparable.OrderBy(item => item).ToList() : comparable.OrderByDescending(item => item).ToList();
        int totalItems = comparable.Count;

        int totalGroups = totalItems % groupSize > 0 ? totalItems / groupSize + 1 : totalItems / groupSize;
        for (int groupIndex = 0; groupIndex < totalGroups; groupIndex++)
        {
            int k = 0;
            for (int j = groupIndex; j < totalItems && k < groupSize; j += totalGroups)
            {
                k++;
                if (groups.ElementAtOrDefault(groupIndex) == null)
                {
                    groups.Add(new List<T>());
                }
                groups[groupIndex].Add(items[j]);
            }
        }
    }
    return groups;
}

垂直显示的字母排序列表

3 个答案: