pengantar

Peta Baker adalah sistem dinamik penting yang menunjukkan perilaku kacau. Ini adalah fungsi dari satuan kuadrat itu sendiri yang didefinisikan secara intuitif sebagai berikut.

• Potong persegi secara vertikal menjadi dua, menghasilkan ukuran dua persegi panjang 0.5×1.
• Susun setengah kanan di atas kiri, menghasilkan satu ukuran persegi panjang 0.5×2
• Kompres persegi panjang kembali ke 1×1kotak.

Dalam tantangan ini, Anda akan mengimplementasikan versi diskrit dari transformasi ini.

Masukan dan keluaran

Input Anda adalah array 2D karakter ASCII yang dapat dicetak dan ruang kosong ukuran 2m×2nuntuk sebagian orang m, n > 0. Output Anda adalah array serupa yang diperoleh sebagai berikut, menggunakan 6×4array

ABCDEF
GHIJKL
MNOPQR
STUVWX

sebagai contoh. Pertama, susun setengah kanan array di atas setengah kiri:

DEF
JKL
PQR
VWX
ABC
GHI
MNO
STU

Kemudian, pisahkan kolom menjadi pasangan karakter, dan bebaskan masing-masing pasangan 90 derajat searah jarum jam, "tekan" persegi panjang yang tinggi kembali ke bentuk aslinya:

JDKELF
VPWQXR
GAHBIC
SMTNUO

Ini adalah output yang benar untuk array di atas.

Aturan

Format input dan output fleksibel. Anda dapat menggunakan string yang dibatasi baris baru, daftar string, atau array karakter 2D. Namun, input dan output harus memiliki format yang sama persis: Anda harus dapat mengulangi kiriman Anda beberapa kali sembarang pada setiap input yang valid.

Anda dapat menulis program lengkap atau fungsi. Hitungan byte terendah menang, dan celah standar tidak diizinkan.

Uji Kasus

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

Demonstrasi online . Menggunakan 2D-array karakter.

Array string adalah satu karakter lebih panjang (19 byte). Demonstrasi online

Penjelasan:

         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

Bagian terakhir agak membingungkan pada awalnya. Mari kita asumsikan kita memiliki tuple ['DEF', 'JKL'](saya menggunakan contoh dari 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

Implementasi yang sangat mudah. Bukan entri yang sangat kompetitif, tapi itu menyenangkan!

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)

Ini menciptakan fungsi lambda yang menerima array 2 dimensi sebagai input dan mengembalikan array 2 dimensi yang ditransformasikan.

Penjelasan + tidak dikumpulkan:

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

Untuk memanggilnya, beri nama fungsi, misalnya f=A->(...).

Contoh output:

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

Dan bukti bahwa itu bisa dirantai secara sewenang-wenang:

julia> f(f(B))

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

Saran diterima seperti biasa, dan saya akan senang memberikan penjelasan lebih lanjut.

CJam, 25 24 byte

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

Implementasi spek lurus ke depan. Penjelasan:

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

Cobalah online di sini

JavaScript (ES6), 104 141

Edit Meninjau spesifikasi, saya menemukan bahwa jumlah baris harus genap (saya melewatkan ini sebelumnya). Jadi tidak terlalu rumit menemukan posisi sumber yang benar untuk setiap karakter dalam output dalam satu langkah.

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

Uji di Firefox / konsol 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')))

Keluaran

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 memiliki fungsi tessellation (potong ;.) yang banyak membantu.

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

Penggunaan: f ["12", "34"]->["42","31"]

Bagaimana itu bekerja:

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

Sunting: @Zgarb menemukan byte untuk disimpan.

GNU sed -r, 179 byte

Skor termasuk +1 untuk -rarg to sed.

Butuh beberapa saat untuk mencari tahu bagaimana melakukan ini sed, tapi saya pikir saya sudah memilikinya sekarang:

# 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

Perhatikan bahwa spasi putih di atas harus tabkarakter tunggal . Komentar tidak termasuk dalam skor golf.

Perhatikan juga bahwa ini menggunakan :karakter marker secara ekstensif . Jika aliran input berisi :, maka perilaku yang tidak ditentukan akan terjadi. Ini dapat dikurangi dengan mengganti semua :dengan beberapa karakter non-cetak (misalnya BEL) tanpa biaya ke skor golf.

Input dan output adalah daftar string yang dipisahkan tab:

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

J, 33 32 karakter

Kata kerja monadik.

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

Penjelasan

Mari kita mulai dengan mendefinisikan Ysebagai input sampel kami.

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

Bagian pertama ( -:@#@{. (}. ,. {.) |:) terbelah Ydua dan menambahkan kemudian berakhir:

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

Di bagian kedua ( _2 |.\"1) kami membaginya menjadi pasangan dua dan membalikkannya:

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

Akhirnya ( 0 2 ,.@|:), kami memindahkan matriks sesuai kebutuhan dan membuang sumbu trailing:

   ] 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

Seluruh ekspresi dengan spasi putih dimasukkan:

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

Dan sebagai kata kerja eksplisit:

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