C# 要垂直显示的字母表排序列表

我有一张清单，里面有字母表

使用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;
                }

            }

        }

@{
var-ie=0；
int-sortI=0；
}
int列=3；
int dictLength=ToShow.Count（）；
int行=长度/列；
整数排序=1；
List hasKey=newlist（）；
var newDict=新字典（）；
if（按字母顺序排序）
{
而（sortILINQ的快速示例：

 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();
}

void Main（）
{
var targetnRows=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=字母表
.Select（（el，i）=>new{row=i/targetnrows，col=i%targetnrows，el2=el}）//计算矩阵“abc”的索引，依此类推
.Select（el=>new{row2=el.col，col2=el.row，el3=el.el2}）//转换所述矩阵，从而获得所需矩阵
.OrderBy（el=>el.row2）.ThenBy（el=>el.col2）；//按行排序，然后按列排序
for（int i=0；iel.row2==i）。选择（el=>el.el3）；//获取第i行
foreach（行中的var项目）
{
控制台。写入（项）；
}
Console.WriteLine（）；
}
r、 Dump（）；
}

请告诉我您是否有任何问题。
如果您知道每行要显示多少个字母，您可以这样做：

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();
}

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行=3；
var指数=0；
对于（变量行=0；行<行；行++）{
对于（变量字母=字母索引；字母<26；字母+=行）{
Console.Out.Write（字母[字母]+“”）；
如果（字母+行>=26）
字母索引=（字母+行）-26；
}
Console.Out.WriteLine（）；
}

行将设置所需的行数，而不是为您计算的行数。
它真正适用于能够“垂直”对任何（IComparable）集合进行分组和排序，字母表之类的一系列字符可能是最可见/最常见的字符

根据要求，行数或每列项目数：

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;
}

publicstaticilistgroupcollection（列表可比，int-groupSize，bool-sortAscending=true），其中T:IComparable
{
变量组=新列表（）；
如果（可比较！=null&&groupSize>0）
{
var items=sortAscending？compariable.OrderBy（item=>item.ToList（）：compariable.OrderByDescending（item=>item.ToList（）；
int totalItems=可比较的。计数；
int totalGroups=totalItems%groupSize>0？totalItems/groupSize+1:totalItems/groupSize；
对于（int-groupIndex=0；groupIndex
谢谢。我发现，不管怎样，由于缺少字母，这都不会像我喜欢的那样起作用，因此我找到了另一种方法。但您的示例提供了我要求的详细信息，对字母表进行排序，因此您是赢家！：）