Sfida:

Data una matrice NxN in cui e una delle otto distinte "opzioni di piegatura", un array / elenco 2D con i valori sottratti.$N\geq2$

Le otto opzioni di piegatura sono: da sinistra a destra; da destra a sinistra; dall'alto al basso; dal basso verso l'alto; topleft-to-bottomright; topright-to-bottomleft; bottomleft-to-topright; bottomright-to-topleft.

Esempi passo passo:

Matrice di input:

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

Con l'opzione di piegatura dall'alto verso il basso, produciamo il seguente risultato:

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

Perché? Pieghiamo dall'alto verso il basso. Poiché le dimensioni della matrice sono pari, non abbiamo uno strato intermedio da conservare così com'è. La riga "th" verrà sottratta dalla "th row (sarebbe stata " th row per matrici di dimensioni dispari); così diventa . La riga sarà quindi sottratta dalla riga (sarebbe stata la riga per le matrici di dimensioni dispari); così diventa .$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]

Con l'opzione di piegatura dal basso verso l'alto-sinistra invece (con la stessa matrice di input sopra) produciamo il risultato seguente:

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

Con le seguenti sottrazioni pieghevoli:

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

Regole della sfida:

• È possibile utilizzare otto lettere [A-Za-z]o numeri distinti nell'intervallo per le opzioni di piegatura. I numeri o sono probabilmente le opzioni più comuni, ma se si desidera utilizzare numeri diversi nell'intervallo per alcuni calcoli intelligenti, non esitate a farlo. Indica quali opzioni di piegatura hai utilizzato nella tua risposta.$[-99,99]$$[1..8]$$[0..7]$
• La matrice di input sarà sempre una matrice NxN quadrata, quindi non è necessario gestire matrici NxM rettangolari. sarà sempre almeno 2, poiché una matrice vuota o 1x1 non può essere piegata.$N$
• L'input della matrice conterrà sempre numeri non negativi nell'intervallo (i numeri nell'output saranno quindi nell'intervallo ).$[0, 999]$$[-999, 999]$
• Con la piegatura (anti) diagonale o la piegatura verticale / orizzontale di dimensioni dispari, lo 'strato' centrale rimarrà invariato.
• L'I / O è flessibile. Può essere un array / elenco 2D di numeri interi; può essere restituito o stampato come stringa delimitata da spazio e newline; puoi modificare la matrice di input e sostituire i numeri che dovrebbero essere andati con nullo un numero al di fuori [-999, 999]dell'intervallo per indicare che non ci sono più; ecc ecc.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

Input-matrix 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]]

Input-matrix 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]]

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

Provalo online!

-2 byte (e un po 'di riordino) grazie a Luis Mendo

+2 byte a causa della correzione per TB

Operazioni 1-indicizzate per i valori di b da 1-8:

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

Questo mi ha dato un mal di testa, lo golfò correttamente dopo

Gelatina ,  39  34 byte

_{È possibile giocare a golf ulteriormente combinando alcune delle due "funzioni".}
... sì: -5 grazie a NickKennedy!

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

Provalo online!

Un collegamento diadico che accetta un numero intero (l'istruzione) e un elenco di elenchi di numeri (la matrice).

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

Come?

Il collegamento crea il codice Jelly che viene quindi valutato utilizzando M come input ...

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

Ciascuna delle otto opzioni sono quindi:

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Ṛ

Ciascuno (tranne 0e 4) applica una trasformazione Mall'utilizzo di alcuni di Z(trasposizione), Ṛ(inversione) e U(inversione ciascuno); quindi una delle due funzioni (vedi sotto), quindi l'inverso della trasformazione dell'installazione (se presente) implementata con il contrario del codice.

Le due funzioni interne sono:

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

Provalo online!

Commentate

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 byte

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

Provalo online!

Test Suite

Un programma completo. Il giusto argomento è la matrice. L'argomento di sinistra è il tipo di piega:

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

Riscritto per utilizzare binario binario a 5 bit come input. Si noti che il programma sopra indicato non funzionerà ripetutamente per più pieghe.

Ottava , 482 byte , 459 byte

Gli input per decidere le direzioni di piegatura sono:
1) da sinistra a destra
2) dal basso verso l'alto
3) da destra a sinistra
4) dall'alto verso il basso
5) da tr a bl
6) da br a tl
7) da bl a tr
8) da tl a br
Ogni chiamata genera solo la piega specificata, anziché tutte (che probabilmente richiederebbe meno byte). Il problema più grande è che in questo caso non riesco a capire come mettere le pieghe 1-4 e 5-8 nello stesso loop. Ma almeno l'ottava ha matrici piacevoli.

    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

Provalo online!

La soppressione dell'output costa byte, quindi ignora tutto ciò che non è l'istruzione return (ans =).

Carbone , 78 77 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Utilizza le seguenti opzioni di piegatura:

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

I valori piegati vengono sostituiti da stringhe vuote. Spiegazione:

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

Ruota l'array quattro volte.

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

Piegare l'array in senso orizzontale quando appropriato.

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

Piegare l'array in diagonale quando appropriato.

»Ｅη⪫ι,

Invia l'array una volta ruotato di nuovo al suo orientamento originale.