บทนำ

แผนที่ของเบเกอร์เป็นระบบพลังสำคัญที่แสดงพฤติกรรมวุ่นวาย มันเป็นฟังก์ชั่นจากตารางหน่วยเพื่อกำหนดตัวเองอย่างสังหรณ์ใจดังนี้

• 0.5×1ตัดตารางในแนวตั้งในช่วงครึ่งปีที่เกิดขึ้นในสองรูปสี่เหลี่ยมขนาด
• สแต็คครึ่งขวาที่ด้านบนของด้านซ้ายส่งผลให้ขนาดหนึ่งรูปสี่เหลี่ยมผืนผ้า 0.5×2
• บีบอัดสี่เหลี่ยมกลับเข้าไปใน1×1ตาราง

ในการท้าทายนี้คุณจะใช้การแปลงแบบแยกส่วน

อินพุตและเอาต์พุต

ข้อมูลของคุณมีอาร์เรย์ 2 มิติของตัวอักขระ ASCII และช่องว่างที่มีขนาดบาง2m×2n m, n > 0เอาต์พุตของคุณคืออาร์เรย์ที่คล้ายกันซึ่งได้รับดังต่อไปนี้โดยใช้6×4อาร์เรย์

ABCDEF
GHIJKL
MNOPQR
STUVWX

ตัวอย่างเช่น. ขั้นแรกให้แบ่งครึ่งขวาของอาร์เรย์ที่ด้านบนของครึ่งซ้าย:

DEF
JKL
PQR
VWX
ABC
GHI
MNO
STU

จากนั้นแบ่งคอลัมน์ออกเป็นคู่ของอักขระและหมุนแต่ละคู่ตามเข็มนาฬิกา 90 องศาตามลำดับ "บีบอัด" สี่เหลี่ยมสูงกลับเป็นรูปร่างเดิม:

JDKELF
VPWQXR
GAHBIC
SMTNUO

นี่เป็นเอาต์พุตที่ถูกต้องสำหรับอาร์เรย์ข้างต้น

กฎระเบียบ

รูปแบบอินพุตและเอาต์พุตมีความยืดหยุ่น คุณสามารถใช้สตริงที่มีการ จำกัด บรรทัดใหม่รายการของสตริงหรืออาร์เรย์ 2 มิติของอักขระ อย่างไรก็ตามอินพุทและเอาท์พุทต้องมีรูปแบบที่แน่นอน: คุณต้องสามารถวนซ้ำการส่งของคุณได้หลายครั้งในอินพุตที่ถูกต้อง

คุณสามารถเขียนโปรแกรมเต็มหรือฟังก์ชั่น จำนวนไบต์ต่ำสุดที่ชนะและช่องโหว่มาตรฐานไม่ได้รับอนุญาต

กรณีทดสอบ

Input:
12
34

Output:
42
31

Input:
Hell
!  o
d  -
lroW

Output:
 lol
o W-
!H e
ldr 

Input:
ABCDEF
GHIJKL
MNOPQR
STUVWX

Output:
JDKELF
VPWQXR
GAHBIC
SMTNUO

Input:
*___  ___  o
o|__) |__) *
*|    |    o
o __   __  *
*|    | _  o
o|__  |__| *

Output:
|_____)   *o
 |_ _     *o
||_ __|   *o
o*|_____)   
o* |_ _     
o*||_ _     

Pyth, 25 19 18 ไบต์

msC_dcs_Cmck/lk2Q2

การสาธิตออนไลน์สาธิตออนไลน์มันใช้อาร์เรย์ 2 มิติของตัวอักษร

Array of strings เป็นอักขระที่มีความยาวมากกว่าหนึ่งตัว (19 ไบต์) การสาธิตออนไลน์

คำอธิบาย:

         m      Q    map each string k in input:
            /lk2        calculate half the line-length: len(k)/2
          ck/lk2        chop k into pieces of length len(k)/2
                        results in two pieces
        C            zip the resulting list
                     results in a tuple ([first half of strings], [second half of strings])
       _             invert the order ([second half of strings], [first half of strings])
      s              sum (combine the two lists to a big one
     c           2   chop them into tuples
m                          for each tuple of strings: 
 sC_d                        invert, zip, and sum

ส่วนสุดท้ายค่อนข้างสับสนในตอนแรก สมมติว่าเรามี tuple ['DEF', 'JKL'](ฉันใช้ตัวอย่างจาก OP)

    d  (('D', 'E', 'F'), ('J', 'K', 'L'))   just the pair of strings
   _d  (('J', 'K', 'L'), ('D', 'E', 'F'))   invert the order
  C_d  [('J', 'D'), ('K', 'E'), ('L', 'F')] zipped
 sC_d  ('J', 'D', 'K', 'E', 'L', 'F')       sum (combine tuples)

Julia ขนาด 136 ไบต์

การดำเนินการที่ตรงไปตรงมามาก ไม่ใช่รายการแข่งขันโดยเฉพาะ แต่มันสนุก!

A->(s=size(A);w=s[2];u=w÷2;C=vcat(A[:,u+1:w],A[:,1:u]);D=cell(s);j=1;for i=1:2:size(C,1) D[j,:]=vec(flipdim(C[i:i+1,:],1));j+=1end;D)

สิ่งนี้จะสร้างฟังก์ชั่นแลมบ์ดาที่ยอมรับอาร์เรย์ 2 มิติเป็นอินพุตและส่งกลับอาร์เรย์ 2 มิติที่ถูกแปลง

คำอธิบาย Ungolfed +:

function f(A)

    # Determine bounds
    s = size(A)          # Store the array dimensions
    w = s[2]             # Get the number of columns
    u = w ÷ 2            # Integer division, equivalent to div(w, 2)

    # Stack the right half of A atop the left
    C = vcat(A[:, u+1:w], A[:, 1:u])

    # Initialize the output array with the appropriate dimensions
    D = cell(s)

    # Initialize a row counter for D
    j = 1

    # Loop through all pairs of rows in C
    for i = 1:2:size(C, 1)

        # Flip the rows so that each column is a flipped pair
        # Collapse columns into a vector and store in D
        D[j, :] = vec(flipdim(C[i:i+1, :], 1))

        j += 1
    end

    return D
end

f=A->(...)เรียกว่าให้ชื่อฟังก์ชั่นเช่น

ตัวอย่างผลลัพธ์:

julia> A = ["A" "B" "C" "D" "E" "F";
            "G" "H" "I" "J" "K" "L";
            "M" "N" "O" "P" "Q" "R";
            "S" "T" "U" "V" "W" "X"]
julia> f(A)

4x6 Array{Any,2}:
 "J"  "D"  "K"  "E"  "L"  "F"
 "V"  "P"  "W"  "Q"  "X"  "R"
 "G"  "A"  "H"  "B"  "I"  "C"
 "S"  "M"  "T"  "N"  "U"  "O"

julia> B = ["H" "e" "l" "l";
            "!" " " " " "o";
            "d" " " " " "-";
            "l" "r" "o" "W"]
julia> f(B)

4x4 Array{Any,2}:
 " "  "l"  "o"  "l"
 "o"  " "  "W"  "-"
 "!"  "H"  " "  "e"
 "l"  "d"  "r"  " "

และพิสูจน์ว่าสามารถถูกล่ามโซ่โดยพลการ:

julia> f(f(B))

4x4 Array{Any,2}:
 "W"  "o"  "-"  "l"
 "r"  " "  " "  "e"
 "o"  " "  " "  "l"
 "l"  "!"  "d"  "H"

ข้อเสนอแนะยินดีต้อนรับเช่นเคยและฉันยินดีที่จะให้คำอธิบายเพิ่มเติม

CJam, 25 24 ไบต์

qN/_0=,2/f/z~\+2/Wf%:zN*

การนำไปปฏิบัติตามข้อกำหนดตรงไปตรงมา คำอธิบาย:

qN/                       "Split input by rows";
   _0=,2/                 "Get half of length of each row";
         f/               "Divide each row into two parts";
           z              "Convert array of row parts to array of half columns parts";
            ~\+           "Put the second half of columns before the first half and join";
               2/         "Group adjacent rows";
                 Wf%      "Flip the row pairs to help in CW rotation";
                    :z    "Rotate pairwise column elements CW";
                      N*  "Join by new line";

ลองออนไลน์ได้ที่นี่

JavaScript (ES6), 104 141

แก้ไขการตรวจสอบข้อมูลจำเพาะฉันพบว่าจำนวนแถวต้องเท่ากัน (ฉันพลาดไปก่อนหน้านี้) ดังนั้นจึงไม่ซับซ้อนเกินไปค้นหาตำแหน่งแหล่งที่ถูกต้องสำหรับแต่ละอักขระในเอาต์พุตในขั้นตอนเดียว

F=a=>a.map((r,i)=>
  [...r].map((c,k)=>
     a[l=i+i]?a[(j=l+1)-k%2][(k+r.length)>>1]:a[l-j-k%2][k>>1]
  ).join('')
)

ทดสอบในคอนโซล Firefox / FireBug

;[["ABCDEF","GHIJKL","MNOPQR","STUVWX"]
 ,["12","34"], ["Hell","!  o","d  -","lroW"]
 ,["*___  ___  o","o|__) |__) *","*|    |    o","o __   __  *","*|    | _  o","o|__  |__| *"]
].forEach(v=>console.log(v.join('\n')+'\n\n'+F(v).join('\n')))

เอาท์พุต

ABCDEF
GHIJKL
MNOPQR
STUVWX

JDKELF
VPWQXR
GAHBIC
SMTNUO

12
34

42
31

Hell
!  o
d  -
lroW

 lol
o W-
!H e
ldr 

*___  ___  o
o|__) |__) *
*|    |    o
o __   __  *
*|    | _  o
o|__  |__| *

|_____)   *o
 |_ _     *o
||_ __|   *o
o*|_____)   
o* |_ _     
o*||_ _     

J, 45 39 ไบต์

   $$[:,@;@|.@|:([:,:~2,2%~1{$)<@|:@|.;.3]

J มีฟังก์ชั่น tessellation (ตัด;.) ซึ่งช่วยได้มาก

   ]input=.4 6$97}.a.
abcdef
ghijkl
mnopqr
stuvwx

   ($$[:,@;@|.@|:([:,:~2,2%~1{$)<@|:@|.;.3]) input
jdkelf
vpwqxr
gahbic
smtnuo

Haskell, 128 127 ไบต์

import Control.Monad
f=g.ap((++).map snd)(map fst).map(splitAt=<<(`div`2).length)
g(a:b:c)=(h=<<zip b a):g c
g x=x
h(a,b)=[a,b]

การใช้งาน: f ["12", "34"]->["42","31"]

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

                                 input list:
                                   ["abcdef", "ghijkl", "mnopqr", "stuvwx"]
==========================================================================

map(splitAt=<<(`div`2).length)   split every line into pairs of halves:
                                   -> [("abc","def"),("ghi","jkl"),("mno","pqr"),("stu","vwx")]
ap((++).map snd)(map fst)        take all 2nd elements of the pairs and
                                 put it in front of the 1st elements:
                                   -> ["def","jkl","pqr","vwx","abc","ghi","mno","stu"]
(    zip b a) : g c              via g: take 2 elements from the list and
                                 zip it into pairs (reverse order), 
                                 recur until the end of the list:
                                   -> [[('j','d'),('k','e'),('l','f')],[('v','p'),('w','q'),('x','r')],[('g','a'),('h','b'),('i','c')],[('s','m'),('t','n'),('u','o')]]
h=<<                             convert all pairs into a two element list
                                 and concatenate:
                                   -> ["jdkelf","vpwqxr","gahbic","smtnuo"]  

แก้ไข: @Zgarb พบไบต์เพื่อบันทึก

GNU sed -r, 179 ไบต์

คะแนนรวม +1 สำหรับ-rarg to sed

ฉันต้องใช้เวลาพอสมควรในการหาวิธีการทำสิ่งนี้sedแต่ฉันคิดว่าฉันมีตอนนี้:

# Insert : markers at start and end of each row
s/  /:  :/g
s/(^|$)/:/g
# Loop to find middle of each row
:a
# Move row start and end markers in, one char at a time
s/:([^  :])([^  :]*)([^ :]):/\1:\2:\3/g
ta
# Loop to move left half of each row to end of pattern buffer
:b
s/([^   :]+)::(.*)/\2   \1/
tb
# remove end marker
s/$/:/
# double loop to merge odd and even rows
:c
# move 1st char of rows 2 and 1 to end of pattern buffer
s/^([^  :])([^  ]*) ([^ ])(.*)/\2   \4\3\1/
tc
# end of row; remove leading tab and add trailing tab 
s/^ +(.*)/\1    /
tc
# remove markers and trailing tab
s/(:|   $)//g

หมายเหตุช่องว่างทั้งหมดข้างต้นควรเป็นtabอักขระตัวเดียว ความคิดเห็นไม่รวมอยู่ในคะแนนกอล์ฟ

โปรดทราบว่านี่เป็นการใช้:อักขระเครื่องหมายอย่างกว้างขวาง หากกระแสข้อมูลเข้ามี:พฤติกรรมที่ไม่ได้กำหนดจะตามมา สิ่งนี้สามารถบรรเทาได้ด้วยการแทนที่ทั้งหมด:ด้วยอักขระที่ไม่พิมพ์ (เช่น BEL) โดยไม่เสียค่าใช้จ่ายใด ๆ กับคะแนนกอล์ฟ

อินพุตและเอาต์พุตเป็นรายการสตริงที่คั่นด้วยแท็บ:

$ echo 'Hell
!  o
d  -
lroW' | paste -s - | sed -rf baker.sed | tr '\t' '\n'
 lol
o W-
!H e
ldr 
$ 

J, 33 32 ตัวอักษร

คำกริยา monadic

0 2,.@|:_2|.\"1-:@#@{.(}.,.{.)|:

คำอธิบาย

เริ่มจากการกำหนดYให้เป็นตัวอย่างอินพุตของเรา

   ] Y =. a. {~ 65 + i. 4 6          NB. sample input
ABCDEF
GHIJKL
MNOPQR
STUVWX

ส่วนแรก ( -:@#@{. (}. ,. {.) |:) แบ่งYครึ่งแล้วผนวกท้าย:

   # {. Y                            NB. number of columns in Y
6
   -: # {. Y                         NB. half of that
3
   |: Y                              NB. Y transposed
AGMS
BHNT
CIOU
DJPV
EKQW
FLRX
   3 {. |: Y                         NB. take three rows
AGMS
BHNT
CIOU
   3 }. |: Y                         NB. drop three rows
DJPV
EKQW
FLRX
   3 (}. ,. {.) |: Y                 NB. stitch take to drop
DJPVAGMS
EKQWBHNT
FLRXCIOU

ในส่วนที่สอง ( _2 |.\"1) เราแบ่งสิ่งนี้เป็นคู่ที่สองและย้อนกลับ:

   R =. (-:@#@{. (}. ,. {.) |:) Y    NB. previous result
   _2 <\"1 R                         NB. pairs put into boxes
┌──┬──┬──┬──┐
│DJ│PV│AG│MS│
├──┼──┼──┼──┤
│EK│QW│BH│NT│
├──┼──┼──┼──┤
│FL│RX│CI│OU│
└──┴──┴──┴──┘
   _2 <@|.\"1 R                      NB. reversed pairs
┌──┬──┬──┬──┐
│JD│VP│GA│SM│
├──┼──┼──┼──┤
│KE│WQ│HB│TN│
├──┼──┼──┼──┤
│LF│XR│IC│UO│
└──┴──┴──┴──┘

ในที่สุด ( 0 2 ,.@|:) เราย้ายเมทริกซ์ตามต้องการและทิ้งแกนต่อท้าย:

   ] RR =. _2 |.\"1 R                NB. previous result
JD
VP
GA
SM

KE
WQ
HB
TN

LF
XR
IC
UO
   0 2 |: RR                         NB. transpose axes
JD
KE
LF

VP
WQ
XR

GA
HB
IC

SM
TN
UO
   ($ RR) ; ($ 0 2 |: RR)            NB. comparison of shapes
┌─────┬─────┐
│3 4 2│4 3 2│
└─────┴─────┘
   ,. 0 2 |: RR                      NB. discard trailing axis
JDKELF
VPWQXR
GAHBIC
SMTNUO

การแสดงออกทั้งหมดที่มีช่องว่างแทรก:

0 2 ,.@|: _2 |.\"1 -:@#@{. (}. ,. {.) |:

และเป็นคำกริยาที่ชัดเจน:

3 : ',. 0 2 |: _2 |.\"1 (-: # {. y) (}. ,. {.) |: y'