Tantangan:

Diberikan matriks NxN di mana dan satu dari delapan 'opsi lipat' yang berbeda, menghasilkan array 2D / daftar dengan nilai yang dikurangi.$N\geq2$

Delapan opsi lipat adalah: kiri-ke-kanan; kanan ke kiri; atas ke bawah; dari bawah ke atas; topleft-to-bottomright; sayap kanan atas ke bawah; bottomleft-to-topright; bottomleight ke topleft.

Contoh langkah demi langkah:

Matriks input:

[[ 1, 3, 5, 7],
 [ 0, 8, 6, 4],
 [ 1, 1, 1, 1],  (a'th row in the explanation below)
 [ 1,25, 0,75]]

Dengan opsi lipat dari atas ke bawah, kami menampilkan sebagai berikut:

[[ 1,-7,-5,-3],
 [ 0,22,-5,68]]

Mengapa? Kami melipat dari atas ke bawah. Karena dimensi matriksnya genap, kami tidak memiliki lapisan tengah untuk dilestarikan apa adanya. Baris ' akan dikurangi dengan baris ' (akan menjadi 'baris untuk matriks dimensi ganjil); jadi menjadi . Baris ' kemudian akan dikurangi dengan baris ' (akan menjadi 'baris untuk matriks dimensi ganjil); jadi menjadi .$a$[1, 1, 1, 1]$(a-1)$$(a-2)$[1-0, 1-8, 1-6, 1-4][1, -7, -5, -3]$(a+1)$[1, 25, 0, 75]$(a-2)$$(a-3)$[1-1, 25-3, 0-5, 75-7][0, 22, -5, 68]

Dengan opsi lipat bottomright-to-topleft (dengan input-matriks yang sama di atas) kami menampilkan sebagai berikut:

[[-74,  2,  1,  7],
 [  0,  7,  6],
 [-24,  1],
 [  1]]

Dengan pengurangan lipat berikut:

[[1-75,  3-1,  5-4,    7],
 [ 0-0,  8-1,    6],
 [1-25,    1],
 [   1]]

Aturan tantangan:

• Anda dapat menggunakan delapan huruf berbeda [A-Za-z]atau angka berbeda dalam rentang untuk opsi pelipatan. Angka atau mungkin merupakan opsi yang paling umum, tetapi jika Anda ingin menggunakan angka yang berbeda dalam kisaran untuk beberapa perhitungan cerdas, jangan ragu untuk melakukannya. Harap sebutkan opsi lipat mana yang Anda gunakan dalam jawaban Anda.$[-99,99]$$[1..8]$$[0..7]$
• Matriks input akan selalu berupa matriks NxN persegi, jadi Anda tidak harus menangani matriks NxM persegi panjang. juga akan selalu minimal 2, karena matriks kosong atau 1x1 tidak dapat dilipat.$N$
• Input dari matriks akan selalu berisi angka-angka non-negatif dalam kisaran (angka-angka dalam output karena itu akan berada dalam kisaran ).$[0, 999]$$[-999, 999]$
• Dengan lipatan diagonal (anti-) atau lipatan vertikal / horisontal dimensi ganjil, 'lapisan' tengah akan tetap tidak berubah.
• I / O fleksibel. Dapat berupa array 2D / daftar bilangan bulat; dapat dikembalikan atau dicetak sebagai string yang dibatasi spasi-dan-baris; Anda dapat memodifikasi input-matrix dan mengganti angka-angka yang seharusnya dengan nullatau angka di luar [-999, 999]rentang untuk menunjukkan mereka hilang; dll. dll

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda dengan aturan I / O default , sehingga Anda diizinkan untuk menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda (yaitu TIO ).
• Juga, menambahkan penjelasan untuk jawaban Anda sangat dianjurkan.

Kasus uji:

Input-matrix 1:

Input-matrix (for the following eight test cases):
[[ 1, 3, 5, 7],
 [ 0, 8, 6, 4],
 [ 1, 1, 1, 1],
 [ 1,25, 0,75]]

Input-folding option: left-to-right
Output: [[2,6],[-2,4],[0,0],[-25,74]]

Input-folding option: right-to-left
Output: [[-6,-2],[-4,2],[0,0],[-74,25]]

Input-folding option: top-to-bottom
Output: [[1,-7,-5,-3],[0,22,-5,68]]

Input-folding option: bottom-to-top
Output: [[0,-22,5,-68],[-1,7,5,3]]

Input-folding option: topleft-to-bottomright
Output: [[7],[6,-1],[1,-7,-2],[1,24,0,74]]

Input-folding option: topright-to-bottomleft
Output: [[1],[-3,8],[-4,-5,1],[-6,21,-1,75]]

Input-folding option: bottomleft-to-topright
Output: [[1,3,4,6],[8,5,-21],[1,1],[75]]

Input-folding option: bottomright-to-topleft
Output: [[-74,2,1,7],[0,7,6],[-24,1],[1]]

Input-matrix 2:

Input-matrix (for the following eight test cases):
[[17, 4, 3],
 [ 8, 1,11],
 [11, 9, 7]]

Input-folding option: left-to-right
Output: [[4,-14],[1,3],[9,-4]]

Input-folding option: right-to-left
Output: [[14,4],[-3,1],[4,9]]

Input-folding option: top-to-bottom
Output: [[8,1,11],[-6,5,4]]

Input-folding option: bottom-to-top
Output: [[6,-5,-4],[8,1,11]]

Input-folding option: topleft-to-bottomright
Output: [[3],[1,7],[11,1,-10]]

Input-folding option: topright-to-bottomleft
Output: [[17],[4,1],[8,-2,7]]

Input-folding option: bottomleft-to-topright
Output: [[17,-4,-8],[1,2],[7]]

Input-folding option: bottomright-to-topleft
Output: [[10,-7,3],[-1,1],[11]]

Oktaf , 256 248 244 248 byte

m=d=x=@(a,b=1)rot90(a,b)
y=@(a,b=2)flip(a,b)
z=@(a,b=1)tril(a+1e3,-1)+a-x(y(tril(a)))+b*diag(diag(a))
f=@(a,b){m=((a-y(a))(:,1:(d=size(a,2)/2))),-y(m),m=y(x((a=x(a))-y(a)))(d+1:end,:),y(m,1),-y(z(a,-1)),x(z(x(a,2)),2),z(a=x(a,3)),x(z(x(a,2)),2)}{b}

Cobalah online!

-2 byte (dan sedikit merapikan) terima kasih kepada Luis Mendo

+2 byte karena koreksi untuk TB

Operasi 1-Indexed untuk nilai b dari 1-8:

R-L
L-R
B-T
T-B
BR-TL
TR-BL
BL-TR
TL-BR

Ini membuat saya sakit kepala, saya akan golf dengan benar nanti

Jelly ,  39  34 byte

_{Ada kemungkinan bermain golf lebih lanjut dengan menggabungkan beberapa "fungsi".}
... ya: -5 terima kasih kepada NickKennedy!

ṃ“Z“Ṛ“U“ “ŒDṙL ZZṚ”ŒḄFḲj“ŒH_Ṛ}¥/”v

Cobalah online!

Sebuah link diad yang menerima integer (instruksi) dan daftar daftar angka (matriks).

$[-99,99]$

           Instruction  |  integer
------------------------+---------
         left-to-right  |     4
         right-to-left  |    14
         top-to-bottom  |     9
         bottom-to-top  |    39
topleft-to-bottomright  |    65
topright-to-bottomleft  |    15
bottomleft-to-topright  |    10
bottomright-to-topleft  |     0

Bagaimana?

Tautan ini membuat kode Jelly yang kemudian dievaluasi menggunakan M sebagai ...

ṃ“Z“Ṛ“U“ “ŒDṙL ZZṚ”ŒḄFḲj“ŒH_Ṛ}¥/”v - Link: integer, I; matrix, M
 “Z“Ṛ“U“ “ŒDṙL ZZṚ”                - list of lists of characters = ["Z", "Ṛ", "U", " ", "ŒDṙL ZZṚ"]
ṃ                                  - base decompress (I) using those lists as the digits
                                   -  ...i.e. convert to base 5 and then convert the digits:
                                   -          [1,2,3,4,0] -> ["Z", "Ṛ", "U", " ", "ŒDṙL ZZṚ"]
                   ŒḄ              - bounce
                                   -  ...e.g. [a, b, c] -> [a, b, c, b, a]
                     F             - flatten to a list of characters
                      Ḳ            - split at spaces
                       j           - join with:
                        “ŒH_Ṛ}¥/”  -   list of characters = "ŒH_Ṛ}¥/"
                                 v - evaluate as Jelly code with an input of M

Masing-masing dari delapan opsi tersebut adalah:

left-to-right           (4): ŒH_Ṛ}¥/
right-to-left          (14): ṚŒH_Ṛ}¥/Ṛ
top-to-bottom           (9): ZŒH_Ṛ}¥/Z
bottom-to-top          (39): ZṚŒH_Ṛ}¥/ṚZ
topleft-to-bottomright (65): ṚUŒDṙLŒH_Ṛ}¥/ZZṚUṚ
topright-to-bottomleft (15): UŒDṙLŒH_Ṛ}¥/ZZṚU
bottomleft-to-topright (10): ṚŒDṙLŒH_Ṛ}¥/ZZṚṚ
bottomright-to-topleft  (0): ŒDṙLŒH_Ṛ}¥/ZZṚ

Masing-masing (kecuali 0dan 4) menerapkan transformasi untuk Mmenggunakan beberapa Z(transpos), Ṛ(mundur), dan U(mundur masing-masing); kemudian salah satu dari dua fungsi (lihat di bawah), kemudian kebalikan dari transformasi pengaturan (jika ada satu) diimplementasikan dengan kebalikan dari kode.

Dua fungsi batin adalah:

ŒH_Ṛ}¥/ - Function A: Fold bottom-to-top: matrix, M
ŒH       - split M into two equal lists of rows (first half bigger by 1 if need be)
      / - reduce by:
     ¥  - last two links as a dyad:
    }   -  using the right argument (i.e. second half):
   Ṛ    -    reverse
  _     -  subtract

ŒDṙLŒH_Ṛ}¥/ZZṚ - Function B: Fold topright-to-bottomleft: matrix, M
ŒD             - diagonals of M
  ṙ            - rotate left by:
   L           -   length of M (puts them in order from bottom left most)
    ŒH_Ṛ}¥/    - same action as calling Function A on the diagonals
           Z   - transpose
            Z  - transpose
             Ṛ - reverse

JavaScript (ES6),  149 ... 133  128 byte

(matrix)(d)$0\le d\le7$NaN

$0 =\;\rightarrow$$1 =\;\downarrow$$2 =\;\small\searrow$$3 =\;\small\swarrow$$4 =\;\leftarrow$$5 =\;\uparrow$$6 =\;\small\nwarrow$$7 =\;\small\nearrow$

m=>d=>m.map((r,y)=>r.map((v,x)=>v-=(w=m.length+~y)-(p=[x+x-y,y,x,q=w+y-x][d&3])&&[r[q],m[w][x],m[q][w],m[x][y]][d>3^p>w?d&3:m]))

Cobalah online!

Berkomentar

m => d =>                   // m[] = matrix; d = direction
  m.map((r, y) =>           // for each row r[] at position y in m[]:
    r.map((v, x) =>         //   for each value v at position x in r[]:
      v -=                  //     subtract from v:
        (                   //       define w as:
          w = m.length + ~y //         the width of input matrix - y - 1
        ) - (               //       and compare it with
          p = [             //       p defined as:
            x + x - y,      //         2 * x - y for vertical folding
            y,              //         y for horizontal folding
            x,              //         x for diagonal folding
            q = w + y - x   //         q = w + y - x for anti-diagonal folding
          ][d & 3]          //       using d MOD 4
        ) &&                //       if p is equal to w, leave v unchanged
        [                   //       otherwise, subtract:
          r[q],             //         r[q] for vertical folding
          m[w][x],          //         m[w][x] for horizontal folding
          m[q][w],          //         m[q][w] for diagonal folding
          m[x][y]           //         m[x][y] for anti-diagonal folding
        ][                  //       provided that we're located in the target area:
          d > 3 ^           //         test p < w if d > 3 
          p > w ? d & 3     //         or p > w if d <= 3
                : m         //         and yield either d MOD 4 or m[]
        ]                   //       (when using m[], we subtract 'undefined' from v,
                            //       which sets it to NaN instead)
    )                       //   end of inner map()
  )                         // end of outer map()

Jelly , 71 34 byte

ḃ2ŒḄ,UZṚŒDṙLƊŒH_Ṛ}¥/$ZZṚƊṚZ8ƭ$ị@¥ƒ

Cobalah online!

Test Suite

Program lengkap. Argumen yang benar adalah matriks. Argumen kiri adalah jenis lipatan:

44 = L-R
40 = R-L
36 = T-B
32 = B-T
50 = TL-BR
34 = TR-BR
54 = BL-TR
38 = BR-TL

Ditulis ulang untuk menggunakan binary bijective 5-bit sebagai input. Perhatikan bahwa program yang diberikan di atas tidak akan bekerja berulang kali untuk beberapa lipatan.

Oktaf , 482 byte , 459 Bytes

Input untuk memutuskan arah pelipatan adalah:
1) kiri ke kanan
2) bawah ke atas
3) kanan ke kiri
4) atas ke bawah
5) tr ke bl
6) br ke tl
7) bl ke tr 7) bl ke tr
8) tl ke br
Setiap panggilan hanya menghasilkan lipatan yang ditentukan, bukan semuanya (yang mungkin akan memakan waktu kurang dari byte). Masalah terbesar adalah bahwa untuk kasus ini saya tidak tahu cara meletakkan lipatan 1-4 dan 5-8 dalam satu lingkaran yang sama. Tapi setidaknya oktaf memiliki matriks yang terlihat bagus.

    function[m]=f(n,o)
    k=length(n);m=NaN(k);if(o<5)
    if(mod(o,2)>0)n=n'end
    q=[0,0,k+1,k+1](o)
    for x=1:ceil(k/2)if(x*2>k)m(x,:)=n(x,:)else
    for a=1:k
    m(abs(q-x),a)=n(abs(q-x),a)-n(abs(q-(k+1-x)),a)end
    end
    end
    if(mod(o,2)>0)m=flipud(m')end
    else
    if(mod(o,2)>0)n=flip(n)end
    q=[0,0,k+1,k+1](o-4)
    for x=1:k
    for a=1:k+1-x
    if(a==k+1-x)m(x,a)=n(x,a)else
    m(abs(q-x),abs(q-a))=n(abs(q-x),abs(q-a))-n(abs(q-(k+1-a)),abs(q-(k+1-x)))end
    end
    end
    end
    if(mod(o,2)>0)m=flip(m)end
    end

Cobalah online!

Output suppression biaya byte, jadi abaikan semua yang bukan pernyataan pengembalian (ans =).

Arang , 78 77 byte

Ｆ⁴«ＵＭηＥ⮌η§μλ¿⁼ιθＵＭηＥκ⎇‹⊕⊗νＬη⁻μ§⮌κν⎇›⊕⊗νＬηωμ¿⁼ι﹪θ⁴ＵＭηＥκ⎇‹λν⁻짧ηνλ⎇›λνωμ»Ｅη⪫ι,

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Gunakan opsi lipat berikut:

0   top-to-bottom
1   left-to-right
2   bottom-to-top
3   right-to-left
4   bottomright-to-topleft
5   topright-to-bottomleft
6   topleft-to-bottomright
7   bottomleft-to-topright

Nilai yang dilipat diganti dengan string kosong. Penjelasan:

Ｆ⁴«≔ＵＭηＥ⮌η§μλ

Putar array empat kali.

¿⁼ιθＵＭηＥκ⎇‹⊕⊗νＬη⁻μ§⮌κν⎇›⊕⊗νＬηωμ

Lipat array secara horizontal bila perlu.

¿⁼ι﹪θ⁴ＵＭηＥκ⎇‹λν⁻짧ηνλ⎇›λνωμ

Lipat array secara diagonal bila perlu.

»Ｅη⪫ι,

Keluarkan array setelah diputar kembali ke orientasi aslinya.