Виклик:

Дано матрицю NxN, де$N\geq2$ та один із восьми різних «варіантів складання», виведіть двовимірний масив / список із відніманими значеннями.

Вісім варіантів складання - це: зліва направо; справа наліво; зверху вниз; знизу вгору; верху донизу; зверху донизу; віднизу до верху; від низу до верху.

Покрокові приклади:

Матриця введення:

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

Складаючи варіант згори донизу, в результаті виводимо наступне:

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

Чому? Складаємо зверху вниз. Оскільки розміри матриці рівні, ми не маємо середнього шару для збереження таким, яким є. 'Ї рядок буде вирахувана з ( з - 1 ) -й рядком (були б ( - 2 ) -й рядком для непарних матриць розмірності); так стає . Потім ( a + 1 ) '-го рядка буде віднімано ( a - 2 ) '-й рядок (був би ( a - 3 ) '-й рядок для матриць непарних розмірів); так$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].

За допомогою опції складання замість неї (з тією ж матрицею введення вгорі) виводимо наступне як результат:

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

З наступними складними відніманнями:

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

Правила виклику:

• Для опцій складання можна використовувати будь-які вісім відмінних літер [A-Za-z]або виразні цифри в діапазоні $[-99,99]$ . Числа $[1..8]$ або $[0..7]$ це, мабуть, найпоширеніші варіанти, але якщо ви хочете використовувати різні числа в межах діапазону для певних розумних обчислень, сміливо робіть це. Будь ласка, вкажіть, які варіанти складання використовували у своїй відповіді.
• Матриця введення завжди буде квадратною матрицею NxN, тому вам не доведеться обробляти будь-які прямокутні матриці NxM. $N$ також завжди буде щонайменше 2, оскільки порожню або 1х1 матрицю неможливо скласти.
• Вхід матриці завжди буде містити негативні числа в діапазоні $[0, 999]$ (отже, цифри на виході будуть знаходитися в діапазоні $[-999, 999]$ ).
• При (проти) діагональній складці або вертикальній / горизонтальній складності непарних розмірів, середній "шар" залишиться незмінним.
• Введення / виведення гнучко. Може представляти собою 2D масив / список цілих чисел; може бути повернуто або надруковано у вигляді рядка з обмеженим пробілом та новим рядком; ви можете змінити матрицю введення та замінити числа, які слід пропустити, nullабо число поза [-999, 999]діапазону, щоб вказати, що вони пропали; тощо.

Загальні правила:

• Це код-гольф , тому найкоротша відповідь у байтах виграє.
  Не дозволяйте мовам коду-гольфу відштовхувати вас від публікації відповідей з не кодовими гольф-мовами. Спробуйте придумати якомога коротшу відповідь на "будь-яку" мову програмування.
• Для вашої відповіді застосовуються стандартні правила з правилами вводу / виводу за замовчуванням , тому вам дозволяється використовувати STDIN / STDOUT, функції / метод із відповідними параметрами та повним програмами типу повернення. Твій дзвінок.
• Лазівки за замовчуванням заборонені.
• Якщо можливо, додайте посилання з тестом для вашого коду (тобто TIO ).
• Також настійно рекомендується додавати пояснення до своєї відповіді.

Тестові приклади:

Матриця введення 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]]

Матриця введення 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]]

Октава , 256 248 244 248 байт

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}

Спробуйте в Інтернеті!

-2 байти (і досить прибирати) завдяки Луїсу Мендо

+2 байти через корекцію на туберкульоз

1-Індексовані операції для значень b від 1-8:

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

Це дало мені головний біль, пізніше я буду гольфу належним чином

Желе ,  39  34 байт

_{Можливо, можливий подальший гольф, поєднуючи деякі з двох "функцій".}
... так: -5 завдяки NickKennedy!

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

Спробуйте в Інтернеті!

Діадичне посилання, що приймає ціле число (інструкція) та список списків чисел (матриця).

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

Як?

Посилання створює Jelly-код, який потім оцінюється, використовуючи M як вхідний ...

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

Кожен з восьми варіантів є:

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Ṛ

Ці (за винятком 0і 4) застосовують перетворення, Mвикористовуючи деякі Z(транспонировать), Ṛ(обернути) та U(перевернути кожен); то одна з двох функцій (див. нижче), то обернена трансформація настройки (якщо вона була одна), реалізована з реверсом коду.

Дві внутрішні функції:

Œ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 байт

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

Спробуйте в Інтернеті!

Прокоментував

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

Желе , 71 34 байт

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

Спробуйте в Інтернеті!

Тестовий сюїт

Повна програма. Правильний аргумент - матриця. Аргумент зліва - тип складки:

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

Перезаписаний, щоб використовувати 5-бітний бієктивний двійковий файл як вхід. Зауважте, що наведена вище програма не працюватиме повторно для декількох складок.

Октава , 482 байти , 459 байт

Вхідні дані для вирішення напрямків складання:
1) зліва направо
2) знизу вгору
3) праворуч ліворуч
4) зверху вниз
5) tr до bl
6) br to tl
7) bl до tr
8) tl до br
Кожен дзвінок генерує лише вказану складку, а не всі (що, ймовірно, займе менше байтів). Найбільша проблема полягає в тому, що в цьому випадку я не можу зрозуміти, як скласти складки 1-4 і 5-8 в одну петлю. Але принаймні в октаві є красиві на вигляд матриці.

    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

Спробуйте в Інтернеті!

Придушення виводу коштує в байтах, тому ігноруйте все, що не є оператором return (ans =).

Вугілля деревне , 78 77 байт

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Використовує такі варіанти складання:

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

Складені значення замінюються порожніми рядками. Пояснення:

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

Поверніть масив чотири рази.

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

Складіть масив горизонтально, якщо це доречно.

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

Складіть масив по діагоналі, коли це доречно.

»Ｅη⪫ι,

Після повернення масиву повернути його до початкової орієнтації.