กำหนดจำนวนเต็มkและบล็อกข้อความหรืออาร์เรย์ 2d ที่อาร์เรย์ภายในอาจมีความยาวไม่เท่ากัน (ซึ่งคล้ายกับบล็อกข้อความ) หมุนทุกตัวอักขระหรือองค์ประกอบในคอลัมน์k -th ขึ้นหรือลงไปยังตำแหน่งถัดไป ที่มีอยู่

ตัวอย่าง

หมุนคอลัมน์ที่ 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.

การหมุนคอลัมน์k -th ของอินพุตเดียวกันโดยที่ 35 < k <42 จะทำให้ข้อความอินพุตไม่เปลี่ยนแปลง

กฎระเบียบ

• คุณสามารถใช้ข้อความดิบอาเรย์ของเส้นอาเรย์ 2d ของอักขระหรือรูปแบบที่เหมาะสมเพื่อแสดงข้อมูล นอกจากนี้คุณยังสามารถใช้ชนิดข้อมูลอื่นที่ไม่ใช่อักขระ
• จำนวนค่าที่เป็นไปได้ของชนิดข้อมูลขององค์ประกอบต้องมีอย่างน้อย 20 หากความยาวรหัสของคุณขึ้นอยู่กับมันมิฉะนั้นอย่างน้อย 2 ซึ่งอาจเป็นชุดย่อยของตัวอักษรหรือค่าอื่น ๆ ที่สนับสนุนในประเภทเนทีฟ
• ช่องว่างและค่า Null ใด ๆ เป็นเพียงค่าปกติหากคุณอนุญาตในอินพุต นอกจากนี้คุณยังสามารถยกเว้นพวกเขาในประเภทองค์ประกอบ
• การเปลี่ยนแปลงกฎ:คุณได้รับอนุญาตให้รองอาร์เรย์ที่สั้นกว่าด้วยค่าเริ่มต้นทั่วไป (เช่นช่องว่าง) หากคุณต้องการใช้อาร์เรย์ที่มีความยาวเท่ากันเพื่อจัดเก็บข้อมูล
• kอาจเป็น 0 หรือ 1 ก็ได้ มันรับประกันว่าจะอยู่ในบรรทัดที่ยาวที่สุดในอินพุต (หมายความว่าอินพุตมีอย่างน้อยหนึ่งบรรทัดที่ไม่ว่าง)
• คุณสามารถเลือกได้ว่าจะหมุนขึ้นหรือลง
• อย่างใดอย่างหนึ่งเพียงหนึ่งตำแหน่งหมุนหรือหมุนnตำแหน่งที่nเป็นจำนวนเต็มบวกที่ได้รับในการป้อนข้อมูล
• รหัสที่สั้นที่สุดชนะ

APL (Dyalog Extended) , 9 ไบต์^SBCS

โปรแกรมเต็มรูปแบบ แจ้ง stdin สำหรับบล็อก 2D ข้อความจากนั้นk (0 หรือ 1 ตามขึ้นอยู่กับการตั้งค่าปัจจุบันของ APL) แล้วn บวกnหมุนขึ้น, ลบnหมุนลง

โดเมนประกอบด้วยอย่างใดอย่างหนึ่งต่อไปนี้:

1. อักขระ Unicode ทั้งหมดยกเว้นการเว้นวรรคปล่อยค่าที่อนุญาต 1114111 ซึ่งมากกว่า 20 ที่ต้องการ

2. ตัวเลขทั้งหมดยกเว้น 0เหลือค่าที่อนุญาตประมาณ 2 ¹²⁹ค่าซึ่งมากกว่าค่าที่ต้องการ 20

เนื่องจาก APL ต้องการให้บล็อก 2 มิติเป็นรูปสี่เหลี่ยมผืนผ้าอินพุตจะต้องถูกเสริมด้วยช่องว่าง / ศูนย์ สิ่งนี้สามารถทำได้โดยอัตโนมัติโดยป้อน↑ทางด้านซ้ายของรายการสตริง / รายการตัวเลข

⎕⌽@≠@⎕⍢⍉⎕

ลองออนไลน์! (ช่องว่างที่ชัดเจนเป็นช่องว่างที่ไม่ทำลาย)

⎕ แจ้งให้บล็อกข้อความ

⍢⍉ ในขณะที่ transposed:

 @⎕ ใช้สิ่งต่อไปนี้ในแถวอินพุต ':

  @≠ ที่องค์ประกอบที่แตกต่างจากต้นแบบของพวกเขา (ช่องว่างสำหรับตัวละครศูนย์สำหรับตัวเลข):

   ⎕⌽ หมุนขั้นตอน "อินพุท" ไปทางซ้าย

APL (Dyalog Unicode) , 22+ ไบต์^SBCS

รุ่นนี้อนุญาตให้ชุดอักขระเต็มโดยใช้ศูนย์เป็นองค์ประกอบเติมที่ระบุได้

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

ลองออนไลน์!

หลักสูตรนี้หมายความว่าไม่อนุญาตให้ใช้ค่าศูนย์ในอาร์กิวเมนต์ที่เป็นตัวเลข โปรแกรมที่สอดคล้องกันสำหรับตัวเลขทั้งหมดจะมีการ0แทนที่ด้วยสามเหตุการณ์โดย' 'ใช้พื้นที่เป็นส่วนเติม:

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

หากเราต้องการช่วงเต็มของ (ทั้งตัวอักษรและตัวเลข) เราสามารถใช้ค่า null เป็นตัวเติม:

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

และในที่สุดถ้าเราต้องการรวมโมฆะและวัตถุในโดเมนอินพุตเราสามารถกำหนดคลาสการเติมและใช้อินสแตนซ์ของสิ่งนี้เป็นการเติม:

~∘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 ดัชนีและส่งคืนรายการสตริง

คอลัมน์หมุนขึ้น 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 bytes

-7 bytes by changing to an arithmetic ternary, -9 bytes by changing the character in-place (TIL), -4 bytes by inputting the index on stdin and the strings as arguments, -5 bytes by using a string instead of an array to store the rotating characters.

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

Old Old Old Old Try it online!

Here are the keys to making this answer work:

• $array[0] or $string[0] is always empty
• $array[n] or $string[n] is empty if n is larger than the length of the array/string
• array[i]=c or string[i]=c will replace the element/character.
• In $[$#s<i?0:++j], j is not incremented if $#s<i.

In the original 94 byte answer, there was an interesting issue I came across involving using <<< to print. I had to use echo to get around it:

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

The reason for this can be seen here:

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

Here-strings are run in subshells because they are given as stdin to another program. If there is no program given, it is implicitly given to cat. You can see this with <<< $_. <<< $ZSH_SUBSHELL is similar to echo $ZSH_SUBSHELL | cat. Since we need to increment j, we can't be in a subshell.

R, 62 bytes

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

Try it online!

Takes input as a space-padded matrix of characters. Rotates upwards. All thanks to Kirill L.!

R, 74 bytes

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

Try it online!

This submission predates the allowance of padded lines.

Aliasing substr here won't work because we're calling substr and substr<- in the first line.

I/O as a list of non-padded lines; rotates upwards.

C# (Visual C# Interactive Compiler), 82 bytes

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

Try it online!

Credit to @ASCIIOnly for suggesting foreach which led to a 12 byte savings!

-8 bytes thanks to @someone!
-1 byte thanks to @EmbodimentofIgnorance!

Ruby, 57 bytes

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

Try it online!

Takes input as an array of lines a. Rotates the text down at 0-based position k. Returns by modifying the input a.

05AB1E, 21 bytes

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

Can definitely be golfed some more..

0-indexed; input and output both as a list of strings.
It rotates down like the example, but < can be replaced with > to rotate up instead.

Try it online (footer joins the list by newlines, remove it to see the actual list output).

Explanation:

ʒ  }             # 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, 41 bytes

Solution:

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

Explanation:

Not sure if I'm missing something... 0 index, rotates up (change the 1 to -1 for rotate down)

{.[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

Japt v2.0a0, 18 bytes

0-based with input & output as a multi-line string. Rotates up by 1.

There's gotta be a shorter method!

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

Try it

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

Jelly, 16 bytes

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

A dyadic Link accepting a list of lines (lists of characters containing no newline characters) on the left and an integer on the right which returns a list of lines.

Try it online! (footer splits on newlines, calls the Link, and joins by newlines again)

How?

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 bytes

k is 0-indexed, rotate down

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

TIO

Perl 6, 38 33 bytes

Modifies the array in place (rules don't disallow)

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

Try it online!

JavaScript (Node.js), 52 bytes

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

Try it online!

-7 bytes thanks to Shaggy!

Didn't see a JavaScript answer yet! Port of my C# answer.

Charcoal, 34 28 21 bytes

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

Try it online! Link is to verbose version of code. Takes an array of strings as input. 0-indexed. Edit: Now that PeekDirection has been fixed, I can manipulate it directly. Explanation:

θ

Print the input strings.

Ｊη⁰

Jump to the top of the column to be rotated.

≔ΦＫＤＬθ↓℅ιζ

Extract the cells that have been printed in.

ＵＭζ§ζ⊖κ

Replace each printed cell with the value of the previous cell (cyclically). Conveniently the cell values are read at the time of the PeekDirection call so the fact that the MapCommand call writes new values into the cells doesn't matter.

Pip -rn, 32 bytes

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

0-indexed, rotates down. Try it online!

Filters to find the indices of all rows that are long enough to participate in the rotation. Then loops over those rows, swapping the appropriate character on each row with a temp variable s. Visiting the first row again at the end swaps the dummy value back out again.

Jelly, 19 bytes

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

Try it online!

1-indexed. Rotates down. A monadic link that takes a right-padded list of Jelly strings (a list of lists of characters) as the first argument and k as the second. Spaces are forbidden in the input except as right padding, but all other characters are permitted.

As implemented on TIO, the footer splits a single string input into a list of strings and right-pads it, but this is for convenience; as I understand it, the result of that step is permitted input for the main link per the rules.

GFortran, 199 bytes

_{-20 or so by reading from stdin rather than a file
-14 by using implicit integers for i, k, n
-4 by removal of spaces and ::}

Requires user to input k and n on the first line, where k is the column to rotate, and n is the number of rows of text. Subsequent inputs are the lines of text to be rotated. This was a pain to write! Fortran is so pedantic!

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

• Original, ungolfed program here, with comments and compilation notes: rotcol.f
• 203-byte version: rextester.com
• 199-byte version (new): Try it online!

T-SQL, 195 bytes

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

Try it online ungolfed version