Come le corde sono contorte

L'algoritmo di torsione è molto semplice. Ogni colonna viene spostata verso il basso dal suo indice (col 0 si sposta in basso 0, col 1 si sposta 1, ...). Lo spostamento della colonna si sposta verso l'alto. Funziona così:

aaaa
bbbb
cccc

diventa:

a
ba
cba
----
 cba
  cb
   c

Con tutto sotto la linea che si avvolge verso l'alto. Vero esempio:

Original:
\\\\\\\\\\\\
............
............
............

Twisted:
\...\...\...
.\...\...\..
..\...\...\.
...\...\...\

Ingresso

L'input è una matrice di stringhe o una stringa a più righe. Tutte le linee hanno la stessa lunghezza.

Produzione

La stringa attorcigliata, uscita multilinea su std-out (o alternativa più vicina).

Esempi:

( >indica input, lo spazio finale è importante)

>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

Brachylog , 5 byte

iᵇ↻₎ᵐ

Provalo online!

Ottiene l'input come una matrice di colonne (che sembra rientrare nelle specifiche della domanda).

iᵇ- Per ogni elemento dell'array, abbinalo al suo indice (basato su 0)
ᵐ - associa questo predicato a ciascun elemento del risultato:
↻₎- permuta (la colonna) circolarmente per la quantità specificata come ultimo elemento (l'indice)

Esteso facilmente a una versione che accetta una singola stringa multilinea:

13 byte

ṇẹ\iᵇ↻₎ᵐ\cᵐ~ṇ

Provalo online!

Pyth, 11

jC.>R~hZC.z

Provalo qui

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

APL (Dyalog) , 7 byte

⊖⊖⊖⍨⍬⍋⍉

Richiede ⎕io←0

Provalo online!

⍬⍋⍉ottiene l'intervallo da 0 al numero di colonne
⊖inverte
⊖⊖⍨⍬⍋⍉ruotando verticalmente (verticalmente) l'input (verticalmente) invertito 0,1..
⊖invertendolo e restituendolo.

Retina , 111 101 92 87 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

(?<=((.))*)(?=(?<1>.*¶)*.*(?<=(?=(?<-2>.)*(.))(?<-1>.+¶)*.*(.(?<=^(?<-1>¶?.+)*))*)).
$3

Woo, risolto in una singola sostituzione regex. :) (Probabilmente c'è una soluzione più breve usando diversi, ma dov'è il divertimento in questo ...)

Provalo online!

Spiegazione

Ciò richiede alcune conoscenze di base sui gruppi di bilanciamento . In breve, il sapore regex di .NET ti consente di catturare più volte con un singolo gruppo, spingendo tutte le acquisizioni su uno stack. Lo stack può anche essere estratto, il che ci consente di usarlo per contare le cose all'interno della regex.

(?<=((.))*)

Questo spinge una cattura su entrambi i gruppi 1e 2per ogni personaggio davanti alla partita (nella riga corrente). Cioè, conta la posizione orizzontale della partita.

Il resto è in uno sguardo:

(?=(?<1>.*¶)*.* [...] )

Abbiniamo ciascuna linea e la spingiamo anche sul gruppo 1, in modo tale che il gruppo 1sia ora la somma della posizione orizzontale e verticale (dove quest'ultima viene contata dal basso ). Questo essenzialmente identifica le diagonali della griglia con valori crescenti a partire dall'angolo in basso a sinistra. Questo .*sposta quindi il cursore del motore alla fine della stringa.

Passiamo ora a un lookbehind, che è abbinato da destra a sinistra in .NET:

(?<= [...] (.(?<=^(?<-1>¶?.+)*))*)

Questo pop-up ripetutamente Hcatture esattamente dal gruppo 1(dov'è Hl'altezza dell'input). Lo scopo è quello di prendere il gruppo modulo H. Successivamente, il gruppo 1contiene la riga (contata dal basso) da cui scegliere il nuovo carattere nella colonna corrente.

(?=(?<-2>.)*(.))(?<-1>.+¶)*.*

Un altro aspetto dietro, sempre a partire da destra. (?<-1>.+¶)*.+ora usa group 1per trovare la riga da cui scegliere il nuovo personaggio e quindi il lookahead trova la colonna corretta usando group 2.

Il personaggio desiderato viene catturato in gruppo 3e riscritto dalla sostituzione.

CJam, 13 byte

qN/zee::m>zN*

Provalo qui.

Spiegazione

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.

TeaScript, 10 byte

xHl@C(r╢tD

Grazie alla sintassi estremamente concisa di TeaScript 3, questo è davvero breve: D

Sarebbe più corto di 1 byte se il loop Sigma non fosse difettoso

Provalo online

Spiegazione

      // Implicit, x = input
xH    // Transpose input
l@    // Loop
 C(r╢   // Cycle column by index
        // `╢` exits loop
t    // Transpose
D    // Join on \n

Python 3, 164 byte

Non la migliore risposta da un colpo lungo, ma la prima 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)]))

MATLAB, 92 36 byte

s=bsxfun(@circshift,s,0:size(s,2)-1)

Supponendo che la stringa di input ssia già sotto forma di matrice / matrice di caratteri 2D, ad es

s = ['abcdefg';'.......'];
s = ['\\\\.....././';'...../.......';'........././.';'..../.^\\....'];

Spiegazione: scorrere le colonne della matrice. Per ogni colonna eseguire uno spostamento circolare dei suoi elementi per il numero di caratteri che è uguale all'indice di colonna (-1 a causa dell'indicizzazione MATLAB).

Brachylog , 96 byte

$\: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&;}

Questo si aspetta un elenco di stringhe di codici di caratteri come input e nessun output, ad es brachylog_main([`aaaa`,`bbbb`,`cccc`],_).

Questa è una risposta ridicolmente lunga, e probabilmente c'è un modo molto più breve per farlo.

Spiegazione

§ 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

JavaScript, 92 89 byte

3 byte di sconto grazie @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>

Python 2, 115 byte

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

Grazie alla meraviglia di essere zipriuscito a ottenere questo in una riga. Guardalo in azione qui .

MATL , 18 21 byte

Zy2):"G@Z)@qYS]N$h

L'input è nella forma

['Hello, world!'; 'I am another '; 'string to be '; 'twisted!']

Provalo online!

Come funziona :

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

F #, 105 byte

La mia prima pugnalata ( \nè richiesto solo un personaggio):

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

Uso:

f [| @"\\\\\\\\\\\\"
     "............"
     "............"
     "............" |]

JavaScript (ES6), 73 byte

t=>t.replace(/./g,(_,i)=>t[(i+s*l-i%l*l)%s],l=t.search`
`+1,s=t.length+1)

Spiegazione

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>

Japt, 29 byte

Uy £XsV=(Y*Xl -Y %Xl)+X¯V}R y

Provalo online!

Come funziona

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

Haskell, 81 byte

let t=transpose in t.snd.mapAccumR(\c l -> 1+c,take(length l)(drop c$cycle l))0.t

reimplementazione dell'esempio CJam, sebbene il contrario, map ed enumerate facciano parte di mapAccumR, lo snd rimuove l'accumulatore poiché non ne abbiamo più bisogno, l'inversione è solo un effetto collaterale della piega a destra.

Haskell, 65 byte

g l@("":_)=l;g l|t<-tail<$>l=zipWith(:)(head<$>l)$g$last t:init t

Esempio di utilizzo: g ["1111","2222","3333"]-> ["1321","2132","3213"].

MATL , 9 byte

"@X@qYS&h

Provalo online!

Abbastanza simile nel nucleo alla risposta MATL esistente di Luis Mendo , ma più breve usando funzioni che probabilmente non erano nella lingua a quel punto: 1. "scorre ora automaticamente le colonne di una matrice, quindi nessuna attività costosa di costruzione di indici di colonna e indicizzazione in essi ( questo è il problema), 2. &hcome un modo abbreviato per dire N$h, e 3. fine del ciclo implicito se ]non specificato.

In alternativa, per lo stesso conteggio parziale:

tsn:ql&YS

Provalo su MATL online

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

C (clang) , 114 byte

Funziona in GCC sotto MinGW. Il GCC di TIO viene confuso usando strlennell'espressione init del primo per il ciclo.

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);}

Provalo online!