Herausforderung:

Ausgehend von einer NxN-Matrix, in der und eine von acht verschiedenen 'Faltungsoptionen' , wird ein 2D-Array / eine 2D-Liste mit den subtrahierten Werten ausgegeben.$N\geq2$

Die acht Faltoptionen sind: von links nach rechts; rechts nach links; oben nach unten; unten nach oben; von oben nach unten rechts; von rechts nach links; von links nach rechts; von unten nach oben.

Schritt für Schritt Beispiele:

Eingabematrix:

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

Mit der Faltoption von oben nach unten geben wir Folgendes als Ergebnis aus:

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

Warum? Wir falten von oben nach unten. Da die Matrixdimensionen gleichmäßig sind, müssen wir keine mittlere Ebene beibehalten, wie sie ist. Die -te Zeile wird von der -ten Zeile subtrahiert (wäre -te Zeile für ungeradzahlige Matrizen gewesen); so wird . Die -te Zeile wird dann von der -ten Zeile subtrahiert (wäre -te Zeile für ungeradzahlige Matrizen gewesen); so wird .$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]

Mit der Faltoption von rechts nach links unten (mit der gleichen Eingabematrix oben) geben wir stattdessen Folgendes als Ergebnis aus:

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

Mit folgenden klappbaren Subtraktionen:

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

Herausforderungsregeln:

• Sie können acht verschiedene Buchstaben [A-Za-z]oder verschiedene Zahlen im Bereich für die . Zahlen oder sind wahrscheinlich die gebräuchlichsten Optionen. Wenn Sie jedoch für einige intelligente Berechnungen unterschiedliche Zahlen innerhalb des Bereichs verwenden möchten, können Sie dies tun. Bitte geben Sie an, welche Falzoptionen Sie in Ihrer Antwort verwendet haben.$[-99,99]$$[1..8]$$[0..7]$
• Die Eingangsmatrix ist immer eine quadratische NxN-Matrix, sodass Sie keine rechteckigen NxM-Matrizen verarbeiten müssen. wird auch immer mindestens 2 sein, da eine leere oder 1x1-Matrix nicht gefaltet werden kann.$N$
• Die Eingabe der Matrix enthält immer nicht negative Zahlen im Bereich (die Zahlen in der Ausgabe liegen daher im Bereich ).$[0, 999]$$[-999, 999]$
• Bei der (anti-) diagonalen Faltung oder der vertikalen / horizontalen Faltung mit ungeraden Abmessungen bleibt die mittlere "Schicht" unverändert.
• I / O ist flexibel. Kann ein 2D-Array / eine Liste von ganzen Zahlen sein; Kann als durch Leerzeichen und Zeilenumbrüche getrennte Zeichenfolge zurückgegeben oder gedruckt werden. Sie können die Eingabematrix ändern und die Zahlen ersetzen, die weg sein sollen, nulloder eine Zahl außerhalb des [-999, 999]Bereichs, um anzuzeigen, dass sie weg sind. usw. usw.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

Eingangsmatrix 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]]

Eingangsmatrix 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]]

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

Probieren Sie es online!

-2 Bytes (und ein bisschen Aufräumen) dank Luis Mendo

+2 Bytes aufgrund der Korrektur für TB

1-indizierte Operationen für Werte von b von 1-8:

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

Das bereitete mir Kopfschmerzen, ich werde es später richtig golfen

Jelly ,  39  34 Bytes

_{Möglicherweise ist weiteres Golfen möglich, indem einige der beiden "Funktionen" kombiniert werden.}
... yep: -5 danke an NickKennedy!

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

Probieren Sie es online!

Eine dyadische Verknüpfung, die eine Ganzzahl (die Anweisung) und eine Liste von Zahlenlisten (die Matrix) akzeptiert.

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

Wie?

Der Link erzeugt Jelly Code, der dann mit M als Eingabe ausgewertet wird ...

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

Jede der acht Optionen ist dann:

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Ṛ

Diese (mit Ausnahme von 0und 4) wenden jeweils eine Transformation auf die MVerwendung von Z(transponieren), Ṛ(umkehren) und U(jeweils umkehren) an. dann eine von zwei Funktionen (siehe unten), dann die Umkehrung der Setup-Transformation (falls vorhanden) mit der Umkehrung des Codes.

Die zwei inneren Funktionen sind:

Œ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 Bytes

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

Probieren Sie es online!

Kommentiert

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

Jelly , 71 34 Bytes

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

Probieren Sie es online!

Test Suite

Ein volles Programm. Richtiges Argument ist die Matrix. Das linke Argument gibt die Art der Falte an:

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

Umgeschrieben, um 5-Bit-Bijektiv-Binärdaten als Eingabe zu verwenden. Beachten Sie, dass das oben angegebene Programm für mehrere Falzungen nicht wiederholt werden kann.

Oktave , 482 Bytes , 459 Bytes

Die Eingaben zur Entscheidung der Faltrichtung sind:
1) von links nach rechts
2) von unten nach oben
3) von rechts nach links
4) von oben nach unten
5) von tr nach bl
6) von br nach tl
7) von bl nach tr
8) von tl nach br
Jeder Anruf Generiert nur die angegebene Falte und nicht alle (was wahrscheinlich weniger Bytes erfordern würde). Das größte Problem ist, dass ich in diesem Fall nicht herausfinden kann, wie die Faltungen 1-4 und 5-8 in derselben Schleife platziert werden. Aber mindestens Oktave hat gut aussehende Matrizen.

    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

Probieren Sie es online!

Die Unterdrückung der Ausgabe kostet Byte. Ignorieren Sie daher alles, was nicht die return-Anweisung ist (ans =).

Kohle , 78 77 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Verwendet die folgenden Faltoptionen:

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

Gefaltete Werte werden durch leere Zeichenfolgen ersetzt. Erläuterung:

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

Drehen Sie das Array viermal.

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

Falten Sie das Array bei Bedarf horizontal.

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

Falten Sie das Array bei Bedarf diagonal.

»Ｅη⪫ι,

Geben Sie das Array aus, sobald es wieder in seine ursprüngliche Ausrichtung gedreht wurde.