วิธีการที่สตริงจะบิด

อัลกอริทึมการบิดนั้นง่ายมาก แต่ละคอลัมน์ถูกเลื่อนลงโดยดัชนี (คอลัมน์ 0 เคลื่อนลง 0, คอลัมน์ 1 เลื่อน 1, ... ) การเปลี่ยนคอลัมน์ล้อมรอบด้านบน มันทำงานได้เช่นนี้:

aaaa
bbbb
cccc

กลายเป็น:

a
ba
cba
----
 cba
  cb
   c

พร้อมทุกอย่างภายใต้การตัดบรรทัดไปด้านบน ตัวอย่างจริง:

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

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

อินพุต

อินพุตเป็นอาร์เรย์ของสตริงหรือสตริงหลายบรรทัด ทุกบรรทัดมีความยาวเท่ากัน

เอาท์พุต

สตริงบิดออกหลายบรรทัดไปยัง std-out (หรือทางเลือกที่ใกล้เคียงที่สุด)

ตัวอย่าง:

( >หมายถึงอินพุตพื้นที่ต่อท้ายเป็นสิ่งสำคัญ)

>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 ไบต์

iᵇ↻₎ᵐ

ลองออนไลน์!

รับอินพุตเป็นอาร์เรย์ของคอลัมน์ (ซึ่งดูเหมือนจะอยู่ในข้อกำหนดของคำถาม)

iᵇ- สำหรับแต่ละองค์ประกอบในอาร์เรย์ให้จับคู่กับดัชนี (อิง 0)
ᵐ - แมปเพรดิเคตนี้กับแต่ละองค์ประกอบของผลลัพธ์:
↻₎- เรียงสับเปลี่ยน (คอลัมน์) เป็นวงกลมตามจำนวนที่ระบุเป็นองค์ประกอบสุดท้าย (ดัชนี)

ขยายไปสู่เวอร์ชันที่ยอมรับสตริงหลายบรรทัดได้อย่างง่ายดาย:

13 ไบต์

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

ลองออนไลน์!

Pyth, 11

jC.>R~hZC.z

ลองที่นี่

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 ไบต์

⊖⊖⊖⍨⍬⍋⍉

ต้องใช้ ⎕io←0

ลองออนไลน์!

⍬⍋⍉รับช่วงจาก 0 ถึงจำนวนคอลัมน์ที่หมุน
⊖กลับในแนว
⊖⊖⍨⍬⍋⍉ตั้ง (แนวตั้ง) อินพุต (แนวตั้ง) ย้อนกลับโดย0,1..
⊖ย้อนกลับนั้นและส่งคืน

เรติน่า , 111 101 92 87 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

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

Woo แก้ไขมันด้วยการทดแทน regex เดียว :) (โอกาสคือมีวิธีแก้ปัญหาที่สั้นกว่าโดยใช้หลายอย่าง แต่ความสนุกอยู่ตรงไหน ... )

ลองออนไลน์!

คำอธิบาย

สิ่งนี้ต้องการความรู้พื้นฐานเกี่ยวกับการสร้างสมดุลของกลุ่มกลุ่มสมดุลกล่าวโดยสรุปแล้ว regex รสของ. NET ช่วยให้คุณสามารถจับภาพหลายครั้งกับกลุ่มเดียวผลักดันการจับทั้งหมดลงบนสแต็ก สแต็กนั้นยังสามารถโผล่ออกมาจากซึ่งช่วยให้เราสามารถใช้สำหรับการนับสิ่งต่าง ๆ ภายใน regex

(?<=((.))*)

นี่เป็นการผลักหนึ่งการจับภาพไปยังทั้งสองกลุ่ม 1และ2สำหรับแต่ละอักขระที่อยู่ด้านหน้าของการแข่งขัน (ในบรรทัดปัจจุบัน) นั่นคือมันนับตำแหน่งแนวนอนของการแข่งขัน

ส่วนที่เหลืออยู่ใน lookahead:

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

เราจับคู่แต่ละบรรทัดและยังผลักดันมันลงบนกลุ่ม1เช่นกลุ่มที่1อยู่ในขณะนี้ผลรวมของตำแหน่งในแนวนอนและแนวตั้ง (ที่หลังจะถูกนับจากด้านล่าง ) สิ่งนี้จะติดป้าย diagonals ของกริดด้วยค่าที่เพิ่มขึ้นโดยเริ่มจากมุมล่างซ้าย ว่า.*แล้วก็ย้ายเคอร์เซอร์ของเครื่องยนต์ไปยังจุดสิ้นสุดของสตริง

ตอนนี้เราเปลี่ยนเป็น lookbehind ซึ่งจับคู่จากขวาไปซ้ายใน. NET:

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

นี้จะปรากฏขึ้นซ้ำ ๆ กันHจับจากกลุ่ม1(ซึ่งHเป็นความสูงของอินพุต) Hวัตถุประสงค์ของการที่จะนำกลุ่มโมดูโล หลังจากนั้นกลุ่มจะ1มีแถว (นับจากด้านล่าง) เพื่อเลือกอักขระใหม่ในคอลัมน์ปัจจุบัน

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

มองอีกด้านหลังเริ่มจากด้านขวาอีกครั้ง (?<-1>.+¶)*.+ตอนนี้ใช้กลุ่ม1ที่จะหาแถวที่จะเลือกตัวละครใหม่แล้ว lookahead 2พบคอลัมน์ที่ถูกต้องโดยใช้กลุ่ม

ตัวละครที่ต้องการถูกจับเป็นกลุ่ม3และเขียนโดยการทดแทน

CJam, 13 ไบต์

qN/zee::m>zN*

ทดสอบที่นี่

คำอธิบาย

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 ไบต์

xHl@C(r╢tD

ต้องขอบคุณไวยากรณ์ที่รัดกุมอย่างมากของ TeaScript 3 ซึ่งสั้นมากๆ : D

จะสั้นลง 1 ไบต์หาก Sigma loop ไม่ได้บั๊ก

ลองออนไลน์

คำอธิบาย

      // 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 ไบต์

ไม่ใช่คำตอบที่ดีที่สุดในระยะยาว แต่เป็นคำตอบแรกใน 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 ไบต์

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

สมมติว่าสตริงอินพุตsนั้นอยู่ในรูปของอาร์เรย์ char / เมทริกซ์ 2D อยู่แล้วเช่น

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

คำอธิบาย: วนซ้ำผ่านคอลัมน์ของเมทริกซ์ สำหรับแต่ละคอลัมน์ดำเนินการเลื่อนแบบวงกลมขององค์ประกอบตามจำนวนอักขระที่เท่ากับดัชนีคอลัมน์ (-1 เนื่องจากการทำดัชนี MATLAB)

Brachylogขนาด 96 ไบต์

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

สิ่งนี้คาดว่าจะมีรายการของสตริงรหัสอักขระเป็นอินพุตและไม่มีเอาต์พุตเช่น brachylog_main([`aaaa`,`bbbb`,`cccc`],_).

นั่นเป็นคำตอบที่เยิ่นเย้อและอาจเป็นวิธีที่สั้นกว่ามาก

คำอธิบาย

§ 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 ไบต์

3 ไบต์ปิดขอบคุณ@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 ไบต์

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

ขอบคุณความมหัศจรรย์ของzipการจัดการเพื่อให้ได้ลงหนึ่งบรรทัด เห็นในการกระทำที่นี่

MATL , 18 21ไบต์

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

อินพุตเป็นของฟอร์ม

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

ลองออนไลน์!

มันทำงานอย่างไร :

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 ไบต์

แทงครั้งแรกของฉันที่มัน ( \nจำเป็นต้องมีตัวละครเท่านั้น):

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

การใช้งาน:

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

JavaScript (ES6), 73 ไบต์

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

คำอธิบาย

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

ทดสอบ

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 ไบต์

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

ทดสอบออนไลน์!

มันทำงานอย่างไร

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 ไบต์

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

การปรับใช้ตัวอย่าง CJam ซ้ำอีกครั้งแม้ว่า reverse, map และ enumerate เป็นส่วนหนึ่งของ mapAccumR แต่ snd จะลบตัวสะสมเนื่องจากเราไม่ต้องการอีกต่อไปการกลับเป็นเพียงผลข้างเคียงของการพับด้านขวา

Haskell, 65 ไบต์

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

ตัวอย่างการใช้งาน: ->g ["1111","2222","3333"]["1321","2132","3213"]

MATL , 9 ไบต์

"@X@qYS&h

ลองออนไลน์!

ค่อนข้างคล้ายคลึงกันในแกนกลางกับคำตอบที่มีอยู่ของ Luis Mendo แต่สั้นลงโดยใช้คุณลักษณะที่อาจไม่ได้อยู่ในภาษานั้น: 1. "วนซ้ำผ่านคอลัมน์ของเมทริกซ์โดยอัตโนมัติในขณะนี้ดังนั้นจึงไม่มีค่าใช้จ่ายในการสร้างดัชนีคอลัมน์ นี่คือตัวใหญ่), 2. &hเป็นวิธีจดชวเลขN$hและ 3. ลูปสิ้นสุดโดยนัยถ้า]ไม่ได้ระบุไว้

อีกทางเลือกสำหรับ bytecount เดียวกัน:

tsn:ql&YS

ลองใช้กับ 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 (เสียงดังกราว) , 114 ไบต์

ทำงานใน GCC ภายใต้ MinGW GCC ของ TIO สับสนโดยใช้strlenในนิพจน์ init ของลูปแรก

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

ลองออนไลน์!