给定一个整数k和一个文本块，或者一个内部数组可能具有不等长的2d数组（类似于一个文本块），则将第k列中的每个字符或元素向上或向下旋转到下一个位置存在。

例

旋转以下文本的第20列（从1开始）：

A line with more than k characters.
A longer line with more than k character.
A short line.
Rotate here: ------v--
This is long enough.

This is not enough.
Wrapping around to the first line.

输出：

A line with more thtn k characters.
A longer line with aore than k character.
A short line.
Rotate here: ------m--
This is long enoughv

This is not enough.
Wrapping around to .he first line.

在35 < k <42的情况下旋转同一输入的第k列将使输入文本保持不变。

规则

• 您可以使用原始文本，行数组，二维字符数组或任何合理的格式来表示数据。您也可以使用字符以外的数据类型。
• 如果代码长度取决于元素，则元素的数据类型的可能值的数量必须至少为20，否则至少为2。这可能是字符或本机类型支持的其他值的子集。
• 如果在输入中允许空格和任何类型的null值，它们只是普通值。您也可以将它们简单地排除在元素类型之外。
• 规则更改：如果您希望使用长度相等的数组来存储数据，则可以使用通用默认值（例如空格）填充较短的数组。
• k可以基于0或基于1。保证它在输入中的最长行内（这意味着输入至少有一条非空行）。
• 您可以选择向上或向下旋转。
• 只需旋转一个位置，或旋转n个位置（其中n是输入中给定的正整数）即可。
• 最短的代码胜出。

APL（Dyalog扩展），9 字节^SBCS

完整程序。提示输入2D文本块的stdin，然后是k（基于APL的当前设置，从0开始或从1开始），然后是n。正n向上旋转，负n向下旋转。

该域包含以下任一内容：

1. 除空格以外的所有Unicode字符，保留1114111允许的值，该值大于要求的20。

2. 除0以外的所有数字，剩下大约2 ^129个允许的值，大于所需的20个值。

由于APL要求2D块为矩形，因此必须用空格/零填充输入。通过输入↑字符串/数字列表的左侧，可以自动完成此操作。

⎕⌽@≠@⎕⍢⍉⎕

在线尝试！（表观空间实际上是不间断空间）

⎕ 提示文本块

⍢⍉ 转置时：

 @⎕ 在输入的第th行上应用以下内容：

  @≠ 与原型不同的元素（字符为空格，数字为零）：

   ⎕⌽ 向左旋转“输入”步骤

APL（Dyalog Unicode），22 个以上字节的^SBCS

此版本通过使用零作为可识别的填充元素来允许完整字符集。

0~¨⍨↓⍉⎕⌽@(0≠⊢)@⎕⍉↑0,¨⎕

在线尝试！

当然，这意味着数字参数中不允许使用零。所有数字的对应程序将0用替换三下' '，因此将空格用作填充：

' '~¨⍨↓⍉⎕⌽@(' '≠⊢)@⎕⍉↑' ',¨⎕

如果我们确实想要字符和数字的全部范围（甚至是它们的混合），则可以使用null作为填充：

n~¨⍨↓⍉⎕⌽@(n≠⊢)@⎕⍉↑⎕,¨⍨n←⎕NULL

最后，如果我们想在输入域中包含null和对象，则可以定义一个fill类并将其实例用作fill：

~∘I¨⍨↓⍉⎕⌽@(~⊢∊I←⎕INSTANCES⊢∘C)@⎕⍉↑⎕,¨⍨⎕NEW⎕FIX':Class C' ':EndClass'

Python 2和111 110 109 99 98个 96个 94字节

lambda a,n:[l[:n]+(l[n:]and[L[n]for L in a[i:]+a if L[n:]][1]+l[n+1:])for i,l in enumerate(a)]

在线尝试！

将输入作为行列表和0-index列，并返回字符串列表。

色谱柱向上旋转1。

_{-11个字节，感谢Jo King}

Java 8，107 106 135 107字节

k->m->{int s=m.length,i=-1;for(char p=0,t;i<s;t=m[i%s][k],m[i%s][k]=p<1?t:p,p=t)for(;m[++i%s].length<=k;);}

+29个字节用于错误修复。

0索引；像示例一样向下旋转。
输入为字符矩阵；修改char-matrix而不是返回一个新的以节省字节。

在线尝试。

说明：

k->m->{                 // Method with integer and char-matrix parameters and no return-type
  int s=m.length,       //  Amount of lines in the matrix `s`
      i=-1;             //  Index-integer `i`, starting at -1
  for(char p=0,         //  Previous-character, starting at 0
           t;           //  Temp-char, uninitialized
      i<s               //  Loop as long as `i` is smaller than `s`:
      ;                 //    After every iteration:
       t=m[i%s][k],     //     Set the temp to the `k`th character of the `i`'th line
       m[i%s][k]=       //     Replace the `k`'th character of the `i`'th line with:
         p<1?           //      If `p` is still 0:
          t             //       Set it to the temp we just set
         :              //      Else:
          p,            //       Set it to the previous-character instead
       p=t)             //     And then replace `p` with the temp for the next iteration
    for(;m[++i          //   Increase `i` by 1 before every iteration with `++i`,
             %s].length //   And continue this loop until the length of the `i`'th line
           <=k;);}      //   is smaller than or equal to the input `k`

Zsh，94 87 78 74 69字节

转换为算术三元组时为-7个字节，更改字符就地（TIL）时为-9个字节，通过在stdin和字符串上输入索引作为参数将其作为-4字节，通过使用字符串而不是数组来使-5字节存储旋转字符。

read i
for s;c+=$s[i]
c=$c[-1]$c
for s;s[i]=$c[$[$#s<i?0:++j]]&&<<<$s

旧 旧 旧 旧 在线试用！

以下是使此答案有效的关键：

• $array[0] 要么 $string[0]始终为空
• $array[n] 要么 $string[n]为空，如果n大于数组/字符串的长度
• array[i]=c或string[i]=c将替换元素/字符。
• 在$[$#s<i?0:++j]，j是不是增加，如果$#s<i。

在最初的94字节答案中，我遇到了一个有趣的问题，涉及使用<<<打印。我不得不使用echo它来解决它：

for s;echo $s[0,i-1]$c[$[$#s<i?0:++j]]${s:$i}

可以在这里看到其原因：

echo $ZSH_SUBSHELL   # prints 0
<<< $ZSH_SUBSHELL    # prints 1

此处的字符串在子shell中运行，因为它们以stdin的形式提供给另一个程序。如果未提供任何程序，则将其隐式提供给cat。您可以通过看到此内容<<< $_。 <<< $ZSH_SUBSHELL与相似echo $ZSH_SUBSHELL | cat。由于我们需要增加j，所以不能放在子shell中。

R，62个字节

function(L,n){L[A,n]<-rep(L[A<-L[,n]!=' ',n],2)[1+1:sum(A)];L}

在线尝试！

将输入作为空格填充的字符矩阵。向上旋转。感谢Kirill L.！

R，74字节

function(L,n){substr(L[A],n,n)=rep(substr(L[A<-nchar(L)>=n],n,n),2)[-1]
L}

在线尝试！

此提交在填充线的允许之前。

混叠substr在这里是行不通的，因为我们调用substr和substr<-在第一线。

I / O作为非填充行的列表；向上旋转。

C＃（Visual C＃交互式编译器），82字节

k=>a=>{var c='0';a.Where(b=>b.Count>k&&((b[k],c)=(c,b[k])).c>0).ToList()[0][k]=c;}

在线尝试！

感谢@ASCIIOnly的建议foreach，它节省了12个字节！

-8个字节感谢@someone！
-1个字节感谢@EmbodimentofIgnorance！

红宝石，57个字节

->a,k{b=a.map{|i|i[k]}-[p];c=-2;a.map{|i|i[k]&&=b[c+=1]}}

在线尝试！

将输入作为行数组a。在从0开始的位置处向下旋转文本k。通过修改输入返回a。

05AB1E，21字节

ʒg‹}U¹εXyk©diX®<èIèIǝ

绝对可以打更多的球..

0索引；输入和输出都作为字符串列表。
它像示例一样向下旋转，但是<可以替换>为向上旋转。

在线尝试（页脚通过换行符加入列表，将其删除以查看实际的列表输出）。

说明：

ʒ  }             # Filter the (implicit) input-list by:
 g               #  Where length of the current string
  ‹              #  is larger than the (implicit) input-integer
    U            # Pop and store this filtered list in variable `X`
¹ε               # Map over the first input-list again:
  Xyk            #  Get the index of the current string in variable `X`
     ©           #  Store it in the register (without popping)
      di         #  If the index is not -1, so the current string is present in variable `X`
        X®<è     #   Get the (index-1)'th string in variable `X`
            Iè   #   Get the character at the index of the input-integer
              Iǝ #   And insert it at the index of the input-integer in the current string

K4个字节

解：

{.[x;i;:;.q.rotate[1;x . i:(&y<#:'x;y)]]}

说明：

不知道我是否缺少某些内容... 0索引，向上旋转（将更1改为-1向下旋转）

{.[x;i;:;.q.rotate[1;x . i:(&y<#:'x;y)]]} / the solution
{                                       } / lambda taking implicit x and y
 .[x; ;:;                              ]  / index apply assignment back into x
         .q.rotate[1;                 ]   / left rotate 1 character
                           (       ; )    / two item list
                                    y     / index to rotate
                               #:'x       / count (#:) each (') input
                             y<           / index less than ?
                            &             / indexes where true
                         i:               / assign to variable w
                     x .                  / index into x
     i                                    / indexes we saved as i earlier

杰普特 v2.0a0，18个字节

基于0的输入和输出为多行字符串。向上旋转1。

必须有一个更短的方法！

yÈr\S_Y¦V?Z:°TgXrS

试试吧

yÈr\S_Y¦V?Z:°TgXrS     :Implicit input of string U & integer V
y                      :Transpose
 È                     :Pass each line X at 0-based index Y through the following function & transpose back
  r                    :  Replace
   \S                  :  RegEx /\S/g
     _                 :  Pass each match Z through the following function
      Y¦V              :    Test Y for inequality with V
         ?Z:           :    If true, return Z, else
            °T         :    Increment T (initially 0)
              g        :    Index into
               XrS     :    X with spaces removed

果冻，16字节

z⁷⁹ịỴFṙ-ṁƲY⁸ṛ⁹¦"

双向链接在左边接受行列表（不包含换行符的字符列表），在右边接受整数，以返回行列表。

在线尝试！（页脚在换行符处分割，调用链接，然后通过换行符再次加入）

怎么样？

z⁷⁹ịỴFṙ-ṁƲY⁸ṛ⁹¦" - Link: lines L; index I        e.g. example in question; 20
z⁷               - transpose L with filler '\n'       ['AAART\nTW', '   oh\nhr', ...]
  ⁹ị             - Ith item                           'am\nv.\n\nt'
    Ỵ            - split at newlines                  ['am', 'v.', '', 't']
         Ʋ       - last four links as a monad - i.e. f(X):
     F           -   flatten                          'amv.t'
       -         -   -1
      ṙ          -   rotate left by                   'tamv.'
        ṁ        -   mould like X                     ['ta', 'mv', '', '.']
          Y      - join with newlines                 'ta\nmv\n\n.'
                 -   -- call this C
           ⁸     - chain's left argument, L
               " - zip with - i.e. [f(L1,C1), f(L2,C2), ...]:
              ¦  -   sparse application...
             ⁹   -   ...to indices: chain's right argument, I
            ṛ    -   ...of: right argument, Cn

perl 5（-p），75个字节

k为0索引，向下旋转

s/.*//;$r="^.{$&}";s/
//;/$r(.)/;$c=$1;s/$r\K.(?=(?s:.)*?$r(.)|)/$1||$c/gme

蒂奥

Perl 6的，38 33字节

修改数组到位（规则不允许）

{@^a.grep(*>$^b+1)[*;$b].=rotate}

在线尝试！

JavaScript（Node.js），52字节

k=>a=>a.filter(b=>b[k]&&([b[k],a]=[a,b[k]]))[0][k]=a

在线尝试！

-7个字节，感谢Shaggy！

尚未看到JavaScript答案！我的C＃答案的端口。

木炭，34 28 21字节

θＪη⁰≔ΦＫＤＬθ↓℅ιζＵＭζ§ζ⊖κ

在线尝试！链接是详细版本的代码。将字符串数组作为输入。0索引。编辑：现在PeekDirection已修复，我可以直接对其进行操作。说明：

θ

打印输入字符串。

Ｊη⁰

跳到要旋转的列的顶部。

≔ΦＫＤＬθ↓℅ιζ

提取已打印的单元格。

ＵＭζ§ζ⊖κ

将每个打印的单元格替换为上一个单元格的值（循环）。方便的是，在PeekDirection调用，因此MapCommand调用将新值写入单元格这一事实无关紧要。

点子 -rn，32字节

POgY#(g@_)>aFI,#gFiyAE@ySsg@i@ag

0索引，向下旋转。 在线尝试！

进行过滤以查找足够长以参与轮换的所有行的索引。然后循环遍历这些行，将每行上的适当字符与temp变量交换s。最后再次访问第一行将再次交换虚拟值。

果冻，19字节

ZnÄ×$ịḟ¹ṙ-;ɗɗʋ€⁹¦⁶Z

在线尝试！

1个索引。向下旋转。单调链接，将果冻字符串的右填充列表（字符列表）作为第一个参数，将k用作第二个参数。输入中禁止使用空格（右填充除外），但允许所有其他字符。

正如在TIO上实现的那样，页脚将单个字符串输入拆分为字符串列表，并在其中右击，但这是为了方便起见。据我了解，该步骤的结果是根据规则允许输入主链接的。

GFortran，199字节

_{通过从标准输入而不是文件
-14读取-20左右，方法是使用i, k, n
-4的隐式整数，通过删除空格和::}

要求用户输入k和n在第一行，k旋转的列在哪里n，文本的行数在哪里。后续输入是要旋转的文本行。这太痛苦了！Fortran太学究了！

character(99),allocatable::A(:);character(1)r,s
read(*,*)k,n;allocate(A(n))
do i=1,n;read(*,'(A)')A(i);r=A(i)(k:k)
if(r.ne.''.or.r.ne.' ')then;A(i)(k:k)=s;s=r;endif;enddo
A(1)(k:k)=s;print'(A)',A;end

• 此处是原始的非高尔夫程序，带有注释和编译注释：rotcol.f
• 203字节版本：rextester.com
• 199字节版本（新）：在线试用！

T-SQL，195个字节

WITH C as(SELECT rank()over(order by i)r,sum(1)over()c,*FROM @t
WHERE len(x)>=@)SELECT
isnull(stuff(c.x,@,1,substring(e.x,@,1)),t.x)FROM @t t
LEFT JOIN c ON t.i=c.i
LEFT JOIN c e ON e.r%c.c+1=c.r

在线试用非高尔夫版本