Thử thách:

Đưa ra một ma trận NxN trong đó và một trong tám 'tùy chọn gấp' riêng biệt, xuất ra một mảng / danh sách 2D với các giá trị được trừ.$N\geq2$

Tám tùy chọn gấp là: trái sang phải; phải sang trái; từ trên xuống dưới; dưới lên trên; topleft-to-bottomright; topright-to-bottomleft; từ dưới lên trên; từ dưới lên trên

Từng bước ví dụ:

Ma trận đầu vào:

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

Với tùy chọn gập từ trên xuống dưới, chúng tôi đưa ra kết quả như sau:

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

Tại sao? Chúng tôi gấp từ trên xuống dưới. Vì kích thước ma trận là chẵn, chúng tôi không có lớp giữa để giữ nguyên. Các 'thứ hàng sẽ được trừ bằng ' th hàng (có thể đã được 'th hàng cho ma trận chiều lẻ); vì vậy trở thành . Các 'th hàng sau đó sẽ được trừ bằng ' th hàng (có thể đã được 'th hàng cho ma trận chiều lẻ); vì vậy trở thành .$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]

Thay vào đó, với tùy chọn gập từ dưới lên trên để thay thế (với cùng một ma trận đầu vào ở trên), chúng tôi đưa ra kết quả như sau:

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

Với các phép trừ gấp sau đây:

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

Quy tắc thử thách:

• Bạn có thể sử dụng bất kỳ tám chữ cái [A-Za-z]hoặc số riêng biệt nào trong phạm vi cho các tùy chọn gấp. Các số hoặc có thể là các tùy chọn phổ biến nhất, nhưng nếu bạn muốn sử dụng các số khác nhau trong phạm vi cho một số tính toán thông minh, vui lòng thực hiện. Vui lòng cho biết các tùy chọn gấp mà bạn đã sử dụng trong câu trả lời của bạn.$[-99,99]$$[1..8]$$[0..7]$
• Ma trận đầu vào sẽ luôn là ma trận NxN vuông, do đó bạn không phải xử lý bất kỳ ma trận NxM hình chữ nhật nào. cũng sẽ luôn có ít nhất 2, vì ma trận trống hoặc 1x1 không thể được gấp lại.$N$
• Đầu vào của ma trận sẽ luôn chứa các số không âm trong phạm vi (do đó, các số trong đầu ra sẽ nằm trong phạm vi ).$[0, 999]$$[-999, 999]$
• Với nếp gấp (chống) theo đường chéo hoặc gấp theo chiều dọc / chiều ngang lẻ, 'lớp giữa' sẽ không thay đổi.
• I / O là linh hoạt. Có thể là một mảng 2D / danh sách các số nguyên; có thể được trả lại hoặc in dưới dạng một chuỗi giới hạn không gian và dòng mới; bạn có thể sửa đổi ma trận đầu vào và thay thế các số nên đi cùng nullhoặc một số nằm ngoài [-999, 999]phạm vi để cho biết chúng đã biến mất; Vân vân.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

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

Ma trận đầu vào 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]]

Ma trận đầu vào 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]]

Octave , 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}

Hãy thử trực tuyến!

-2 byte (và một chút để dọn dẹp) nhờ Luis Mendo

+2 byte do hiệu chỉnh TB

1 - Các hoạt động được lập chỉ mục cho các giá trị của b từ 1-8:

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

Điều này làm tôi đau đầu, tôi sẽ chơi golf đúng cách sau

Thạch ,  39  34 byte

_{Có thể chơi golf xa hơn bằng cách kết hợp một số "chức năng".}
... vâng: -5 nhờ NickKennedy!

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

Hãy thử trực tuyến!

Một liên kết dyadic chấp nhận một số nguyên (hướng dẫn) và một danh sách các danh sách các số (ma trận).

$[-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

Làm sao?

Liên kết tạo mã Jelly sau đó được đánh giá bằng M làm đầu vào ...

ṃ“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

Mỗi trong số tám tùy chọn sau đó là:

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Ṛ

Những cái này (ngoại trừ 0và 4) áp dụng một biến đổi để Msử dụng một số Z(chuyển vị), Ṛ(đảo ngược) và U(đảo ngược từng cái); sau đó một trong hai hàm (xem bên dưới), sau đó nghịch đảo của chuyển đổi thiết lập (nếu có) được thực hiện với mã đảo ngược của mã.

Hai chức năng bên trong là:

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

Hãy thử trực tuyến!

Đã bình luận

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

Thạch , 71 34 byte

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

Hãy thử trực tuyến!

Phòng thử nghiệm

Một chương trình đầy đủ. Đối số đúng là ma trận. Đối số bên trái là kiểu gấp:

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

Viết lại để sử dụng nhị phân sinh học 5 bit làm đầu vào. Lưu ý chương trình được cung cấp ở trên sẽ không hoạt động liên tục trong nhiều lần.

Octave , 482 byte , 459 byte

Các đầu vào để quyết định hướng gấp là:
1) từ trái sang phải
2) từ dưới lên trên
3) từ phải sang trái
4) từ trên xuống dưới
5) tr đến bl
6) br đến tl
7) bl đến tr
8) tl đến br
Mỗi cuộc gọi chỉ tạo ra nếp gấp được chỉ định, thay vì tất cả chúng (có thể sẽ mất ít byte hơn). Vấn đề lớn nhất là trong trường hợp này tôi không thể tìm ra cách đặt các nếp gấp 1-4 và 5-8 trong cùng một vòng lặp. Nhưng ít nhất quãng tám có ma trận đẹp.

    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

Hãy thử trực tuyến!

Việc triệt tiêu đầu ra tốn byte, vì vậy bỏ qua mọi thứ không phải là câu lệnh return (ans =).

Than , 78 77 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sử dụng các tùy chọn gấp sau:

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

Các giá trị gấp được thay thế bằng các chuỗi trống. Giải trình:

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

Xoay mảng bốn lần.

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

Gấp mảng theo chiều ngang khi thích hợp.

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

Gấp mảng theo đường chéo khi thích hợp.

»Ｅη⪫ι,

Xuất ra mảng một khi nó được quay trở lại hướng ban đầu của nó.