Giới thiệu

Các bản đồ của Baker là một hệ thống động lực quan trọng là thể hiện hành vi hỗn loạn. Nó là một hàm từ hình vuông đơn vị đến chính nó được xác định bằng trực giác như sau.

• Cắt hình vuông theo chiều dọc làm đôi, dẫn đến hai hình chữ nhật có kích thước 0.5×1.
• Xếp nửa bên phải lên trên cùng bên trái, tạo thành một hình chữ nhật có kích thước 0.5×2
• Nén hình chữ nhật trở lại thành một 1×1hình vuông.

Trong thử thách này, bạn sẽ thực hiện một phiên bản riêng biệt của chuyển đổi này.

Đầu vào và đầu ra

Đầu vào của bạn là một mảng 2D gồm các ký tự ASCII có thể in và khoảng trắng kích thước 2m×2ncho một số m, n > 0. Đầu ra của bạn là một mảng tương tự thu được như sau, sử dụng 6×4mảng

ABCDEF
GHIJKL
MNOPQR
STUVWX

làm ví dụ Đầu tiên, xếp nửa bên phải của mảng lên trên nửa bên trái:

DEF
JKL
PQR
VWX
ABC
GHI
MNO
STU

Sau đó, chia các cột thành các cặp ký tự và xoay độc lập mỗi cặp 90 độ theo chiều kim đồng hồ, "nén" hình chữ nhật cao trở lại hình dạng ban đầu:

JDKELF
VPWQXR
GAHBIC
SMTNUO

Đây là đầu ra chính xác cho mảng trên.

Quy tắc

Các định dạng đầu vào và đầu ra là linh hoạt. Bạn có thể sử dụng các chuỗi được phân tách bằng dòng mới, danh sách các chuỗi hoặc mảng 2D của các ký tự. Tuy nhiên, đầu vào và đầu ra phải có cùng định dạng chính xác: bạn phải có khả năng lặp lại việc gửi của mình một số lần tùy ý trên bất kỳ đầu vào hợp lệ nào.

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Các trường hợp thử nghiệm

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 byte

msC_dcs_Cmck/lk2Q2

Trình diễn trực tuyến . Nó sử dụng một mảng 2D của ký tự.

Mảng của chuỗi dài hơn một char (19 byte). Trình diễn trực tuyến

Giải trình:

         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

Phần cuối cùng là một chút bối rối lúc đầu. Giả sử chúng ta có bộ dữ liệu ['DEF', 'JKL'](tôi sử dụng ví dụ từ 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 byte

Một thực hiện rất đơn giản. Không phải là một mục đặc biệt cạnh tranh, nhưng nó rất vui!

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)

Điều này tạo ra hàm lambda chấp nhận mảng 2 chiều làm đầu vào và trả về mảng 2 chiều được chuyển đổi.

Ungolfed + giải thích:

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

Để gọi nó, đặt tên cho hàm, vd f=A->(...).

Ví dụ đầu ra:

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

Và bằng chứng rằng nó có thể bị xiềng xích tùy tiện:

julia> f(f(B))

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

Đề xuất luôn được chào đón và tôi sẽ vui lòng cung cấp thêm bất kỳ lời giải thích nào.

CJam, 25 24 byte

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

Thẳng tiến thực hiện spec. Giải trình:

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";

Dùng thử trực tuyến tại đây

JavaScript (ES6), 104 141

Chỉnh sửa Xem lại thông số kỹ thuật, tôi thấy rằng số lượng hàng phải chẵn (tôi đã bỏ lỡ điều này trước đây). Vì vậy, không quá phức tạp để tìm vị trí nguồn chính xác cho mỗi char trong đầu ra trong một bước duy nhất.

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

Kiểm tra trong bảng điều khiển 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')))

Đầu ra

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 byte

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

J có chức năng tessname (cắt ;.) giúp rất nhiều.

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

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

Haskell, 128 127 byte

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]

Sử dụng: f ["12", "34"] ->["42","31"]

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

                                 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"]  

Chỉnh sửa: @Zgarb tìm thấy một byte để lưu.

GNU sed -r, 179 byte

Điểm bao gồm +1 cho -rarg để sed.

Tôi phải mất một thời gian để tìm ra cách thực hiện điều này sed, nhưng tôi nghĩ rằng tôi đã có nó ngay bây giờ:

# 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

Lưu ý tất cả các khoảng trắng ở trên phải là các tabký tự đơn . Bình luận không được bao gồm trong điểm golf.

Cũng lưu ý rằng điều này làm cho việc sử dụng rộng rãi các :ký tự đánh dấu. Nếu luồng đầu vào chứa :, thì hành vi không xác định sẽ xảy ra. Điều này có thể được giảm nhẹ bằng cách thay thế tất cả: bằng một số ký tự không in (ví dụ: BEL) miễn phí cho điểm golf.

Đầu vào và đầu ra là một danh sách các chuỗi được phân tách bằng tab:

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

J, 33 32 ký tự

Một động từ đơn âm.

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

Giải trình

Hãy bắt đầu bằng cách xác định Ylà đầu vào mẫu của chúng tôi.

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

Phần đầu tiên ( -:@#@{. (}. ,. {.) |:) chia làm đôi Yvà nối sau đó kết thúc:

   # {. 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

Trong phần thứ hai ( _2 |.\"1) chúng tôi chia phần này thành cặp hai và đảo ngược chúng:

   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│
└──┴──┴──┴──┘

Cuối cùng ( 0 2 ,.@|:), chúng tôi hoán chuyển ma trận khi cần và loại bỏ trục kéo:

   ] 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

Toàn bộ biểu thức với khoảng trắng được chèn:

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

Và như một động từ rõ ràng:

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