Question

I had recently participated in coding competion sponsored by an company and there was this one question which I did not understood, as to what was it asking.

Here is the question:

The string “paypal is the faster, safer way to send money” is written in a
clockwise spiral pattern inside a square starting from the upper left corner:
(you may want to display this pattern in a fixed font for better legibility).

   P A Y P A L
   F E R W A I
   A M O N Y S
   S D Y E T T
   R N E S O H
   E T S A F E

Then read line after line:
PAYPALFERWAIAMONYSSDYETTRNESOHETSAFE

Write the code that will take a string, calculate the minimum square that will
contain it and return the converted string:

String convert(String text);

example:

    convert("paypalisthefastersaferwaytosendmoney") 
should return "paypalferwaiamonyssdyettrnesohetsafe"

Do you understand as to how we can approach this problem?

Answer 1

I believe that the question, as written, is meant to be interpreted as follows:

You are given a string and want to write that string as a spiral into a square grid. Write a function that finds the smallest square that can hold the string, writes the string into the grid by spiraling its characters around the grid clockwise, and finally concatenates the rows together.

As an example, the string “In a spiral” would look like this:

                I N A
In a spiral ->  A L S -> INAALSRIP
                R I P

To see where the grid comes from, note that if you read it like this:

     I -> N -> A

               |
               v

     A -> L    S

     ^         |
     |         v

     R <- I <- P

You get back the initial text, and if you glue the rows “INA”, “ALS,” and “RIP” into a single string you get back “INAALSRIP.”

Let’s consider each problem separately. First, to see the smallest size of a rectangle that can hold the text, you’re essentially looking for the smallest perfect square at least as large as the length of your text. To find this, you could take the square root of the length of your string and round it up to the nearest integer. That gives you the dimension you’d like. However, before you can do that, you need to strip out all of the punctuation and space characters from the string (and perhaps the numbers as well, depending on the application). You could do this by walking across the string and copying over the characters that are indeed alphabetic into a new buffer. In what follows, I’ll assume that you’ve done this.

As for how to actually fill in the grid, there’s a really great way to do this. The intuition is as follows. When you start off in an n x n grid, your only boundaries are the walls of the grid. Every time you march across the grid dropping letters and hit a wall, you’ve just shaved off a row or a column from the matrix. Consequently, your algorithm could work by keeping track of the first and last legal column and the first and last legal row. You then walk across the top row from left to right writing characters. When you’re done, you then increment the first legal row, since you can’t put anything there any more. Then, walk down the right side until you hit the bottom. Once you’re done, you would then block off the last column from consideration as well. For example, to look back at our “In a spiral” example, we start off with an empty 3×3 grid:

. . .
. . .
. . .

After we write the first three characters across the top, we’re left with this:

I N A
. . .
. . .

Now, we need to write the rest of the string into the blank space, starting from the upper-right square and moving down. Because we can’t ever write back into the top row, one way of thinking about this is to think about solving the problem of writing the rest of the characters in a spiral in the smaller space

. . .
. . .

Starting from the upper-left corner and moving downward.

To actually realize this as an algorithm, we need to keep track of a few things at each point. First, we need to store the bounds of the world as we’re updating them. We also need to store our current write location, along with what direction we’re facing. In pseudocode, this is represented as follows:

firstRow = 0, lastRow = N - 1 // Bounds of the grid
firstCol = 0, lastCol = N - 1

dRow = 0  // Amount to move in the Y direction
dCol = 1  // Amount to move in the X direction

row = 0   // Current position
col = 0

for each character ch in the string:
    Write character ch to position (row, col).

    // See if we're blocked and need to turn.
    If (row + dRow, col + dCol) is not contained in the rectangle [firstRow, lastRow] x [firstCol, lastCol]:
        // Based on which way we are currently facing, adjust the bounds of the world.
        If moving left,  increment firstRow
        If moving down,  decrement lastCol
        If moving right, decrement lastRow
        If moving up,    increment firstCol

        Rotate 90 degrees

    // Finally, move forward a step.
    row += dRow
    col += dCol

You can implement the ninety-degree turn using a trick from linear algebra: to rotate a vector 90 degrees to the left, you multiply it by the rotation matrix

|  0   1 |
| -1   0 |

So your new dy and dx are given by

|dCol'| = |  0   1 | dCol = |-dRow|
|dRow'|   | -1   0 | dRow   | dCol|

So you can turn left by computing

temp = dCol;
dCol = -dRow;
dRow = temp;

Alternatively, if you know for a fact that the character with numeric value zero never appears in the string, you can use the fact that Java initializes all arrays to hold zeros everywhere. You can then treat 0 as a sentinel meaning “it’s safe to keep moving forward.” That version of the (pseudo)code would look like this:

dRow = 0  // Amount to move in the X direction
dCol = 1  // Amount to move in the Y direction

row = 0   // Current position
col = 0

for each character ch in the string:
    Write character ch to position (row, col).
    If (row + dRow, col + dCol) is not contained in the rectangle [0, 0] x [n-1, n-1]
             -or-
       The character at [row + dRow, col + dCol] is not zero:
        Rotate 90 degrees

   // Move forward a step
   row += dRow
   col += dCol

Finally, once you’ve written the string into the spiral, you can convert that spiraled text back into a string by walking across the rows one at a time and concatenating together all of the characters that you find.

EDIT: As @Voo points out, you can simplify the last step of this algorithm by not actually creating a multidimensional array at all and instead encoding the multidimensional array as a single-dimensional array. This is a common (and clever!) trick. Suppose, for example, that we have a grid like this:

 0  1  2
 3  4  5
 6  7  8

Then we can represent this using a one-dimensional array as

 0  1  2  3  4  5  6  7  8

The idea is that given an (row, col) pair in an N x N grid, we can convert that coordinate to a corresponding location in the linearized array by looking at position row * N + col. Intuitively, this says that every step in the y direction that you take is equivalent to skipping all N elements of one row, and each horizontal step just moves one step horizontally in the linearized representation.

Hope this helps!