この質問はKevin Cruijssenの質問に触発されました。

カーペットがレイアウトされたので、私たちはそれを転がしたいと思います。あなたの仕事は、文字列を受け取り、この文字列から作られたらせんを返すプログラムを書くことです（横から見たロールされたカーペットを表します）。

カーペットを丸める1ステップの手順は次のとおりです。私の言いたいことを説明する例があります。理解を深めるために、例は部分的に丸められたカーペットで始まっていることに注意してください。

ac
rpet

• カーペットの「頭」と「尾」を分離します。頭はこれまでに巻かれたものであり、尾は巻かれたままのものです。

Head: ac   Tail:
      rp          et

• ヘッドを時計回りに90°回転させます。

Rotated head: ra   Tail (unchanged):
              pc                       et

• 新しいヘッド（ここでの幅があれば2）（ここでは以下の尾の長さよりも2）
  • 次に、尾の上に置きます
  • それ以外の場合、カーペットは（ステップの開始時と同じように）ロールされました

New carpet: ra
            pc
            et

必要な回数だけ手順を繰り返します。

カーペットのローリングのすべてのステップを示す2つの例：

carpet

 c
 arpet

  ac
  rpet

    ra
    pc
    et

0123456789

 0
 123456789

  10
  23456789

    21
    30
    456789

      432
      501
      6789

いくつかの精度：

• すべての中間ステップを表示する必要はなく、ロールされたカーペットのみを表示する必要があります（たとえば、結果を計算する非反復的な方法を見つけた場合、それは完璧です）。また、先頭の空白を印刷する必要はありません。上記の例では、それらを整列するためだけに示しています。
• 入力は文字列、charのリスト/配列です
• 出力は標準出力またはファイルに出力されます。
• 入力は便利です。長さは少なくとも1文字であり、問​​題を引き起こさないように最大でも十分に小さい定数ですが、プログラムでその定数を使用することはできません。文字列の内容はナイスキャラクタ（[a-zA-Z0-9]）のみで、好みに応じてエンコードされます。
• これはcode-golfであるため、バイト単位の最短回答が優先されます。コードゴルフ言語では、非コードゴルフ言語で回答を投稿しないようにしてください。「任意の」プログラミング言語の可能な限り短い答えを考えてみてください。
• デフォルトの抜け穴は禁止されています。
• 可能であれば、コードのテストへのリンクを追加してください。
• また、必要と思われる場合は、回答の説明を追加してください。

炭、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バイト

FrownyFrogのおかげで-3バイト

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

オンラインでお試しください！

説明

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

このアルゴリズムは、Jにとって少し冗長であるにもかかわらず簡単です。

全体的な戦略：（おそらく空の）残りのピースを使用して、入力を正方形のテーブルに減らします。

削減するにつれて、ボックスの2要素リストを使用します。「これまでの結果」が最初のボックスになり、「処理される残りのアイテム」が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

つまり、これは文字どおりJに変換されたOPに記述されたアルゴリズムにすぎません。

最後に、残りのアイテム（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="")}

オンラインでお試しください！

カーペットローリング手順を実装します。入力を文字のリストとして受け取り、標準出力に出力します。

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ビルトインは3つのパラメーターを取ります。

• $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バイトの）ソリューションがあります。

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 / Octave、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

オンラインでお試しください！