这个问题的灵感来自凯文·克鲁伊森的问题。

现在地毯已经铺好了，我们要卷起来。您的任务是编写一个程序，该程序接受一个字符串并返回由该字符串制成的螺旋线（代表从侧面看的卷起的地毯）。

滚动地毯的一个步骤如下。有一个例子可以说明我的意思。请注意，该示例以部分卷起的地毯开始，以更好地理解：

ac
rpet

• 将“头”与地毯的“尾巴”分开：头是到目前为止已经滚过的东西，尾巴是还有待滚过的东西。

Head: ac   Tail:
      rp          et

• 将头顺时针旋转90°。

Rotated head: ra   Tail (unchanged):
              pc                       et

• 如果新头的宽度（在此2）小于或等于尾巴的长度（在2）
  • 然后把它放在尾巴上
  • 否则，地毯（如该步骤开始时一样）被卷起

New carpet: ra
            pc
            et

根据需要重复该过程多次。

两个示例显示了地毯滚动的所有步骤：

carpet

 c
 arpet

  ac
  rpet

    ra
    pc
    et

0123456789

 0
 123456789

  10
  23456789

    21
    30
    456789

      432
      501
      6789

一些精度：

• 您不需要显示所有中间步骤，而仅显示卷起的地毯（例如，如果您找到一种非迭代的方法来计算结果，那是完美的）。另外，您不需要打印任何前导空格，在上面的示例中，我仅显示它们以对齐内容。
• 输入是一个字符串，一个字符列表/数组
• 输出被打印到标准输出或文件中。
• 输入是好的：长度至少为1个字符，并且最大为一个足够小的常量，这样它就不会引起问题，但是您不能在程序中使用该常量。字符串的内容只是漂亮的字符（[a-zA-Z0-9]），可根据您的喜好进行编码。
• 这是代码高尔夫球，因此最短答案以字节为单位。不要让代码高尔夫球语言阻止您使用非代码高尔夫球语言发布答案。尝试针对“任何”编程语言提出尽可能简短的答案。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接。
• 另外，如果您认为有必要，请为您的答案添加说明。

木炭，15字节

ＦＳ«Ｆ¬℅§ＫＶ⁰⟲⁶→Ｐι

在线尝试！链接是详细版本的代码。说明：

ＦＳ«

在地毯上循环。

Ｆ¬℅§ＫＶ⁰

检查光标上方是否有任何东西。

⟲⁶

如果没有，那就滚地毯。

→Ｐι

向右移动并输出当前字符。

示例：对于输入0123456789，将发生以下操作：

0

0 打印。

01

光标向右移动并被1打印。

0
1

由于上方没有任何内容1，因此画布已旋转。

0
12

光标向右移动并2打印。

10
2

由于上方没有任何内容2，因此画布已旋转。

10
23

光标向右移动并3打印。

10
234

光标向右移动并4打印。

21
30
4

由于上方没有任何内容4，因此画布已旋转。

21
30
45

光标向右移动并5打印。

21
30
456

光标向右移动并6打印。

432
501
6

由于上方没有任何内容6，因此画布已旋转。

432
501
67

光标向右移动并7打印。

432
501
678

光标向右移动并8打印。

432
501
6789

光标向右移动并9打印。

Pyth，37个字节

.U+j;bZ.WgleHJlhH,+_MChZ<eZJ>eZJ,]hQt

在此处在线尝试，或在此处一次验证所有测试用例。

.U+j;bZ.WgleHJlhH,+_MChZ<eZJ>eZJ,]hQtQ   Implicit: Q=eval(input())
                                         Trailing Q inferred
                                 ]hQ     First character of Q, wrapped in an array
                                    tQ   All but the first character of Q
                                ,        2-element array of the two previous results
                                           This yields array with rolled carpet (as array of strings) followed by the tail
       .W                                While condition function is truthy, execute inner function, with initial value of the above:
         gleHJlhH                          Condition function, input H
             JlhH                            Number of layers in the current rolled carpet, store in J
          leH                                Lenth of the tail
         g   J                               Is the above greater than or equal to J?
                 ,+_MChZ<eZJ>eZJ           Inner function, input Z
                   _MChZ                     Rotate the current rolled carpet (transpose, then reverse each row)
                  +     <eZJ                 Append the first J characters of the tail as a new row
                 ,                           Pair the above with...
                            >eZJ             ... all but the first J characters of the tail - this is the new tail
.U+j;bZ                                  Join the carpet roll on newlines and append the tail, implicit print

外壳，24字节

►S=ÖLmFȯ:T↔ø§z:oΘḣĠ+CṘ2N

在线尝试！

说明

Implicit input, say s="carpets"

CṘ2N  Break s into chunks:
   N   Natural numbers: [1,2,3,4,..
 Ṙ2    Repeat each twice: [1,1,2,2,3,3,4,4,..
C      Break s into chunks of these lengths: ["c","a","rp","et","s"]
       The last chunk is shorter if we run out of characters.

§z:oΘḣĠ+  Attempt to merge suffix of chunks:
      Ġ    Cumulative reduce chunk list from right
       +   by concatenation: ["carpets","arpets","rpets","ets","s"]
   oΘḣ     Prefixes of chunk list (empty and nonempty): [[],["c"],..,["c","a","rp","et","s"]]
§z         Zip these by
  :        appending: [["carpets"],["c","arpets"],..,["c","a","rp","et","s"]]
           These are all versions of the chunk list where some suffix has been merged.

mFȯ:T↔ø  Roll each list:
m         Map
 F        reduce from left
      ø   starting from empty character matrix
  ȯ:T↔    by this function:
    T↔     Reverse and transpose (rotating by 90 degrees)
  ȯ:       then append next chunk as new row.
         Result: [["carpets"],["c","arpets"],..,["epr","tca","s"]]

►S=ÖL  Select the matrix rolled by the correct amount:
►       Find element that maximizes
 S=     being equal to
   ÖL   sort by length.
        This selects a matrix whose rows have non-decreasing lengths.
        Ties are broken by choosing the rightmost one.
       Result: ["ra","pc","ets"]

Implicitly print each row separated by newlines.

J，69字节

-3字节归功于FrownyFrog

[:(}:@[,{:@[,])&>/[:((|:@|.@[,#@[$]);#@[}.])&>/^:(<:&#&>/)^:_,.@{.;}.

在线尝试！

说明

[: (}:@[ , {:@[ , ])&>/ [: ((|:@|.@[ , #@[ {. ]) ; #@[ }. ])&>/^:(<:&#&>/)^:_ }. ;~ 1 1 $ {.

尽管对于J有点冗长，但该算法非常简单。

总体策略：减少对方桌的投入，剩下的一块（可能是空的）。

随着我们的减少，我们将使用2个元素的盒子列表。我们的“到目前为止的结果”将是第一个方框，“剩余的待处理项目”将是第二个方框。第一个框将初始化为输入的开头（但将转换为表格）：

1 1 $ {.

和“待处理的剩余项目”将是输入的尾部：

}. ;~

现在我们有：

┌─┬─────┐
│c│arpet│
└─┴─────┘

其中“ c”实际上是1x1表格。

我们使用J Do ... While循环将其减少：

^:(...)^:_

括号中的部分是“继续前进”条件：

<:&#&>/

表示“继续前进，而右侧框的长度大于或等于左侧框的长度（即方矩阵的边长）

“继续前进”是什么意思？这是在first左边的动词中定义的^:，它告诉我们如何获取当前结果并产生下一个迭代。该动词是：

((|:@|.@[ , #@[ {. ]) ; #@[ }. ])&>/

让我们分解一下：

((|:@|.@[ , #@[ {. ]) ; #@[ }. ])&>/
(  verb in parens               )&>/ NB. put the verb in parens
                                     NB. between the two items
                                     NB. of our list, and unbox
                                     NB. them into left / right
                                     NB. args ([ / ]) for the verb
 (|:@|.@[ , #@[ {. ]) ; #@[ }. ]     NB. breaking down verb in 
                                     NB. parens...
                      ; ....         NB. new "remaining items":
                            }. ]     NB. remove from remaining
                        #@[          NB. the size of a side of
                                     NB. the result matrix
                ....  ;              NB. new "result":
  |:@|.@[                            NB. rotate existing result
          ,                          NB. and put it on top of
            #@[ {. ]                 NB. the items we removed
                                     NB. from remaining items

也就是说，这只是OP中描述的算法，字面上将其翻译为J。

最后，我们处理（可能为0）剩余的物品，即地毯卷的尾部：

(}:@[ , {:@[ , ])&>/

这表示“除结果的最后一个榆树以外的所有东西”：

}:@[ 

并将其追加到,结果的最后一个项目{:@[与追加到最后一个项目，其余项目, ]

R，146132字节

function(s){m=F[F]
while({m=rbind(t(m)[,F:0],s[1:F])
s=s[-1:-F]
length(s)>sum(F<-dim(m))})0
write(m[F:1,],1,F[1],,"")
cat(s,sep="")}

在线尝试！

实施地毯卷制程序。将输入作为字符列表并打印到stdout。

通过找到使用do-while循环并使用初始化的方式节省了14个字节F。

function(s){
m=F[F]					# logical(0); create an empty array (this gets automatically promoted to character(0) later
while(					# do-while loop
      {m=rbind(t(m)[,F:0],s[1:F])	# rotate m counterclockwise and add the first F characters of s to the bottom
       s=s[-1:-F]			# remove those characters
       length(s)>sum(F<-dim(m))})0	# while the number of characters remaining is greater than the sum of m's dimensions
write(m[F:1,],1,F[1],,"")		# write the rolled portion write writes down the columns, we reverse each column
cat(s,sep="")				# and write the remaining characters
}

果冻，30 个字节

_{似乎太长了...}

ḢW,ðZU;Ls@¥©ḢWɗ,®Ẏ¤ð/ẈṢƑ$¿ḢY;Ɗ

在线尝试！

怎么样？

ḢW,ðZU;Ls@¥©ḢWɗ,®Ẏ¤ð/ẈṢƑ$¿ḢY;Ɗ - Main Link: list of characters
Ḣ                              - pop and yield head
 W                             - wrap in a list
  ,                            - pair with (the remaining list after Ḣ)
                         ¿     - while...
                        $      - ...condition: last two links as a monad:
                     Ẉ         -   length of each
                       Ƒ       -   is invariant under:
                      Ṣ        -     sort
                    /          - ...do: reduce by:
   ð               ð           -   the enclosed dyadic chain -- i.e. f(head, tail):
    Z                          -     transpose
     U                         -     reverse each (giving a rotated head)
              ɗ                -     last three links as a dyad:
          ¥                    -       last two links as a dyad:
       L                       -         length (i.e. number of rows in current roll)
         @                     -         with swapped arguments:
        s                      -           split (the tail) into chunks of that length
           ©                   -       (copy to register for later)
            Ḣ                  -       pop and yield head (Note register "copy" is altered too)
             W                 -       wrap in a list
      ;                        -     concatenate (the rotated head with the first chunk of the tail)
                  ¤            -     nilad followed by link(s) as a nilad:
                ®              -       recall from register (other chunks of tail, or an empty list)
                 Ẏ             -       tighten (the chunks to a flat list)
               ,               -     pair (the concatenate result with the tightened chunks)
                             Ɗ - last three links as a monad:
                          Ḣ    -   pop and yield head
                           Y   -   join with newline characters
                            ;  -   concatenate (the remaining tail)
                               - when running as a full program implicitly prints

05AB1E，41 个字节

g©L¦€DD2šηO®>‹Ï©IŽ8OS®g4α._.ΛðÜI®O®g->.$«

太长了，但是我想使用Canvas。。由于我完成了它，结果发现它太长了，这可能是一个不好的选择。

在线尝试。（没有测试套件，因为似乎是一个奇怪的问题与.Λ内置..）

说明：

首先，我对Canvas以及我希望代码完成的工作进行一般性说明。在此相关的05AB1E技巧中可以找到更多详细信息，但是对于这一挑战，我希望执行以下操作：

Canvas内置变量具有三个参数：

• $a$[2,2,3,3,4,4,5,5,...]
• $b$
• $c$$[2,0,6,4]$$[→,↑,←,↓]$$n$carpet$[0,6,4,2]$0123456789ABCDEFGHI$[6,4,2,0]$ 代替）。

至于代码：

g                # Get the length of the (implicit) input-string
 ©               # Store it in the register (without popping)
  L              # Create a list in the range [1,length]
   ¦             # Remove the first item to make the range [2,length]
    €D           # Duplicate each to get the list [2,2,3,3,4,4,5,5,...]
      D2š        # Create a copy and prepend a 2: [2,2,2,3,3,4,4,5,5,...]
         η       # Get the prefixes: [[2],[2,2],[2,2,2],[2,2,2,3],...]
          O      # Sum each prefix: [2,4,6,9,12,16,20,...]
           ®     # Push the length from the register again
            >‹   # Check for each summed prefix if it's <= length
              Ï  # And only leave the truthy values
               © # And store this in the register (without popping)
                 # (This is our `a` for the Canvas builtin)
I                # Push the input-string
                 # (This is our `b` for the Canvas builtin)
Ž8O              # Push compressed integer 2064
   S             # Converted to a list of digits: [2,0,6,4]
    ®g           # Push the list from the register, and get its length
      4α         # Get the absolute difference with 4
        ._       # And rotate the [2,0,6,4] that many times towards the left
                 # (This is our `c` for the Canvas builtin)
.Λ               # Now use the Canvas builtin, without printing it yet
  ðÜ             # Remove any trailing spaces (since the Canvas implicitly makes a rectangle)
     ®O          # Push the sum of the list from the register
       ®g-       # Subtract the length of the list from the register
          >      # And add 1
    I      .$    # Remove that many leading characters from the input-string
             «   # And append it at the end of the roll created by the Canvas
                 # (after which the result is output implicitly)

看到这个05AB1E尖矿（部分如何压缩大整数？）理解为什么Ž8O是2064。

Python 3，112字节

r=lambda t,h=[[]]:len(h)>len(t)and h[:-1]+[h[-1]+list(t)]or r(t[len(h):],list(zip(*h[::-1]))+[list(t)[:len(h)]])

在这种情况下，输出是函数的值。

在线尝试！

如果您愿意，可以使用以下另一种（更长的129 bytes）解决方案直接打印滚动输入：

r=lambda t,h=['']:len(h)>len(t)and set(map(print,h[:-1]+[h[-1]+t]))or r(t[len(h):],list(map(''.join,zip(*h[::-1])))+[t[:len(h)]])

在线尝试！

的MATLAB / 八度，154字节

不是最短的一种，但是在MATLAB / Octave中打高尔夫球总是很有趣的:)

function h=r(t,h);n=fliplr(h');s=size(n,2);q=numel(t);if s<=q h=r(t(max(s,1)+1:end),[n; t(1:max(s,1))]);elseif q>0 h(:,end+q)=' ';h(end,end-q+1:end)=t;end

在线尝试！