Python 2, 111 110 109 99 98 96 94 bytes

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)]

Try it online!

Takes input as a list of lines and 0-index column, and returns a list of strings.

Column is rotated up 1.

_{-11 bytes, thanks to Jo King}

Java 8, 107 106 135 107 bytes

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 bytes for a bug-fix..

0-indexed; rotates down like the example.

Input as a character-matrix; modifies the char-matrix instead of returning a new one to save bytes.

Try it online.

Explanation:

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 bytes

-7 bytes by changing to an arithmetic ternary, -9 bytes by changing the character in-place. (TIL)

i=$1

shift

for s;c+=($s[i])

c=($c[-1] $c)

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

Try it online!
Try it online!
Try it online!

Input is index [ string ... ]

So, my previous comment about the subshell printing is now outdated, but here it is with the old last line for posterity:

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

Hey, Gamma, why did you use echo in that last command instead of <<<?
Wouldn't <<< save you two bytes?

I'm glad you asked! Go ahead and give it a try. See if you can figure out what's happening.

(Hint: Run echo $ZSH_SUBSHELL; <<< $ZSH_SUBSHELL.)

You get 0 for echo, but 1 for <<<.
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.

Anyway, on to the main event:

i=$1

shift

for s

    c+=($s[i])                       # without "", empty strings aren't added

c=($c[-1] $c)                        # add the last element onto the start

for s

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

         $s[0,i-1]                  ${s:$i}  # before and after the replacement point

                  $c[              ] # insert from char array

                     $[$#s<i?0    ]  # Sting is too small: at index 0: empty string

                     $[$#s<i  :++j]  # Increment j and insert from there

                                     # j is unset, so ++j initially sets j to 1

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ÈrS_Y¦V?Z:°TgXrS

Try it

yÈrS_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'       ['AAARTnTW', '   ohnhr', ...]

  ⁹ị             - Ith item                           'amnv.nnt'

    Ỵ            - 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                 'tanmvnn.'

                 -   -- 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/$rK.(?=(?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, 203 bytes

-20 or so by reading from stdin rather than a file
-14 by using implicit integers for i, k, n

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!

Original, ungolfed program here, with comments and compilation notes: rotcol.f

Try it here: https://rextester.com/RBEE63006

character(80),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

T-SQL, 208 bytes

WITH C as(SELECT rank()over(order

by i)r,sum(1)over()c,*FROM @

WHERE len(x)>=@c)SELECT

isnull(m,x)FROM @ z

LEFT JOIN(SELECT stuff(c.x,@c,1,substring(e.x,@c,1))m,c.i

FROM c,c e WHERE e.r%c.c+1=c.r)d

ON z.i=d.i

Try it online ungolfed version