Roll cakes are delicious sweets made with a layer of sponge cake, a layer of cream (or icecream), rolled as a spiral, see Wikipedia.

Your task is to get a non-empty phrase string from standard input, strip the spaces out, and roll it as a roll cake starting from the center in right to left in a counterclockwise direction, while the spaces starts at the bottom of the first phrase character, from the center left to right, as in the following example.

Please note that the phrase will be the layer of sponge cake and the cream layer will be represented as empty spaces.

Input: Lorem ipsum dolor sit amet, consectetu adipiscing elit, sed do eiusmod

Output with spaces ' ' represented as _


Test cases

Input: Lorem ipsum dolor sit amet, consectetu adipiscing elit, sed do eiusmod


t        i
, srolod d
s i    m a
e t oL u u
d a r  s t
d m emip e
o e      t
e t,consec

Input: Sandbox for Proposed Challenges


e    r
d aS o
c n  f
h dbox

Input: Cake



Input: it





2 Answers 2


Python 2, 202 200 bytes

-2 bytes thanks to LevitatingLion

a=input().replace(' ','')
#Calculate the ammount of rotations
while s<l:s=n*(1+n)/2;n+=1
#Add trailing spaces to not break the rolling
a+=' '*(s-l)
#Add a cream layer on top and a cake layer on bottom of the cake and roll 90 degrees
for i in range(1,n):c=[' '*i]+zip(*c[::-1])+[a[:i]];a=a[i:]
#Finish the rolling to match the pattern
#Serve the cake
for i in c:print''.join(i)
  • \$\begingroup\$ You can drop the parentheses around exec: exec~i%4*'c=zip(*c[::-1]);'. This saves two bytes \$\endgroup\$ Dec 13, 2016 at 18:37

Befunge, 260 250 bytes

>00g:: :09g\`8+0\p::19g`8+1\p20g1-2%+00p10g:::29g\`8+2\p::39g`8^

Try it online!

The basic idea is that we build up the spiral in the lower half of the playfield, keeping tracking of the min and max coordinates as we go along. Once all the input has been processed, we iterate over the range of coordinates and write out the content that was saved.

Detailed Explanation

Note that the dx and dy values are in the range 0 to 3, corresponding to the relative offsets -1, 0, 1, 0. Updating the direction is thus done by adding 1, modulo 4. Converting to a relative offset is done by subtracting 1, modulo 2.

"'"::00p09p19p      Set x, minx, and maxx to 39.
35*::10p29p39p      Set y, miny, and maxy to 15.
020p130p            Set dx to 0 (relative offset -1) and dy to 1 (relative offset 0).
140p                Set the segment length to 1.
0                   Set the index to 0 (on the stack).

                    -- The main input loop start here --
~                   Read a character from stdin.
:48*`_              If it's greater than 32 (i.e. not whitespace or EOL)...
  00g:              Get the current value of x and make a duplicate.
  ::09g\`8+0\p      If it's less than minx, update minx.
  ::19g`8+1\p       If it's greater than maxx, update maxx.
  20g1-2%           Calculate (dx-1)%2, which converts dx into the range -1 to 1.
  +00p              Add that to x and save (leaving the original x on the stack).
  10g:              Get the currrent value of y and make a duplicate.  
  ::29g\`8+2\p      If it's less than miny, update miny.
  ::39g`8+3\p       If it's greater than maxy, update maxy.
  30g1-2%           Calculate (dy-1)%2, which converts dy into the range -1 to 1.
  +10p              Add that to y and save (leaving the original y on the stack).
  p                 Store the character we read at the original x,y coordinates.
  1+                Increment the index by 1.
  :40g%!            Mod that with the current segment len; if zero it's time to turn.
  :20g+4%20p        Add the turn condition to the dx value, thus turning if needed.
  :30g+4%30p        Similarly add the turn condition to the dy value.
  :40g+40p          Also add it to the segment length, so it gets longer every turn.
  !*                Multiply the index by !turn, so it's reset to zero on every turn.
  ^                 Repeat the loop, reading another character.
0`!#v_^             If the char <= 32, we test for EOF and repeat the loop if not.

>                   If it is EOF, we start the output routine.
29g                 Initialise the y coordinate with miny.
:39g\-              Calculate maxy - miny to use as the height countdown.

                    -- The outer output loop starts here --
\:50p               Swap y to the top and save in a temporary variable.
09g                 Initialise the x coordinate with minx.
:19g\-              Calculate maxx - miny to use as our width countdown.
\                   Swap x to the top of the stack.

                    -- The inner output loop starts here --
  :50g              Take a copy of x and the y save in the temporary variable.
  g,                Read the character at those coordinate and write to stdout.
  \:_               Swap the width countdown to the top of the stack and break if zero.
  1-                Otherwise decrement the width countdown.
  \1+               Swap the x value back to the top and increment it.
  <                 Repeat the inner loop.

$$                  Clear the width countdown and x value from the stack.
1+                  Increment the y value.
\                   Swap the height countdown to the top of the stack.
:¬#@_               If it's zero, exit.
1-                  Otherwise decrement it.
55+,                Output a line break.
^                   Repeat the outer loop.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.