[Question]
  [
Given an integer *k* and either a block of text, or a 2d array that the inner arrays may have unequal lengths (that resembles a block of text), rotate every character or element in the *k*-th column up or down to the next position that exists.
### Example
Rotate the 20th column of the following text (1-based):
```
A line with more th**a**n k characters.
A longer line with **m**ore than k character.
A short line.
Rotate here: ------**v**--
This is long enough**.**
This is not enough.
Wrapping around to **t**he first line.
```
Output:
```
A line with more th**t**n k characters.
A longer line with **a**ore than k character.
A short line.
Rotate here: ------**m**--
This is long enough**v**
This is not enough.
Wrapping around to **.**he first line.
```
Rotating the *k*-th column of the same input where 35 < *k* < 42 would yield the input text unchanged.
### Rules
* You may use raw text, an array of lines, a 2d array of characters, or any reasonable format to represent the data. You may also use data types other than characters.
* The number of possible values of the data type of the elements must be at least 20 if your code length depends on it, otherwise at least 2. This could be a subset of the characters or other values supported in the native type.
* Spaces and any kind of null values are just normal values, if you allow them in the input. You may also simply exclude them in the element type.
* **Rule change:** You are allowed to pad the shorter arrays with a generic default value (such as spaces), if you prefer using arrays with equal lengths to store the data.
* *k* could be 0-based or 1-based. It is guaranteed to be inside the longest line in the input (implying the input has at least one non-empty line).
* You may choose whether it rotates up or down.
* Either just rotate one position, or rotate *n* positions where *n* is a positive integer given in the input.
* Shortest code wins.
  
[Answer]
# [Python 2](https://docs.python.org/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!](https://tio.run/##hc6xTsQwDAbgnafwdq3aIpWNSAzsnRASQ8hgrsklutSu3BTE05ckAuk2okz//yX2@p0808Phnt6PiMvHjIA9KR21ItM1UZMySLOeNBnHAhMEAtRBmQ4hOJgKMHo0XabdqExbVOhjcZb2xQom22BrjlLU2DX69AwxkIWvkDwsLBaSR4IrnD0KnpOV7f7UQ2FMFyv/6V@8eZZUbQ1eOOXh4K1YBUM9n8NQmlcfNsi3/J7X5P3i64vbjjjdVm@C6xoyR@GdZkict7Dggmx/I00P42Or7mCVQDk8fgA "Python 2 – 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
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 9 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Full program. Prompts stdin for 2D block of text, then *k* (0-based or 1-based, depending on APL's current setting), then *n*. Positive *n* rotate up, negative *n* rotate down.
The domain consists of either one of the following:
1. all Unicode characters, *except spaces*, leaving 1114111 allowed values, which is more than the required 20.
2. all numbers, *except 0*, leaving approximately 2129 allowed values, which is more than the required 20.
Since APL requires 2D blocks to be rectangular, the input must be padded with spaces/zeros. This can be done automatically by entering `↑` to the left of a list of strings/numerical lists.
```
⎕⌽@≠@⎕⍢⍉⎕
```
[Try it online!](https://tio.run/##jVBBTgMxDLznFZUA9RTUcuRUBC9AlTi7u2ETsSSRNy3wAdpKLRIH7hYf4AVc/JR8ZHEWhIATlmyNMjMZyxBbXT9AGxpt7pPxtan7vFnHPj@95N37LG9pVuD@Ne@3AgrZj4aKKj8@j8@YWucN051Lluk2oOBkwTPdMFUWEKpksDsejwZt8I3B/3m@LJ0NmD4d5eUyJEiitwbNKZMeaqW1UHPrOqbSJYbJ@LBsbDH9In1IP7krhBhd0QOGpa9llVDWkYxrh913tDqZKH6bKolTfy5wfiH/TKRhUck8ODwStZp@AA "APL (Dyalog Extended) – Try It Online") (the apparent spaces are actually non-breaking spaces)
`⎕` prompt for text block
`⍢⍉` while transposed:
 `@⎕` apply the following on the input'th row:
  `@≠` at elements different from their prototype (space for characters, zero for numbers):
   `⎕⌽` rotate "input" steps left
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 22+ [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
This version allows the full character set by using zeros as identifiable fill element.
```
0~¨⍨↓⍉⎕⌽@(0≠⊢)@⎕⍉↑0,¨⎕
```
[Try it online!](https://tio.run/##hY/BSgMxEIbveYoBlVpwJfXoqaW9eBJE8Dxu4ya4TcJsqnjxuFqxRZHexVNvPoGXPkpeZJ2sCHvrkAxk/u@fn6Avs@kDlq5o4mp9dh7rNyni85Nv5ON2E5ebWH/E5YK1@PozPJRx8RlfvvrDNOBx/S6PGFutG/Y00JYXvRGUxiq4N0HDzJGCoNHCLeQaCfOgqDruQaKcLRTtgv/YSjsKLZreFy5gUKAVqVPI2rrLMhYutamAT1oNyrp5oRPfUawLHeGK0HvDLJKb2ykEx/kKbgxV/2niRIrt90Bwhuh8cTxhu@SL1zn3vf0DJsXgFw "APL (Dyalog Unicode) – Try It Online")
This of course means that zeros are not allowed in numeric arguments. The corresponding program for all numbers would have the three occurrences of `0` replaced by `' '` and thus use space as fill:
```
' '~¨⍨↓⍉⎕⌽@(' '≠⊢)@⎕⍉↑' ',¨⎕
```
If we truly want the full ranges of (even a mixture of) both characters and numbers, we could use null as fill:
```
n~¨⍨↓⍉⎕⌽@(n≠⊢)@⎕⍉↑⎕,¨⍨n←⎕NULL
```
And finally, if we wanted to include nulls and objects in the input domain, we could define a fill class and use instances of this as fills:
```
~∘I¨⍨↓⍉⎕⌽@(~⊢∊I←⎕INSTANCES⊢∘C)@⎕⍉↑⎕,¨⍨⎕NEW⎕FIX':Class C' ':EndClass'
```
[Answer]
# [Zsh](https://www.zsh.org/), ~~94 87 78 74 69~~ 68 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, **-1 byte** thanks to @pxeger letting me know `${c[])` allows arithmetic ternary.*
```
read i
for s;c+=$s[i]
c=$c[-1]$c
for s;s[i]=${c[$#s<i?0:++j]}&&<<<$s
```
~~[Old](https://tio.run/##LU87bwIxDN7zKz7RCHMCJG5ggWPv1qVSB8QQEkNCcwlKDuiD/vZrDuHBsr6X7Z9s@8wd5l/iZp1nJFYG3gVew0TBV@Xx4OcYyQEe9W4ja5GtO3TiEBPyWk83E5m3blcJXSa9ndc7SF096clEvuTGVdV43DSNzPc7axtRHIuZK9JimE5PO/mbV9L99Zcw7HM4QUGL4qDNs0iYGLivC7EHEYyol6BXRqs@ORe0ZRWQlVeGQB@WE8NlfMdLwjEahHgreG6jfzxIQwa92Rk6q7pBqdAp7xGT4URiuQC9D0y4tPsCgIqkixFGtQHWHS2JumQMDefEmdOVgWHFWelyUCkS/w "Zsh – Try It Online")
[Old](https://tio.run/##LY@9bgIxEIR7P8UosbRBgMQVNHAobbo0kVKgK4y9YIPPRvYB@VGe/WIjplit5lvN7v5kO2YeMP8SN@s8I7Ey8C7wGiYKviqPO5/jSVb7aXQb2Yhs3X4Q@5iQ13q6eZF567qJ0KXT23nTQerJA7O2EYUvZq6AguVWPufWvS5W0@mx6@RvXkn3N15CXeRwxAkKWrRtS5uHSJgYeGwK2IEIRjRL0BujVyfOxe1ZBWTllSHQp@XEcBnf8ZJwiAYh3oqf@@jvv1HNoHc7w2DVUCcVBuU9YjKcSCwXoI9KwqXfFQNURoYYYVQfYN3BkmhKRi04J86crgzUFWely0FFJP4B "Zsh – Try It Online")
[Old](https://tio.run/##LY8xb8IwEIV3/4onanFFNBIZWCBR125dKnWIMpj4wAbHRnYAtX8@tStuOJ2@9/Tu7jeZWTyMdYzISsNZz3voIPiuHBJPqCosZMGL2bayFsnY4ySOISLth3X7KlNn@5UY8jR0Vd1DDqunXJQ2U9nJl9TY981uvT73/XLZNI1M882XfIszLlAYRKbUPouEDp7nOgsHEEGLegv6YIzqwinTkZVHUk5pAn0bjgyb8BNuEaeg4cMj8zQG9/8SlQz6NG@YjJqKU2FSziFEzZHEdgP6Koq/jYcMQNkyhQCtRg9jT4ZEnTNKwzVy4nhnoKy4qiEflIvEHw "Zsh – Try It Online")
[Old](https://tio.run/##LY89b8MgEIZ3fsUrF@UapZHioUtjq2u3LpU6RB6IuQQSDBE4ST/U3@5ClBsAPc9xL/wkM12NdYzISsNZz2voIPiiHBKPWC5RyYIrYb3mr7aSdSWSsbtR/E63S1bsQkRa94v2UaaN7eaiz6d@s6w7yH5@18W0mcqNfEiNfV29LBaHrpvNmqaRafpD3nPWLaUSZ1/SLQ44QqEXWVJ7LxI6eJ7qLLYgghb1M@iNMagjp0wHVh5JOaUJ9Gk4MmzCdzhH7IOGD9fM0xDc7cNUZtC7ecJo1Fg6FUblHELUHEk8r0AfxfjzsM0AlFvGEKDV4GHs3pCo84yy4BQ5cbwwUCJOqs8PykXiHw "Zsh – Try It Online")
[Old](https://tio.run/##LU5BbsIwELz7FaNgsSBAIodeSqL22FsvlXpAOZh4g90mNrIDtP08tQMry5qdnZ2dv2hu3WK5uAVWGlZ0PiDu2lUt4942oq1lu9@UjWwfk8xmTu7lLFb2Zfu8Wn01zXxeVZWMt6W4GtszJrfeOt5BewHwRfWIPGKzQSHzoEisdZp/6kKWuYnGdqNIYHbn4R3iqK1bT0YRKr1wPA/sxphkXTJ6LZDuJjBtZJfcUv0oEto7vpUAFA4gghblE@iNMajvbImBVTqjeqUJ9Gk4MGzErz8HHL2G89fEx8H3UwjKHvRu1hiNGrNSYVR9Dx80BxJPW9BHnrjzcEgEKElG76HV4GDs0ZBIaej@4xQ4crhwxhRPqk2RUpH4Bw "Zsh – Try It Online")~~
[Try it online!](https://tio.run/##LU7LbsIwELz7K0bBYkGARA69lETtsbdeKvWAOJh4g90mNrID9KF@e2oDK8uanZ2dnZ9oxnY2n42BlYYVrQ@Im2ZRy7i1O9HUstmuyp1s7pPM1vK32cpJrOzT@nGx@Nj9TadVVck4zsXF2I5xNeus4w20FwCfVYfIA1YrFDIPisRap/mrLmSZm2hsO4gEJjce3iEO2rrl1ShCpRcOp57dEJOsTUbPBdLdBK4b2SW3VN@LhPaOxxKAwh5E0KJ8AL0wevWZLdGzSmdUpzSB3g0Hho349qeAg9dw/pL42PvuGoKyB72aJQajhqxUGFTXwQfNgcTDGvSWJ@7U7xMBSpLBe2jVOxh7MCRSGrr9OAaOHM6cMcWjalKkVCT@AQ "Zsh – 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.
[Answer]
# 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.](https://tio.run/##7VbNi9pAFL/7VzxsFxOMQaHbUmMsZUuhh17WQg/iIcZRxySTkHlxWcS/3Z3RF51GI7sU2ovCM@P7/r0PM6tgHXRWs2gXxoGU8DPgYtMAkBggD2GlpG6BPHbnhQiRp8L9TofBD4FswXLnktJDKmSRsHwQLoN8PBlPhkOYg7@LOsOkM9xwgSD9xI2ZWODS4X6n583T3NLakPldBz0@kB76yZjfyck4mjjHk58Nel@wnzmZj7Y28pJxu62F5G7gR57tbXdeQ@HIimmscBCcdcpnkCiI1ghzLhbjCQS2hguATKIl2BOUGR/Y9Nm0vracFiiKFXFFQhEj3hPxUNGSeImiVFFu6JXygOw1L6JnaMhyeoZkw4gnFbmtrVOfWUqeF4bV/866PmNJ1mVErMn23MMjWSHFRCPfpRFbP/vE79TQ@niuRvlF3jjlCpVzteJAEQXxC@IvL2F4azBhQH5ToNZvozkZEa@kXTaw9KZlM2MA0sowlMWek69yPK@08JhW77Pt3XbutnO3nft3O/eJVk6/MPXbl/tdD/jgg/pqt21Sur6P5hQ9KPpWAa3l3Qs8DXO6n9Fz2TvFf6/ozkgVgL/y/2F0Nst1Uz819q5@b6vWubGBM7JILsYwWyePmqeW/bnjJ6z3e6TbxunGtb@i7IGXoIGLrEAHdNsiuq0cri8gWcbyANMcfGh2mm6ufgdofbynAo6eJbLETQt0M2WAsbCOJvUqzcdU5cJmEKZxkYg@RH6zHV3Rh2PkyG43183XR5@7QZbFz8rODcKQZWjtwRrDeqgCxFww6B9KUY7rBf96WA61sbSF/Vd1oN5sdy8)
**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`
```
[Answer]
# [R](https://www.r-project.org/), 62 bytes
```
function(L,n){L[A,n]<-rep(L[A<-L[,n]!=' ',n],2)[1+1:sum(A)];L}
```
[Try it online!](https://tio.run/##hY2xbsMgEIZ3P8V1AlRsNRmTeMjOFFXq4HqgNg6o8WEd5yZS1Wd3cVRl7QkdcPru@2kZ4FAuw4wdh4jSaFTfpjlqbA8luUnm96E0Tf4/1QJEvvVWNZvnzS7Nozyqdm9@FpMdMEgDNZxcP3dO0kfAXiemNF0CyyHSaFneVqftTUCXpNLX0LOvR3uT2HlL8qaU0kLkhtm0fVH7vCcDBITNDilepVGqyx7TBN3q5KZaCC3eUajiCJdshWtgD2MkB@wtwiesYtuxo1StTMSzo//QlUw@Et/BqjhFtuzAO3I7KO/1VZbFqw8J8lml4DDOZ18VjylGfgzfyE5TyJSlOGMPHHOmgyFQ@stYfgE "R – Try It Online")
Takes input as a space-padded matrix of characters. Rotates upwards. All thanks to [Kirill L.](https://codegolf.stackexchange.com/users/78274/kirill-l)!
# [R](https://www.r-project.org/), 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!](https://tio.run/##hY2xbsJADIb3ewqPFykXQUcUkNgzISQGxHAEhzsBduRz2qHqs6eXgOhYy4P96dP/y9hB7cZuoFYjk21KKr7TcE4qtjluTyVlsBbs7R@sHbXB57PYrOlplB/F0S1PpvkZOyvoL00kTDbzRWG2cM8ffEUN8GBB0OAJbjCF@FZRUjU5TFeU/9TJTIFFZ7EyO1avCAEFV@Dm@XTO7ENMkHcKBSQerqEyb0qsb3gQ3/cxW154oAso506ELkp6dYy/ "R – 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.
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 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!](https://tio.run/##hVBNawIxEL3nVwwe3ATcYI/tmqVSKLT0VAUP1kNMoxtWE0nGj1L627dJbK23DkOYmTzevHkqlCqY7nFv1chYHIwVGmdHTy8m4M@rGunrGLAC0bWilqL@PEgPShTDopJ81miv6VLUS/7g9hbrtt@ndDlvFwPFBFWDVDLGVT1kfOoSJ2Xz4SJOhaq@uooE9Mau5wvYGKsDCLjvkXFu4Giwga3zGrCRFlpIaqRC7QNPGGfX2v8HTcjQOI8ZyMmrQ4kaku47KHMcypJMGxMgZiIFbd1@3XBymVqHl@HMy90uSgbp48XvgC7u1LAyPvzu6PGpN1vK@GS3MUiLN1uwipBsXNSVrszX8oneaIX0JGp65Tc7RavG3ssPythfWZEVvbllNFPEbuYNanr2jz87Y/OiQf6@Yrb6CGcQveaNUXXf "C# (Visual C# Interactive Compiler) – 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!
[Answer]
# [Ruby](https://www.ruby-lang.org/), 57 bytes
```
->a,k{b=a.map{|i|i[k]}-[p];c=-2;a.map{|i|i[k]&&=b[c+=1]}}
```
[Try it online!](https://tio.run/##hc0xa8MwEAXgXb/iJpPSSJBuTVDAkK4ZSqCDMeasypFwLYmT3FIS/3bXCiXQqcdNj4/3aGy/507OfI/r/tJKFAOGy9VebdXXE69CvVOSP@3@5EUh20o9yk09TTPKQ3kqxYd1Oma0KrbK@CE8sK7C9ea5ZmFMEZA1zcvx0DSshGzhyyYDgycNyaCDHpRBQpU0RZGNd2dN/9Eso/GUblCwV58waTCa9Bb47T45ZydjIyyfS0E7P56NYPfU@XQP3whDsItC8qN7h@SXTQ2dpfi7Mf8A "Ruby – 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`.
[Answer]
# [K4](https://kx.com/download), 22 ~~41~~ bytes
## New Rules:
**Solution:**
```
{+@[+x;y;.q.rotate 1]}
```
If the input is already padded to the maximum length, then this becomes much shorter.
## Old Rules:
**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
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 21 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ʒ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](https://tio.run/##yy9OTMpM/f//1KT0Rw07a0MP7Ty3NaIy@9DKlMyIQ@tsDq/wBKLjc//HHtr9P1rJUSEnMy9VoTyzJEMhN78oVaEkIzFPIVshOSOxKDG5JLWoWE9JRwGkLD8vPbWIkGqo4uKM/KISsFqwQFB@SWJJqkJGalGqlYIuGJTp6oJkQjIyixWACGS6Qmpefml6BlgHslxefgmyVHhRYkFBJlB5YlF@aV6KQkk@0BWpCmmZRcUwK2O5DC0B) (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
```
[Answer]
# [Japt](https://github.com/ETHproductions/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](https://petershaggynoble.github.io/Japt-Interpreter/?v=2.0a0&code=echyXFNfWaZWP1o6sFRnWHJT&input=IkEgbGluZSB3aXRoIG1vcmUgdGhhbiBrIGNoYXJhY3RlcnMuCkEgbG9uZ2VyIGxpbmUgd2l0aCBtb3JlIHRoYW4gayBjaGFyYWN0ZXIuCkEgc2hvcnQgbGluZS4KUm90YXRlIGhlcmU6IC0tLS0tLXYtLQpUaGlzIGlzIGxvbmcgZW5vdWdoLgoKVGhpcyBpcyBub3QgZW5vdWdoLgpXcmFwcGluZyBhcm91bmQgdG8gdGhlIGZpcnN0IGxpbmUuIgoxOQ)
```
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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/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!](https://tio.run/##hY2xCsIwGIT3PsWPe4s4urn4ACJIx1B/m2hNyt9U0a2zTyDuuougoZuC75G@SEyLuHrcdPdxt8Qs2zm3b6p7UxlbH2x9G1tzDK2p3te4qR7WnHzzPPecr16X2LkRZEIibIXmsFaEoDmTsIKEM2KJRiqiwDNKpkj/0JYsuCLdgVEwUZppBI6EQwg7bcIwmHJRgHc7CihVmfIo@KVS6V84I5bnwlOMVCnnoJX/RFgIKr4fbtD/AA "Jelly – 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
```
[Answer]
# 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](https://tio.run/##Vc3BSsQwEAbge55iWIK0C03sQYq7lOJ5byJ4ESHUsQlukzCZXQ/WVze2dREd5vT/HzMR6XiTc9Jqq/VeUrt5Vh/y6nOzT1rMiZZUqHJu@lbWcybp6aCKri26tFPltlvrqdSynibZ62HEnOtbcQdH5xHeHVsYAyGwZQ9v0FtDpmekpBYT/ID0h5ofav7RRSYbiFeoxH1gwwgWCXdQrTNWlXiwLsG8y1FAH06DPYvf1Ae@hEo8konRzcpQOPkX4ADKIrw6SpcfXyGyCz7l6rppmvgN)
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 38 33 bytes
Modifies the array in place (rules don't disallow) 
```
{@^a.grep(*>$^b+1)[*;$b].=rotate}
```
[Try it online!](https://tio.run/##hZHNTuswEIX3fopRiW6b0loXFiyIiuAJkK6QWMAtcpppY3DsMJ7wI8Szl7FTwZIokqXjMz/nc4/kzvbdOxSMbwwrmFyBsx7h1XILXSAEbo2HJ9i0hsyGkaJW4gl@h/SbNTljG4izUat/gQ0jtEh4Dsv8vSyX6qa1EeRPTQF9GHatVt@qD/wt3pLpeysuQ2HwDXCQmQhbS/EwY1IpdQQ3IsoWzqGsCXKG1wjbQNltfT9wKq3lCrrBsW1shz7a4I2T1mTeFxDDuI@JhyIv0eUS4cWQNbVDSN0luhJ8l7lK@GWOOvbO8mxy7yel7kw/@xiF6XRRPJT6Knk/D2cl615vtxE5hT1ZWt/gGzapaRFGfQWnf6sk/Kld2DzBav9xuTZ6R9jP5hfFuj4@Ke/mVVH/1yvKiD/3lRrNs3GzxaFXmfFcD5wQ5DfrCZmtk8TcJsg57Q@7JmD0UwbC58FSAhaZ0gsQRiGndJTYiew4J6ed68dgfVntvwA "Perl 6 – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 52 bytes
```
k=>a=>a.filter(b=>b[k]&&([b[k],a]=[a,b[k]]))[0][k]=a
```
[Try it online!](https://tio.run/##hY/dasMwDIXv/RS6am1owna5BQf6CmOwiyxQNXViN6kVbLXr22dx@gO7mhDo6PBxhI54wdgEN3Lm6WCmVk@9LnHuvHUDmyD3utxXfb1aySrNDda6wk2StVLVSz0LjVMhLhgggoad2MLgvIEfxxZOFAywRQ89NBYDNnNmzBNDvjPhPzSR0VLgBczFBzGyAWuCeYdsqUuWiU/rIsydQsF4Onc2F0/XEz/Nr4Dj6GYKA539AZjmmwZaF@Ljxu72DOooAHIO7iRVUnEcHMv1t18v6wlHedXl9eGvVbIL0crXNyVR3VJY4x/4SM4/2PtyDyxEQz7SYPKBOsmqmH4B "JavaScript (Node.js) – Try It Online")
-7 bytes thanks to Shaggy!
Didn't see a JavaScript answer yet! Port of my C# answer.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~34~~ ~~28~~ 21 bytes
```
θＪη⁰≔ΦＫＤＬθ↓℅ιζＵＭζ§ζ⊖κ
```
[Try it online!](https://tio.run/##hY5Ba8MwDIXv/RWiJweSsR3XnsLCYGNjZRR2KD0YR4tNEimTlXb0z2dO2KC3GYElve/Zz3krjm03TTsJpOYr266ex37Ys/E53KapjDE0ZB5Dpyhmh9hWQdBpYDIvSI36ZMphU/GZ0v0mdSDbmZCl4ZL8r3Z44L63VJtLDqU@UY3fc1uhE@yRFGvTZlm2nabDYbUuoQuEcA7qoWdBUG8JWnApqXUpQ7xZ5wvG1KD8R//C0bPowi6Ld1arCB4FN1As51QUs7L3IUKq@XVA4rHxi@NaI9Zr6UPsMISEW@GRalBOKRA@g8S/L4853N0fp@LU/QA "Charcoal – 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.
[Answer]
# [Pip](https://github.com/dloscutoff/pip) `-rn`, 32 bytes
```
POgY#(g@_)>aFI,#gFiyAE@ySsg@i@ag
```
0-indexed, rotates down. [Try it online!](https://tio.run/##hc0xC8IwEAXgPb/iwEXBFBx1kHSw4KSoIE4S6pkcahIuqdJfH9siXT1ueny8FyjkvN@Zy2Rq1HW21tV2PjEVteVGtcdoFCltcl4sRQlPcggfShZenhGS1Q4eUFvNuk7IseiNdwb5H@1ltJ7TAAtx8EknBIuMK5DDvaUUJ0sRuu9LAZ1vjC3EmDqfxvDMOgTqlGbfuBsk320i3InjbyNLdl8 "Pip – 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.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 19 bytes
```
ZnÄ×$ịḟ¹ṙ-;ɗɗʋ€⁹¦⁶Z
```
[Try it online!](https://tio.run/##hc0xCsJAEAXQPuewnSCWWnkFEUS7JY7Z1bgbJhtEu4hdDhCs7LSxFDGkS6p4i@QiayKSVpji83n8WaPn7Y1ZyOJUJL0qi6vXJU@r9AyjMimTd1wf73WU5tc6ei5MlT0ObShuc2PG4AmJsBOaw1YRguZMwgYczog5GimwrcYo6SL9o60MuCL9hbY1UZppBI6EQ2vKRQDNtVOAUoUut62ulUp35YyY74tGMVKhXIJWzSeElaDgt2wG/Q8 "Jelly – 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. 
[Answer]
# [GFortran](https://en.wikipedia.org/wiki/GNU_Fortran), 182 bytes
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! [Try it Online.](https://tio.run/##hZDBTsUgEEX3fMXsCqZtfK58JV3wC8bENbbTQlqHZuDp51d41rqUTGBy78lcYAqc2FIzTz/Nvg/Osh0SsrxeVW3XNQw22fcVu87ITuk//6K4joLRjg/1UpM@WJRGklJiDOD7S9YLUUmjqtpIrzT35ZBLtyjhJ8ktYVtBpZJD0qfVRx171kijn8o@BmFy4q@3sad0DC32vj89wrMwsHpC@PLJwUdghOQswQLnpWNbmEAz8n9oIaPL33IHW/ESUn4cOGTsoLmvz6YRr85HyFWGAlK4za4Vp0ohneIb223zmbIcbjRCCjkTYfIcj4xv)
```
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.' ')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](https://gist.github.com/roblogic/d1175fa16fb4540910cc389a1e5374e6)
Saved 20B by reading from stdin rather than a file. Saved 14B by using implicit integers for `i k n`. Saved 4B by cleanup of spaces and `::`. Saved 17B by simplfying logic, and cutting i/o formatting guff.  
~~[203 bytes](https://rextester.com/RBEE63006)~~  
~~[199 bytes](https://tio.run/##hZBBboQwDEX3OYV3JCOIOl11QCxyhapS1ykYEkEd5GTa49PAULpsZCXW/0927CFwYkvVODySde2cZdslZHm7qdLOc@hssh8z1rWRtWr@/KviMgpG28tLeVFTSc2BozSSlBJ9AN9es35AhTSqUEZ61XC7PXKqJyX8IFkT6qLQgfUjhUIlh9ScVBub2HKD1Pthu/sgTP7Cr7ewp7TXL81mr@vzE7wIA7MnhG@fHHwGRkjOEkxwThH1xgQakf9DNzK6vKcd1OI1pDwqOGSsodrPV1WJN@cj5NiKAlK4j06LU6WQTvGd7bL4TFkOd@ohhdwTYfAcjx4/)~~
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 19 chars
```
{⍉¯1⌽@{' '≠⍵}@⍺⍉↑⍵}
{                  ↑⍵} ⍝ from nested vector of char vectors to char matrix (padding=space)
{                ⍉   } ⍝ transpose
{              @⍺     } ⍝ apply on row ⍺ (left argument)
{  ¯1⌽@{' '≠⍵}       } ⍝ rotation towards the right only elements that are note spaces
{⍉                   } ⍝ transpose back
```
[Try it online!](https://tio.run/##hZA9TsNAEIX7nOJ1roziKBVVuAJCol45Y@8KZ9caj/lRRBspEkZQ0HMDKhokGo6yFzG7NhFpkoy2Gb3vzZtZVVfp8kFVruz7AqH85gVr321/PjL/9L1YJ0j89t13n48L330FwW9eYzcRupeBTi5QGUu4M6KxckwQrSxukGvFKhfi5iwZKGdL4lPwyDbasQxo7C@dKCFoYjpHOtRtmgbhSpsG4cXRIOvaUkd@T7FO9oRrVnVtAqvYtXYJcSGfUBhudmkT//w23jUGgcfw2TRsnLuqXdm/Ff7R2RQF4occMiML8w@YkZ0wz48kz3fJff8L "APL (Dyalog Unicode) – Try It Online")
[Answer]
# 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](https://data.stackexchange.com/stackoverflow/query/1031912/rotate-a-column)** ungolfed version
]