Resta la matriz plegada

21

Reto:

Dada una matriz NxN donde norte2 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 una 'th fila [1, 1, 1, 1]será sustraída por la (una-1) ' th fila (habría sido (una-2) 'th fila para matrices de dimensiones impares); así se [1-0, 1-8, 1-6, 1-4]convierte [1, -7, -5, -3]. La (una+1) 'th fila [1, 25, 0, 75]será restada por la (una-2) ' th fila (habría sido (una-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. norte 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 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 , 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]]
Kevin Cruijssen
fuente
¿Importa el orden de las opciones de plegado?
Datos
Además, ¿podemos simplemente generar la matriz 8xNxN de todos los pliegues posibles?
Datos
¿No debería esta muestra de prueba Opción de plegado de entrada: de abajo hacia arriba Salida: [[-1,7,5,3], [0, -22,5, -68]] se voltea?
OrangeCherries
también para la matriz 2, 17-11 es 6, no 4?
OrangeCherries
@ExpiredData Como se especifica en las reglas, puede usar cualquier letra A-Za-zo cualquier número entero en el rango [-999,999], por lo que el orden no importa. Y lo siento, pero debe generar el pliegue correcto en función de la entrada, por lo que no está permitido generar los ocho.
Kevin Cruijssen

Respuestas:

5

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

Datos caducados
fuente
Sugerir en rows(a)lugar desize(a,2)
ceilingcat
5

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
Jonathan Allan
fuente
1
Ah bueno, me preguntaba si alguien haría uso de las opciones de entrada algo flexibles. Genial para ver cómo ha utilizado los valores para una conversión de base conveniente a código Jelly para evaluar el plegado deseado. :)
Kevin Cruijssen
Usando parte del código de mi respuesta y reutilizando el código común a ambos, aquí hay un byte de 34: tio.run/##y0rNyan8///…
Nick Kennedy
Si se nos permitieran números enteros de 16 bits, podría ser aún más corto
Nick Kennedy
Respuesta de 23 bytes no competitiva utilizando enteros de 16 bits como parámetro para seleccionar qué pliegue: tio.run/##y0rNyan8///…
Nick Kennedy
@NickKennedy - gracias. Me gusta la división y únete! Tendré que volver más tarde para cambiar completamente la descripción.
Jonathan Allan
3

JavaScript (ES6),  149 ... 133128  bytes

Toma entrada como (matrix)(d)0 0re7 7NaN

0 0=1=2=3=4 4=5 5=6 6=7 7=

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()
Arnauld
fuente
3

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.

Nick Kennedy
fuente
1

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 =).

Cerezas Naranjas
fuente
¿Cuántos bytes perdió al escribir "fin"?
Datos
no tienes que escribir fin?
OrangeCherries
Lo hace a menos que lo reestructure para que no sea un montón de declaraciones if / else y for
Datos
wow tbh mirando tu código hay toneladas de cosas que ni siquiera sabía que podías hacer en matlab.
OrangeCherries
No sé mucho sobre octava tbh, probablemente pueda ahorrar 50-100 bytes con bastante facilidad
Datos
1

Carbón , 78 77 bytes

F⁴«UMηE⮌η§μλ¿⁼ιθUMηEκ⎇‹⊕⊗νLη⁻μ§⮌κν⎇›⊕⊗νLηωμ¿⁼ι﹪θ⁴UMηEκ⎇‹λν⁻짧ηνλ⎇›λνωμ»Eη⪫ι,

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:

F⁴«≔UMηE⮌η§μλ

Gire la matriz cuatro veces.

¿⁼ιθUMηEκ⎇‹⊕⊗νLη⁻μ§⮌κν⎇›⊕⊗νLηωμ

Dobla la matriz horizontalmente cuando sea apropiado.

¿⁼ι﹪θ⁴UMηEκ⎇‹λν⁻짧ηνλ⎇›λνωμ

Dobla la matriz diagonalmente cuando sea apropiado.

»Eη⪫ι,

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

Neil
fuente