Subtrahieren Sie die gefaltete Matrix

21

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.N2

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 .ein[1, 1, 1, 1](ein-1)(ein-2)[1-0, 1-8, 1-6, 1-4][1, -7, -5, -3](ein+1)[1, 25, 0, 75](ein-2)(ein-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 , 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]]
Kevin Cruijssen
quelle
Ist die Reihenfolge der Faltoptionen wichtig?
Abgelaufene Daten
Können wir auch einfach die 8xNxN-Matrix aller möglichen Falten ausgeben?
Daten
Sollte dieses Testmuster nicht gekippt werden?
OrangeCherries
auch für Matrix 2 ist 17-11 6, nicht 4?
OrangeCherries
@ExpiredData Wie in den Regeln angegeben, können Sie einen beliebigen Buchstaben A-Za-zoder eine beliebige Ganzzahl im Bereich verwenden [-999,999], sodass die Reihenfolge keine Rolle spielt. Tut mir leid, aber Sie müssen die richtige Falte basierend auf der Eingabe ausgeben, sodass die Ausgabe aller acht nicht zulässig ist.
Kevin Cruijssen

Antworten:

5

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

Abgelaufene Daten
quelle
Schlagen Sie rows(a)stattdessen vorsize(a,2)
ceilingcat
5

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
Jonathan Allan
quelle
1
Ah schön, ich habe mich gefragt, ob irgendjemand die etwas flexiblen Eingabemöglichkeiten nutzen würde! Cool, um zu sehen, wie Sie die Werte für eine bequeme Basisumwandlung in Jelly-Code verwendet haben, um die gewünschte Faltung zu ermitteln. :)
Kevin Cruijssen
Unter Verwendung eines Teils des Codes aus meiner Antwort und Wiederverwendung des Codes, der beiden gemeinsam ist, hier ein 34-Byte-Code: tio.run/##y0rNyan8///…
Nick Kennedy
Wenn wir 16-Bit-Ganzzahlen hätten, könnte es noch kürzer sein
Nick Kennedy
Nicht konkurrierende 23-Byte-Antwort mit 16-Bit-Ganzzahlen als Parameter für die Auswahl der Falte: tio.run/##y0rNyan8///…
Nick Kennedy
@ NickKennedy - danke. Ich mag die Trennung und mach mit! Ich muss später wiederkommen, um die Beschreibung vollständig zu ändern.
Jonathan Allan
3

JavaScript (ES6),  149 ... 133  128 Bytes

(matrix)(d)0d7NaN

0=1=2=3=4=5=6=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]))

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

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.

Nick Kennedy
quelle
1

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

OrangeCherries
quelle
Wie viele Bytes haben Sie verloren, als Sie "end" geschrieben haben?
Daten
musst du nicht ende schreiben
OrangeCherries
Sie tun dies, es sei denn, Sie restrukturieren es so, dass es kein Haufen von if / else und Anweisungen ist
Abgelaufene Daten
Wow, wenn ich mir deinen Code ansehe, gibt es Unmengen von Dingen, von denen ich nicht mal wusste, dass du sie in Matlab machen kannst.
OrangeCherries
Ich weiß nicht viel über Oktaven, aber es kann wahrscheinlich ziemlich leicht 50-100 Bytes einsparen
Abgelaufene Daten
1

Kohle , 78 77 Bytes

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

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:

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

Drehen Sie das Array viermal.

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

Falten Sie das Array bei Bedarf horizontal.

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

Falten Sie das Array bei Bedarf diagonal.

»Eη⪫ι,

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

Neil
quelle