Làm thế nào dây được xoắn

Thuật toán xoắn rất đơn giản. Mỗi cột được dịch chuyển xuống theo chỉ số của nó (col 0 di chuyển xuống 0, col 1 di chuyển 1, ...). Sự thay đổi cột kết thúc tốt đẹp lên đầu. Nó hoạt động như thế này:

aaaa
bbbb
cccc

Trở thành:

a
ba
cba
----
 cba
  cb
   c

Với tất cả mọi thứ dưới dòng bọc lên đầu. Ví dụ thực tế:

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

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

Đầu vào

Đầu vào là một chuỗi các chuỗi hoặc một chuỗi nhiều dòng. Tất cả các dòng có cùng chiều dài.

Đầu ra

Chuỗi xoắn, đầu ra đa dòng thành std-out (hoặc thay thế gần nhất).

Ví dụ:

( >biểu thị đầu vào, dấu cách là quan trọng)

>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ᵇ↻₎ᵐ

Hãy thử trực tuyến!

Nhận đầu vào dưới dạng một mảng các cột (dường như nằm trong thông số kỹ thuật của câu hỏi).

iᵇ- Đối với mỗi phần tử trong mảng, hãy ghép nó với chỉ mục (dựa trên 0) của nó
ᵐ - ánh xạ vị từ này đến từng phần tử của kết quả:
↻₎- permute (cột) theo số lượng được chỉ định làm phần tử cuối cùng (chỉ mục)

Dễ dàng mở rộng thành phiên bản chấp nhận một chuỗi nhiều dòng:

13 byte

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

Hãy thử trực tuyến!

Bình thường, 11

jC.>R~hZC.z

Hãy thử nó ở đây

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

⊖⊖⊖⍨⍬⍋⍉

Đòi hỏi ⎕io←0

Hãy thử trực tuyến!

⍬⍋⍉lấy phạm vi từ 0 đến số cột
⊖đảo ngược theo chiều dọc
⊖⊖⍨⍬⍋⍉(theo chiều dọc) đầu vào đảo ngược (theo chiều dọc) bằng cách 0,1..
⊖đảo ngược và trả lại.

Võng mạc , 111 101 92 87 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Woo, đã giải quyết nó trong một thay thế regex duy nhất. :) (Có thể có một giải pháp ngắn hơn bằng cách sử dụng một số, nhưng đâu là niềm vui trong đó ...)

Hãy thử trực tuyến!

Giải trình

Điều này đòi hỏi một số kiến ​​thức cơ bản về các nhóm cân bằng . Nói tóm lại, hương vị regex của .NET cho phép bạn chụp nhiều lần với một nhóm, đẩy tất cả các ảnh chụp lên một ngăn xếp. Ngăn xếp đó cũng có thể được bật ra, cho phép chúng ta sử dụng nó để đếm những thứ bên trong regex.

(?<=((.))*)

Điều này đẩy một lần chụp vào cả hai nhóm 1và 2cho mỗi nhân vật ở phía trước trận đấu (trong dòng hiện tại). Đó là, nó đếm vị trí ngang của trận đấu.

Phần còn lại là trong một cái nhìn:

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

Chúng tôi khớp từng dòng và cũng đẩy nó vào nhóm 1, sao cho nhóm đó 1bây giờ là tổng của vị trí ngang và dọc (trong đó cái sau được tính từ dưới cùng ). Điều này về cơ bản gắn nhãn các đường chéo của lưới với các giá trị tăng dần bắt đầu từ góc dưới bên trái. Điều .*đó sau đó chỉ cần di chuyển con trỏ của động cơ đến cuối chuỗi.

Bây giờ chúng ta chuyển sang một giao diện, được khớp từ phải sang trái trong .NET:

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

Điều này sẽ liên tục bật chính xác các Hảnh chụp từ nhóm 1( Hchiều cao của đầu vào). Mục đích của việc đó là lấy modulo nhóm H. Sau đó, nhóm 1chứa hàng (được tính từ dưới cùng) để chọn ký tự mới trong cột hiện tại.

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

Một cái nhìn khác, một lần nữa bắt đầu từ bên phải. (?<-1>.+¶)*.+bây giờ sử dụng nhóm 1để tìm hàng từ đó chọn ký tự mới và sau đó giao diện tìm cột chính xác bằng nhóm 2.

Nhân vật mong muốn được bắt vào nhóm 3và viết lại bằng cách thay thế.

CJam, 13 byte

qN/zee::m>zN*

Kiểm tra nó ở đây.

Giải trình

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

Nhờ cú pháp cực kỳ súc tích của TeaScript 3, đây là thực sự ngắn: D

Sẽ ngắn hơn 1 byte nếu vòng lặp Sigma không có lỗi

Dùng thử trực tuyến

Giải trình

      // 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

Không phải là câu trả lời hay nhất bằng một cú sút xa, mà là câu đầu tiên trong 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)

Giả sử rằng chuỗi đầu vào sđã ở dạng mảng / ma trận 2D, vd

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

Giải thích: lặp qua các cột của ma trận. Đối với mỗi cột thực hiện dịch chuyển vòng tròn các phần tử của nó theo số lượng ký tự bằng chỉ số cột (-1 vì lập chỉ mục 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&;}

Điều này mong đợi một danh sách các chuỗi mã ký tự là đầu vào và không có đầu ra, ví dụ: brachylog_main([`aaaa`,`bbbb`,`cccc`],_).

Đó là một câu trả lời dài đến nực cười, và có lẽ có một cách ngắn hơn để làm điều đó.

Giải trình

§ 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

Tắt 3 byte cảm ơn @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')))]))

Nhờ vào sự tuyệt vời của zipquản lý để có được điều này xuống một dòng. Xem nó trong hành động ở đây .

MATL , 18 21 byte

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

Đầu vào có dạng

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

Hãy thử trực tuyến!

Cách thức hoạt động :

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

Cú đâm đầu tiên của tôi vào nó (chỉ cần một \nnhân vật):

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

Sử dụng:

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)

Giải trình

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

Kiểm tra

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

Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

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

triển khai lại ví dụ của CJam, mặc dù ngược lại, ánh xạ và liệt kê là một phần của mapAccumR, snd loại bỏ bộ tích lũy vì chúng ta không cần nó nữa, đảo ngược chỉ là tác dụng phụ của nếp gấp bên phải.

Haskell, 65 byte

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

Ví dụ sử dụng: g ["1111","2222","3333"]-> ["1321","2132","3213"].

MATL , 9 byte

"@X@qYS&h

Hãy thử trực tuyến!

Cốt lõi khá giống với câu trả lời MATL hiện có của Luis Mendo , nhưng ngắn hơn bằng cách sử dụng các tính năng có thể không có trong ngôn ngữ tại thời điểm đó: 1. "lặp đi lặp lại qua các cột của ma trận, do đó không tốn kém khi xây dựng các chỉ mục cột và lập chỉ mục cho chúng ( đây là vấn đề lớn), 2. &hnhư một cách nói ngắn gọn N$hvà 3. kết thúc vòng lặp ngầm định nếu ]không được chỉ định.

Thay phiên, cho cùng một bytecount:

tsn:ql&YS

Dùng thử trên 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 (tiếng kêu) , 114 byte

Hoạt động trong GCC theo MinGW. GCC của TIO bị nhầm lẫn bằng cách sử dụng strlentrong biểu thức init của vòng lặp for đầu tiên.

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

Hãy thử trực tuyến!