print array in clockwise

EDIT 1: Added an alternative method body

Hi.

Here is my solution.

You will find 3 overloaded methods to accept a 2D matrix of all chars (char[,]), a list of lines (string[]), a text (string).
The char[,] overload is the only doing the computation (the others two delegates to it).

static string RebuildClockwise(string text)
{
    // Delegate computation to "string[]" overload
    var result = RebuildClockwise(text.Split(new[] { Environment.NewLine }, StringSplitOptions.None));
    return result;
}
static string RebuildClockwise(params string[] lines)
{
    // Fetch total counts of rows/lines and columns (max length of all lines)
    var nRowCount = lines.Length;
    var nColCount = lines.Max(line => line.Length);
    // Loop all lines with lesser length and pad them with spaces
    for (int ixLine = 0; ixLine < lines.Length; ixLine++)
    {
        var line = lines[ixLine];
        if (line.Length < nColCount)
            lines[ixLine] = line.PadRight(nColCount);
    }
    // Translate the lines into chars
    var chars = new char[nRowCount, nColCount];
    for (int ixRow = 0; ixRow < nRowCount; ixRow++)
    {
        for (int ixCol = 0; ixCol < nColCount; ixCol++)
        {
            chars[ixRow, ixCol] = lines[ixRow][ixCol];
        }
    }
    // Delegate computation to "char[,]" overload
    var result = RebuildClockwise(chars);
    return result;
}
static string RebuildClockwise(char[,] chars)
{
    // Fetch total count of chars for loop safety
    var nTotalCount = chars.GetLength(0) * chars.GetLength(1);

    // Store the limits
    var aLimits = new int[4];
    aLimits[Dir_Right] = chars.GetLength(1) - 1;
    aLimits[Dir_Down] = chars.GetLength(0) - 1;
    aLimits[Dir_Left] = 0;
    aLimits[Dir_Up] = 0;

    var result = string.Empty;

    // Start at Top Left corner (0,0) pointing Right
    var ixCol = 0;
    var ixRow = 0;
    var nDirection = Dir_Right;
    // For safety, check the count of processed chars to avoid infinite loop
    for (var nProcessedCount = 0; nProcessedCount < nTotalCount; nProcessedCount++)
    {
        result += chars[ixRow, ixCol];

        if (!RebuildClockwise_Move(aLimits, ref nDirection, ref ixCol, ref ixRow))
            break;
    }

    return result;
}

The main function (RebuildClockwise(char[,] chars)), first stores the matrix limits and initializes the direction and cell location to start with.
Then loops updating the result and calling another function (RebuildClockwise_Move) that changes the cell location and direction.

private static bool RebuildClockwise_Move(int[] aLimits, ref int nDirection, ref int ixCol, ref int ixRow)
{
    // Try all 4 directions
    for (var nTrial = MinDir + 1; nTrial <= MaxDir + 1; nTrial++)
    {
        switch (nDirection)
        {
            case Dir_Right:
                // There are still unprocessed columns on the Right
                if (ixCol < aLimits[nDirection])
                {
                    // Select next column to the Right
                    ixCol++;
                    return true;
                }

                // If we get here, then we have exhasuted all the Columns for the current Row: discard current Row
                aLimits[(nDirection + 3) % 4]++;
                break;
            case Dir_Down:
                // There are still unprocessed rows Below
                if (ixRow < aLimits[nDirection])
                {
                    // Select next row to Below
                    ixRow++;
                    return true;
                }

                // If we get here, then we have exhasuted all the Rows for the current Column: discard current Column
                aLimits[(nDirection + 3) % 4]--;
                break;
            case Dir_Left:
                // There are still unprocessed columns on the Left
                if (ixCol > aLimits[nDirection])
                {
                    // Select next column to the Left
                    ixCol--;
                    return true;
                }

                // If we get here, then we have exhasuted all the Columns for the current Row: discard current Row
                aLimits[(nDirection + 3) % 4]--;
                break;
            case Dir_Up:
                // There are still unprocessed rows Above
                if (ixRow > aLimits[nDirection])
                {
                    // Select next row to Above
                    ixRow--;
                    return true;
                }

                // If we get here, then we have exhasuted all the Rows for the current Column: discard current Column
                aLimits[(nDirection + 3) % 4]++;
                break;
        }

        // Pick the next (clockwise) direction
        nDirection++;
        if (nDirection > MaxDir)
            nDirection = MinDir;
    }

    // We Tried all directions, then we are at the center of the matrix and should stop
    return false;
}

RebuildClockwise_Move, based on the direction, change the row and/or column index and updates the limits.
When no row or column is available, it returns false to stop looping.

Both methods make use of some constants to manage the direction:

const int Dir_Right = 0;
const int Dir_Down = Dir_Right + 1;
const int Dir_Left = Dir_Down + 1;
const int Dir_Up = Dir_Left + 1;
const int MinDir = 0;
const int MaxDir = 3;

The following test code allow to check the computation is correct:

MessageBox.Show(RebuildClockwise("1234", "CDE5", "BGF6", "A987"));
MessageBox.Show(RebuildClockwise("12345", "EFGH6", "DKJI7", "CBA98"));
MessageBox.Show(RebuildClockwise("1234", "EFG5", "DKH6", "CJI7", "BA98"));
MessageBox.Show(RebuildClockwise("12345678"));
MessageBox.Show(RebuildClockwise("1234", "8765"));
MessageBox.Show(RebuildClockwise("12", "83", "74", "65"));
MessageBox.Show(RebuildClockwise("1", "2", "3", "4", "5", "6", "7", "8"));

They should display a text between 12345678 and 123456789ABCDEFGHIJK (the input values are arranged in order to obtain an understandable result).

Overall, this solution is more generalized (and complex) than your sample code but it can be simplified replacing the aLimits array and the switch block with code using constants or plain variables.

Regards,
Daniele.

EDIT 1: The following functions is an alternative to the char[,] overload.
This one will use two concurrent variables to move row and column instead of relying on the nDirection variable; this version also incorporate the movement logic.

static string RebuildClockwise(char[,] chars)
{
    // Fetch maximum column and row indices
    var nMaxCol = chars.GetLength(1) - 1;
    var nMaxRow = chars.GetLength(0) - 1;
    // Fetch total count of chars for loop safety
    var nTotalCount = (nMaxRow + 1) * (nMaxCol + 1);

    var result = string.Empty;

    // Fixed minimum column and row indices
    var nMinCol = 0;
    var nMinRow = 0;
    // Start at 0,0
    var ixCol = 0;
    var ixRow = 0;
    // Initial direction is Col++ (toward Right)
    var nDeltaCol = 1;
    var nDeltaRow = 0;

    // For safety, check the count of processed chars to avoid infinite loop
    for (var nProcessedCount = 0; nProcessedCount < nTotalCount; nProcessedCount++)
    {
        result += chars[ixRow, ixCol];

        var bMoved = false;
        // Try all 4 directions
        for (var nTrial = 1; nTrial <= 4; nTrial++)
        {
            // Compute new location
            var ixColN = ixCol + nDeltaCol;
            var ixRowN = ixRow + nDeltaRow;
            // If location is within min and max, then accept it
            if ((ixColN >= nMinCol) && (ixColN <= nMaxCol) && (ixRowN >= nMinRow) && (ixRowN <= nMaxRow))
            {
                ixCol = ixColN;
                ixRow = ixRowN;

                // Tell outside of for loop that the new location has been found
                bMoved = true;
                break;
            }

            // If location is beyond min column, discard (current) max row
            if (ixColN < nMinCol)
                nMaxRow--;
            // If location is beyond max column, discard (current) min row
            else if (ixColN > nMaxCol)
                nMinRow++;
            // If location is beyond min row, discard (current) min column
            else if (ixRowN < nMinRow)
                nMinCol++;
            // If location is beyond max row, discard (current) max column
            else if (ixRowN > nMaxRow)
                nMaxCol--;

            // Rotate increments (they are like cosine and sine of angles 0, 90, 180, 270)
            var nTemp = nDeltaCol;
            nDeltaCol = -nDeltaRow;
            nDeltaRow = nTemp;
        } 
        // We Tried all directions, then we are at the center of the matrix and should stop
        if (!bMoved)
            break;
    }

    return result;
}