[Question]
  [
## How strings are twisted
The twisting algorithm is very simple. Each column is shifted down by its index (col 0 moves down 0, col 1 moves 1, ...). The column shift wraps to the top. It works like this:
```
aaaa
bbbb
cccc
```
Becomes:
```
a
ba
cba
----
 cba
  cb
   c
```
With everything under the line wrapping to the top. Real example:
```
Original:
\\\\\\\\\\\\
............
............
............
Twisted:
\...\...\...
.\...\...\..
..\...\...\.
...\...\...\
```
## Input
Input is either an array of strings, or a multi-line string. All lines have the same length.
## Output
The twisted string, multi-line output to std-out (or closest alternative).
## Examples:
(`>` denotes input, trailing space is important)
```
>Hello, world!
>I am another 
>string to be 
>twisted!     
Hwrmoe oo br!
Ieii ,dttr e 
s lsna !ohl  
ttaltgnw  ed 
>\\\\\\\\\\\\
>............
>............
>............
\...\...\...
.\...\...\..
..\...\...\.
...\...\...\
>abcdefg
>.......
a.c.e.g
.b.d.f.
>abcdefghij
>..........
>..........
a..d..g..j
.b..e..h..
..c..f..i.
>\\\\.....././
>...../.......
>........././.
>..../.^\\....
\.........../
.\....^..../.
..\../.\../..
...\/...\/...
>cdeab
>deabc
>eabcd
>abcde
cbbbb
ddccc
eeedd
aaaae
>aeimquy37
>bfjnrvz48
>cgkosw159
>dhlptx260
ahknqx147
beloru258
cfipsvy69
dgjmtwz30
>abcdefghi
>jklmnopqr
>stuvwxyz1
>234567890
a3ume7yqi
jb4vnf8zr
skc5wog91
2tld6xph0
```
  
[Answer]
# Pyth, 11
```
jC.>R~hZC.z
```
[Try it here](http://pyth.herokuapp.com/?code=jC.%3ER~hZC.z&input=%5C%5C%5C%5C......%2F.%2F%0A.....%2F.......%0A.........%2F.%2F.%0A....%2F.%5E%5C%5C....&debug=0)
```
jC.>R~hZC.z    ##  implicit: .z = list of input split by lines
        C.z    ##  transpose .z to get columns
  .>R~hZ       ##  shift each column by it's index
               ##  equivalent to .e.>bk
jC             ##  transpose back and join by newlines
```
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 7 bytes
```
⊖⊖⊖⍨⍬⍋⍉
```
Requires `⎕io←0`
[Try it online!](https://tio.run/##hVBLboMwEN3nFM7KmxTIP7lLFclgAyYGE@OEkANEaiuqdtGeoYueyheh49AooEbqyPKb5zfzPDbJxQOtiJBRY14/uDTnN68JYTfPn7@r/jL1t6lfTP3UNCEy53ccMyHkCJVSCTrECHNEUkQyqWOmEPBCK55FSEvkM8t1yQvN6BDZwAOMB63PYyegzOnEP/TmQfyAsjC6FfzVYp70@vukP0576Drutci90wTylbvOpm3q@MClxAfdQgBogQJexumOx3i621fTJWh@mGTqcJqtIA@irSzK8XxtPWKR6@Nk4d17FujJVqSZzHfq8u37Q3msTmPIJ9PZfLFcrT38Aw "APL (Dyalog Unicode) – Try It Online")
`⍬⍋⍉` gets the range from 0 to the number of columns  
`⊖` reverses vertically  
`⊖⊖⍨⍬⍋⍉` rotate (vertically) the (vertically) reversed input by `0,1..`  
`⊖` reverse that, and return it.
[Answer]
## [Retina](https://github.com/mbuettner/retina/), ~~111~~ ~~101~~ ~~92~~ 87 bytes
Byte count assumes ISO 8859-1 encoding.
```
(?<=((.))*)(?=(?<1>.*¶)*.*(?<=(?=(?<-2>.)*(.))(?<-1>.+¶)*.*(.(?<=^(?<-1>¶?.+)*))*)).
$3
```
Woo, solved it in a single regex substitution. :) (Chances are, there's a shorter solution by using several, but where's the fun in that...)
[Try it online!](http://retina.tryitonline.net/#code=KD88PSgoLikpKikoPz0oPzwxPi4qwrYpKi4qKD88PSg_PSg_PC0yPi4pKiguKSkoPzwtMT4uK8K2KSouKiguKD88PV4oPzwtMT7Ctj8uKykqKSkqKSkuCiQz&input=SGVsbG8sIHdvcmxkIQpJIGFtIGFub3RoZXIgCnN0cmluZyB0byBiZSAKdHdpc3RlZCEgICAgIA&debug=on)
### Explanation
This requires some basic knowledge of [balancing groups](https://stackoverflow.com/a/17004406/1633117). In short, .NET's regex flavour allows you to capture multiple times with a single group, pushing all captures onto a stack. That stack can also be popped from, which allows us to use it for counting things inside the regex.
```
(?<=((.))*)
```
This pushes one capture onto both groups `1` and `2` for each character in front of the match (in the current line). That is, it counts the horizontal position of the match.
The rest is in a lookahead:
```
(?=(?<1>.*¶)*.* [...] )
```
We match each line and *also* push it onto group `1`, such that group `1` is now the sum of the horizontal and vertical position (where the latter is counted *from the bottom*). This essentially labels the diagonals of the grid with increasing values starting from the bottom left corner. That `.*` then just moves the engine's cursor to the end of the string.
We now switch into a lookbehind, which is matched from right to left in .NET:
```
(?<= [...] (.(?<=^(?<-1>¶?.+)*))*)
```
This will repeatedly pop exactly `H` captures from group `1` (where `H` is the height of the input). The purpose of that is to take the group modulo `H`. Afterwards, group `1` contains the row (counted from the bottom) from which to pick the new character in the current column.
```
(?=(?<-2>.)*(.))(?<-1>.+¶)*.*
```
Another lookbehind, again starting from the right. `(?<-1>.+¶)*.+` now uses group `1` to find the row from which to pick the new character and then the lookahead finds the correct column using group `2`.
The desired character is captured into group `3` and written back by the substitution.
[Answer]
## CJam, 13 bytes
```
qN/zee::m>zN*
```
[Test it here.](http://cjam.aditsu.net/#code=qN%2Fzee%3A%3Am%3EzN*&input=Hello%2C%20world!%0AI%20am%20another%20%0Astring%20to%20be%20%0Atwisted!%20%20%20%20%20)
### Explanation
```
q    e# Read all input.
N/   e# Split into lines.
z    e# Transpose to get an array of columns.
ee   e# Enumerate, pairing each column with its index.
::m> e# Map: fold: rotate (cyclically shifting each column by its index).
z    e# Transpose again.
N*   e# Join with linefeeds.
```
[Answer]
# TeaScript, 10 bytes
```
xHl@C(r╢tD
```
Thanks to TeaScript 3's extremely concise syntax, this is *really* short :D
Would be 1-byte shorter if Sigma loop weren't buggy
[Try it online](http://vihan.org/p/TeaScript/#?code=%22xHl@C(r))tD%22&inputs=%5B%22%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5C%5Cn............%5Cn............%5Cn............%22%5D&opts=%7B%22int%22:false,%22ar%22:false,%22debug%22:false%7D)
## Explanation
```
      // Implicit, x = input
xH    // Transpose input
l@    // Loop
 C(r╢   // Cycle column by index
        // `╢` exits loop
t    // Transpose
D    // Join on \n
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 4 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
yÈéY
```
[Try it here](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=ecjpWQ&input=IlxcXFxcXFxcXFxcXAouLi4uLi4uLi4uLi4KLi4uLi4uLi4uLi4uCi4uLi4uLi4uLi4uLiI)
[Answer]
# Python 3, 164 bytes
Not the best answer by a long shot, but the first in Python...
```
s=list(zip(*open(0).readlines()))[:-1]
r=[[s[i][(j-i)%len(s[i])] for j in range(len(s[i]))] for i in range(len(s))]
print('\n'.join([''.join(l) for l in zip(*r)]))
```
[Answer]
# MATLAB, ~~92~~ 36 bytes
```
s=bsxfun(@circshift,s,0:size(s,2)-1)
```
Assuming that the input string `s` is already in the form of a 2D char array/ matrix, e.g.
```
s = ['abcdefg';'.......'];
s = ['\\\\.....././';'...../.......';'........././.';'..../.^\\....'];
```
Explanation: iterate through the columns of the matrix. For each column perform a circular shift of its elements by the number of characters that equals the column index (-1 because of MATLAB indexing).
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 5 bytes
```
iᵇ↻₎ᵐ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/P/Ph1vZHbbsfNfU93Drh//9opcSkZCUdBSxU7P8oAA "Brachylog – Try It Online")
Gets input as an array of columns (which seems to be within the question's specifications). 
`iᵇ` - For each element in the array, pair it with its (0-based) index  
`ᵐ` - map this predicate to each element of the result:  
`↻₎` - permute (the column) circularly by the amount specified as the last element (the index)
Easily extended to a version that accepts a single multiline string:
### 13 bytes
```
ṇẹ\iᵇ↻₎ᵐ\cᵐ~ṇ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//@HO9oe7dsZkPtza/qht96OmvodbJ8QkA4k6oMz//0qJSckpqWnpGZlcWdk5uXn5BYVFXMUlpWXlFZVVhlxGxiamZuYWlgZK/6MA "Brachylog – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 96 bytes
```
$\:0{h_.|[M:I]hh:I{bh0,?h.|[C:I]h$)D,I-1=:Dr:2&.}C,I+1=J,Mb:J:1&:[C]rc.}$\{hA,[A]:"~s
"w,?b:3&;}
```
This expects a list of character codes strings as input and no output, e.g. `brachylog_main([`aaaa`,`bbbb`,`cccc`],_).`
That's one ridiculously long answer, and there's probably a much shorter way to do it.
### Explanation
```
§ Main Predicate
$\:0{}$\{}                            § Create a list containing the transposed input and 0
                                      § Call sub-predicate 1 with this list as input
                                      § Transpose its output and pass it as input to
                                      § sub-predicate 3
§ Sub-predicate 1
h_.                                   § If the matrix is empty, output is empty list
   |                                  § Else
    [M:I]hh:I{}C,                     § Input is [M,I], call sub-predicate 2 with the first
                                      § line of M and I as input. Its output is C.
                 I+1=J,Mb:J:1&        § Call sub-predicate 1 with M minus the first line
                                      § and I+1 as input
                              :[C]rc. § Its output is appended after C, which is then
                                      § unified with the output of sub-predicate 1.
§ Sub-predicate 2
bh0,?h.                               § If the second element of the input list is 0,
                                      § output is the first element of the input
       |                              § Else
        [C:I]                         § Input is [C,I]
             h$)D,                    § Perform a circular permutation of C from left to
                                      § right (e.g. [a,b,c] => [c,a,b]) and unify it with D
                  I-1=:Dr:2&.         § Call sub-predicate 2 with D and I-1 as input, unify
                                      § its output with sub-predicate 2's output
§ Sub-predicate 3
hA,[A]:"~s\n"w,                       § Write the first line of the input as a char codes
                                      § string followed by a new line
               ?b:3&;                 § Call sub-predicate 3 with input minus the first
                                      § line. If it fails (empty input), terminate
```
[Answer]
# JavaScript, ~~92~~ 89 bytes
3 bytes off thanks [@Neil](https://codegolf.stackexchange.com/users/17602/neil).
```
s=>(z=s.split`
`).map((m,i)=>m.replace(/./g,(n,j)=>z[((l=z.length)*j+i-j)%l][j])).join`
`
```
```
f=s=>
    (z=s.split`\n`).map((m,i)=>
        m.replace(/./g,(n,j)=>
            z[((l=z.length)*j+i-j)%l][j]
        )
    ).join`\n`
Input.value = `abcdefghij
..........
..........`
```
```
textarea{display:block;width:250px;height:75px;}
```
```
<textarea id='Input'></textarea>
<button id='Run' onClick='Output.value=f(Input.value);'>Run</button>
<textarea id='Output'></textarea>
```
[Answer]
# Python 2, 115 bytes
```
lambda s:'\n'.join("".join(s)for s in zip(*[k[-i%len(k):]+k[:-i%len(k)]for i,k in enumerate(zip(*s.split('\n')))]))
```
Thanks to the wonder of `zip` managed to get this down to one line. See it in action [here](http://ideone.com/MOsH5r).
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 18 ~~21~~ bytes
```
Zy2):"G@Z)@qYS]N$h
```
Input is of the form
```
['Hello, world!'; 'I am another '; 'string to be '; 'twisted!']
```
[**Try it online!**](http://matl.tryitonline.net/#code=WnkyKToiR0BaKUBxWVNdTiRo&input=WydIZWxsbywgd29ybGQhJzsgJ0kgYW0gYW5vdGhlciAnOyAnc3RyaW5nIHRvIGJlICc7ICd0d2lzdGVkISdd)
**How it works**:
```
Zy       % implicitly take input: 2D char array. Get its size
2)       % second element from size vector: number of columns, say n
:        % create vector [1,2,...,n]
"        % for each element k in that vector
  G      %   push input
  @      %   push k
  Z)     %   k-th column from input
  @qYS   %   circularly shift k-1 positions
]        % end for loop
N$h      % concatenate all stack contents horizontally
         % implicitly display
```
[Answer]
# F#, 105 bytes
My first stab at it (only a `\n` character is required):
```
let m x y=(x%y+y)%y
let f(a:string[])=Array.mapi(fun i x->String.mapi(fun j _->a.[m(i-j)a.Length].[j])x)a
```
Usage:
```
f [| @"\\\\\\\\\\\\"
     "............"
     "............"
     "............" |]
```
[Answer]
# JavaScript (ES6), 73 bytes
```
t=>t.replace(/./g,(_,i)=>t[(i+s*l-i%l*l)%s],l=t.search`
`+1,s=t.length+1)
```
## Explanation
```
t=>
  t.replace(/./g,(_,i)=> // replace each character at index i
    t[                   // get the character at index:
      (i                 // start at i
        +s*l             // add s*l to ensure the result is always positive for %s
        -i%l*l           // move the index upwards the num of chars from start of the line
      )%s                // shift the index into the the range of s
    ],
    l=t.search`
`+1,                     // l = line length
    s=t.length+1         // s = input grid length (+1 for the missing newline at the end)
  )
```
## Test
```
var solution = t=>t.replace(/./g,(_,i)=>t[(i+s*l-i%l*l)%s],l=t.search`
`+1,s=t.length+1)
```
```
<textarea id="input" rows="5" cols="40">\\\\.....././
...../.......
........././.
..../.^\\....</textarea><br>
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>
```
[Answer]
# Japt, 29 bytes
```
Uy £XsV=(Y*Xl -Y %Xl)+X¯V}R y
```
[Test it online!](http://ethproductions.github.io/japt?v=master&code=VXkgo1hzVj0oWSpYbCAtWSAlWGwpK1ivVn1SIHk=&input=IlxcXFxcXFxcXFxcXAouLi4uLi4uLi4uLi4KLi4uLi4uLi4uLi4uCi4uLi4uLi4uLi4uLiI=)
### How it works
```
Uy        // Transpose rows and columns in the input string.
£     }R  // Map each item X and index Y in the result, split at newlines, to:
Y*Xl -Y   //  Take Y times X.length and subtract Y.
%Xl)      //  Modulate the result by X.length.
XsV=      //  Set V to the result of this, and slice off the first V chars of X.
+X¯V      //  Concatenate this with the first V chars of X.
y         // Transpose the result again.
          // Implicit: output last expression
```
[Answer]
# Haskell, 81 bytes
```
let t=transpose in t.snd.mapAccumR(\c l -> 1+c,take(length l)(drop c$cycle l))0.t
```
reimplementation of the CJam example, though the reverse, map and enumerate is part of the mapAccumR, the snd removes the accumulator since we don't need it anymore, the reversal is just a side effect of the right fold.
[Answer]
## Haskell, 65 bytes
```
g l@("":_)=l;g l|t<-tail<$>l=zipWith(:)(head<$>l)$g$last t:init t
```
Usage example: `g ["1111","2222","3333"]` -> `["1321","2132","3213"]`.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 10 bytes
```
Tzṙm→İ-T' 
```
[Try it online!](https://tio.run/##yygtzv7/P6Tq4c6ZuY/aJh3ZoBuirnBo2////z1Sc3LydRTK84tyUhS5PBUScxUS8/JLMlKLFLiKS4oy89IVSvIVklIVuErKM4tLUlMUAQ "Husk – Try It Online")
(there's a space at the end.)
## Explanation
```
Tzṙm→İ-T' 
       T'  transpose, padding with spaces
 zṙ        zip and rotate each column by
     İ-    negative integers
   m→      each incremented
T          transposed back
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 9 bytes
```
"@X@qYS&h
```
[Try it online!](https://tio.run/##y00syfn/X8khwqEwMlgt4///aHWP1JycfB2F8vyinBRFdWsFdU@FxFyFxLz8kozUIgWQQHFJUWZeukJJvkJSKligpDyzuCQVqDoWAA "MATL – Try It Online")
Pretty similar in core to Luis Mendo's [existing MATL answer](https://codegolf.stackexchange.com/a/70708/8774), but shorter by using features that were probably not in the language at that point: 1. `"` iterates through a matrix's columns automatically now, so no costly business of constructing column indices and indexing into them (this is the biggie), 2. `&h` as a shorthand way of saying `N$h`, and 3. implicit loop end if `]` is not specified.
Alternately, for the same bytecount:
```
tsn:ql&YS
```
[Try it on MATL Online](https://matl.io/?code=tsn%3Aql%26YS&inputs=%5B%27Hello%2C+world%21%27%3B+%27I+am+another+%27%3B+%27string+to+be+%27%3B+%27twisted%21%27%5D&version=20.9.2)
```
      &YS   % circularly shift the matrix
     l      % across rows (i.e. shift each column) by the amounts
            %  given by this array:
tsn         % duplicate input, get the sum of each column, get the 
            %  number of elements in that (which is the number of columns)
   :q       % construct range 1 to ncols, then decrement to start at 0
            % (implicit output)
```
[Answer]
# [C (clang)](http://clang.llvm.org/), 114 bytes
Works in GCC under MinGW. TIO's GCC gets confused by using `strlen` in the init expression of the first for loop.
```
f(L,n)char**L;{for(int l=strlen(*L),i=0,j,c;i<n;i++)for(j=c=0;j<=l;j++,c=c?c-1:n-1)putchar(l^j?L[(c+i)%n][j]:10);}
```
[Try it online!](https://tio.run/##jZDRasMgFIavk6c4DQw06kjKrmqltxvkDbIMMmtaxeowjl6UPHsWl8F6M9jvld85fHqOZNL27jTPA2qow/Lch7Js@G3wAWkXwYoxBqscKhtMtaiooZLrveOaEJyajJCi4mYvLDeEUCnkQbJ651iNPz5j8iH7Zg5NiyTR@MF1rel2dYX5NCf/pdcO4fyWZ6kVyqjGWLcdCFhQVjwraz2Fqw/2uCloQi/QX6B3Pp5VgBUtX9TuBNHDu/pB8arHqI4bSCkmfu/f/vpf/8gqebzLv0h6J8uXM6DvQSg84QUtixhRwRgr0m2tbdfaNH8B "C (clang) – Try It Online")
]