将多行字符串旋转 90 度 - 行变成列

Question

Say I have a string like

Line 1
Line 2

I want to turn this string 90 degrees clockwise, so that it becomes

LL
ii
nn
ee

12

The rotation needs to be performed only once such that it is in effect 'turning lines into columns.' Performing it twice should give the original string. (If it was truly rotating by 90 degrees, it would have to be repeated four times to arrive back at the original.)

Answer 1

using System;
using System.Collections;
using System.Collections.Generic;

namespace rotateString
{
    class Program
    {
        static void Main(string[] args)
        {
            var strings = new string[] { "Line 1", "Line 2" };

            var lines = new List<string>();

            var done = false;
            var j = 0;
            do
            {
                var line = "";
                for (var i = 0; i < strings.Length; ++i)
                {
                    var s = strings[i];
                    if (j >= s.Length)
                    {
                        done = true;
                        break;
                    }
                    line += s[j];
                }
                lines.Add(line);
                ++j;
            } while (!done);

            for(int i=0; i < lines.Count; ++i)
            {
                Console.WriteLine(string.Format("{0} : '{1}'", i, lines[i]));
            }
        }
    }
}

Output:

0 : 'LL'
1 : 'ii'
2 : 'nn'
3 : 'ee'
4 : '  '
5 : '12'
6 : ''

Note that this pretty much assumes the strings are all the same length. Adjusting it to work with the longest string length is trivial.

Using a StringBuilder would be a bit more efficient but, unless you're working with a lot of very long strings, you'll never see the difference in performance.

Answer 2

This was interesting to try out and write. I haven't spent time on validation and characters, but I was trying to see if I can write something that is somewhat "compact" (challenge to myself mostly in evening hours).

@KayZed I will also run your implementation, I see you did some more validations about the inputs.

@3Dave I see we had similar ideas about this ;)

My idea around this was a projection of the input strings (plus now I hard-coded the length of the Span<char> , that calculation can be made simple) into the "flattened" structure of all characters with the offset of the index based on the number of inputs.

My "solution":

using System.Collections.Generic;

public class Program
{
    public static void Main(string[] args)
    {
        var inputs = new[] { "Short", "Line 1", "Line 2", "Much longer line 3", "🧐" };
        
        Rotate(inputs);
    }

    public static void Rotate(IReadOnlyCollection<string> aValues)
    {
        Span<char> chars = stackalloc char[100];
        var offset = 0; 
        foreach (var value in aValues)
        {
            var index = 0;
            foreach (char character in value)
            {
                chars[index + offset] = character;
                index += aValues.Count;
            }
            offset++;
        }

        var position = 0;
        foreach (char character in chars)
        {
            Console.Write(character == default(char) ? ' ' : character);
            Console.Write(' ');

            if (position == aValues.Count - 1)
            {
                Console.WriteLine();
                position = 0;
                continue;
            }

            position++;
        }
    }
}

I probably missed some edge cases (and didn't handle the "special" characters), but hope this gives an idea on some "optimisations".

The output:

S L L M � 
h i i u � 
o n n c   
r e e h   
t         
  1 2 l   
      o   
      n   
      g   
      e   
      r   
          
      l   
      i   
      n   
      e   
          
      3   
          

Answer 3

It will need to add leading spaces (ie columns which were preceding shorter lines in the original string.) This method gives you an option to make this visible ( fillChar - several options provided as constants.)

Also the additional ReverseLineOrder method reverses the line order in case you would want to rotate 90 degrees, reversing all lines.

using System;
using System.Globalization;
using System.Text;

namespace Library.Text
{
    public static class TextRotate
    {
        public const char Space = ' ';
        public const char MiddleDot = '\u00b7';
        public const char Circle = '\u25cb';
        public const char BlackSquare = '\u25a0';
        public const char NoBreakSpace = '\u00a0';

        public static string LinesToColumns(string s, char fillChar = Space)
        {
            // A line feed at the end of the text is not seen as content.
            // However, if the text ends in a line feed, we make sure the output ends in one, too.

            bool endsWithNewline = s.EndsWith(Environment.NewLine);

            string[] linesIn = s.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);

            int[][] textElements = new int[linesIn.Length][];

            int longestLine_chars = 0;
            int longestLine_elems = 0; // The longest line, in text elements

            for (int l = 0; l < linesIn.Length; l++)
            {
                string line = linesIn[l];

                if (line.Length > longestLine_chars)
                {
                    longestLine_chars = line.Length;
                }

                var elems = StringInfo.ParseCombiningCharacters(line); // Gets indices of surrogate pairs, combining characters etc.

                if (elems.Length > longestLine_elems)
                {
                    longestLine_elems = elems.Length;
                }

                textElements[l] = elems;
            }

            // Go through columns (columns in the input text, and columns in terms of text elements - NOT chars)

            string[] columns = new string[longestLine_elems];

            var builder = new StringBuilder(longestLine_chars * linesIn.Length + Math.Max(longestLine_chars, linesIn.Length) * Environment.NewLine.Length);

            for (int column = 0; column < longestLine_elems; column++)
            {
                builder.Clear();
                System.Diagnostics.Debug.Assert(builder.Length == 0);
                int cutoff = 0;

                for (int l = 0; l < linesIn.Length; l++)
                {
                    // Is the line long enough to reach to this column?

                    int[] lineTextElements = textElements[l];
                    int textElementsInLine = lineTextElements.Length;

                    if (textElementsInLine > column)
                    {
                        int firstCharIndex = lineTextElements[column];

                        if (column + 1 < textElementsInLine)
                        {
                            int nrOfChars = lineTextElements[column + 1] - firstCharIndex;
                            builder.Append(linesIn[l], firstCharIndex, nrOfChars);
                        }
                        else
                        {
                            builder.Append(linesIn[l], firstCharIndex, linesIn[l].Length - firstCharIndex);
                        }

                        cutoff = builder.Length;
                    }
                    else
                    {
                        builder.Append(fillChar);
                    }
                }

                // Trim the fill char off line endings (for when rotating back)
                while (cutoff > 0 && builder[cutoff - 1] == fillChar)
                {
                    cutoff--;
                }

                // Resulting column
                columns[column] = builder.ToString(0, cutoff);
            }

            // Turn the columns into lines
            builder.Clear();

            foreach (var c in columns)
            {
                builder.AppendLine(c);
            }

            if (!endsWithNewline && builder.Length > 0)
            {
                builder.Length -= Environment.NewLine.Length;
            }

            return builder.ToString();
        }

        public static string ReverseLineOrder(string s)
        {
            // A line feed at the end of the text is not seen as content.
            // However, if the text ends in a line feed, we make sure the output ends in one, too.

            bool endsWithNewline = s.EndsWith(Environment.NewLine);

            string[] linesIn = s.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);

            var builder = new StringBuilder(s.Length);

            for (int l = linesIn.Length - (endsWithNewline ? 2 : 1); l >= 0; l--)
            {
                builder.AppendLine(linesIn[l]);
            }

            if (!endsWithNewline && builder.Length > 0)
            {
                builder.Length -= Environment.NewLine.Length;
            }

            return builder.ToString();
        }
    }
}