Reto:

Dada una matriz NxN donde $N\geq2$ y una de las ocho 'opciones de plegado' distintas, genera una matriz / lista 2D con los valores restados.

Las ocho opciones de plegado son: de izquierda a derecha; De derecha a izquierda; de arriba hacia abajo; abajo hacia arriba; de arriba a abajo a la derecha; de derecha a izquierda de abajo a la izquierda hacia la derecha; de derecha a izquierda.

Ejemplos paso a paso:

Matriz de entrada:

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

Con la opción de plegado de arriba a abajo mostramos lo siguiente como resultado:

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

¿Por qué? Doblamos de arriba hacia abajo. Dado que las dimensiones de la matriz son pares, no tenemos una capa intermedia para preservar como es. La $a$ 'th fila [1, 1, 1, 1]será sustraída por la $(a-1)$ ' th fila (habría sido $(a-2)$ 'th fila para matrices de dimensiones impares); así se [1-0, 1-8, 1-6, 1-4]convierte [1, -7, -5, -3]. La $(a+1)$ 'th fila [1, 25, 0, 75]será restada por la $(a-2)$ ' th fila (habría sido $(a-3)$ 'th fila para matrices de dimensiones impares); asi que[1-1, 25-3, 0-5, 75-7] convierte [0, 22, -5, 68].

Con la opción de plegado de abajo a derecha en su lugar (con la misma matriz de entrada anterior), mostramos lo siguiente como resultado:

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

Con las siguientes restas plegables:

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

Reglas de desafío:

• Puede usar ocho letras distintas [A-Za-z]o números distintos en el rango $[-99,99]$ para las opciones de plegado. Los números $[1..8]$ o $[0..7]$ son probablemente las opciones más comunes, pero si desea usar números diferentes dentro del rango para algunos cálculos inteligentes, no dude en hacerlo. Indique qué opciones de plegado ha utilizado en su respuesta.
• La matriz de entrada siempre será una matriz cuadrada de NxN, por lo que no tiene que manejar ninguna matriz rectangular de NxM. $N$ también siempre será al menos 2, ya que una matriz vacía o 1x1 no se puede plegar.
• La entrada de la matriz siempre contendrá números no negativos en el rango $[0, 999]$ (por lo tanto, los números en la salida estarán en el rango $[-999, 999]$ ).
• Con el plegado (anti-) diagonal o el plegado vertical / horizontal de dimensiones impares, la 'capa' central no se modificará.
• I / O es flexible. Puede ser una matriz 2D / lista de enteros; puede devolverse o imprimirse como una cadena delimitada por espacios y líneas nuevas; puede modificar la matriz de entrada y reemplazar los números con los que debería haberse ido nullo un número fuera del [-999, 999]rango para indicar que se han ido; etcétera etcétera.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

Matriz de entrada 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]]

Matriz de entrada 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]]

Octava , 256 248 244 248 bytes

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}

Pruébalo en línea!

-2 bytes (y un poco de ordenar) gracias a Luis Mendo

+2 bytes debido a la corrección de TB

1-Operaciones indexadas para valores de b de 1-8:

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

Esto me dio dolor de cabeza, lo jugaré correctamente más tarde

Jalea ,  39  34 bytes

_{Posiblemente hay más golf posible combinando algunas de las dos "funciones".}
...Sí: -5 gracias a NickKennedy!

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

Pruébalo en línea!

Un enlace diádico que acepta un número entero (la instrucción) y una lista de listas de números (la matriz).

$[-99,99]$ para nuestro beneficio, y por lo tanto tiene el siguiente mapeo aparentemente extraño:

           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

¿Cómo?

El enlace crea un código Jelly que luego se evalúa utilizando M como entrada ...

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

Cada una de las ocho opciones son entonces:

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Ṛ

Cada uno de ellos (excepto 0y 4) aplica una transformación al Muso de algunos de Z(transposición), Ṛ(inversa) yU (revertir cada uno); luego una de las dos funciones (ver más abajo), luego la inversa de la transformación de configuración (si hubiera una) implementada con el reverso del código.

Las dos funciones internas son:

Œ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 ... 133128  bytes

Toma entrada como (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]))

Pruébalo en línea!

Comentado

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

Gelatina , 71 34 bytes

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

Pruébalo en línea!

Banco de pruebas

Un programa completo El argumento correcto es la matriz. El argumento izquierdo es el tipo de pliegue:

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

Reescrito para usar binario biyectivo de 5 bits como entrada. Tenga en cuenta que el programa dado anteriormente no funcionará repetidamente para pliegues múltiples.

Octava , 482 bytes , 459 bytes

Las entradas para decidir las direcciones de plegado son:
1) de izquierda a derecha
2) de abajo a arriba
3) de derecha a izquierda
4) de arriba a abajo
5) tr a bl
6) br a tl
7) bl a tr
8) tl a br
Cada llamada solo genera el pliegue especificado, en lugar de todos ellos (lo que probablemente tomaría menos bytes). El mayor problema es que para este caso no puedo entender cómo poner los pliegues 1-4 y 5-8 en el mismo bucle. Pero al menos la octava tiene bonitas matrices.

    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

Pruébalo en línea!

La supresión de salida cuesta bytes, así que ignore todo lo que no sea la declaración de retorno (ans =).

Carbón , 78 77 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Utiliza las siguientes opciones de plegado:

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

Los valores plegados se reemplazan por cadenas vacías. Explicación:

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

Gire la matriz cuatro veces.

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

Dobla la matriz horizontalmente cuando sea apropiado.

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

Dobla la matriz diagonalmente cuando sea apropiado.

»Ｅη⪫ι,

Salida de la matriz una vez que se gira de nuevo a su orientación original.