Вызов:

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

Восемь вариантов складывания: слева направо; справа налево; сверху донизу; снизу-вверх; к верхнее-левое-bottomright; topright к bottomleft; bottomleft к topright; bottomright к нижнему правому углу.

Пошаговые примеры:

Матрица ввода:

[[ 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, поскольку пустая матрица или матрица 1x1 не могут быть сложены.
• Вход матрицы всегда будет содержать неотрицательные числа в диапазоне $[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 спасибо Ник Кеннеди!

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

Сложенные значения заменяются пустыми строками. Объяснение:

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

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

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

Сложите массив горизонтально, когда это необходимо.

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

Сложите массив по диагонали, когда это необходимо.

»Ｅη⪫ι,

Выведите массив, как только он вернется в исходное положение.