Wyzwanie:

Biorąc pod uwagę macierz NxN, gdzie i jedną z ośmiu różnych „opcji składania”, wyprowadza tablicę / listę 2D z odjętymi wartościami.$N\geq2$

Osiem opcji składania to: od lewej do prawej; od prawej do lewej; od góry do dołu; od dołu do góry; od lewej do prawej; od góry do dołu; od dołu do lewej do prawej; od dołu do góry w lewo.

Przykłady krok po kroku:

Macierz wejściowa:

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

Dzięki opcji składania od góry do dołu otrzymujemy następujące wyniki:

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

Czemu? Składamy od góry do dołu. Ponieważ wymiary matrycy są równe, nie mamy środkowej warstwy do zachowania w obecnej postaci. -Tym rząd zostanie odjęta przez -tym rzędu (byłby -tym rzędu dla nieparzystych macierzy wymiarów); tak się staje . -tym rząd zostanie odjęta przez -tym rzędu (byłby -tym rzędu dla nieparzystych macierzy wymiarów); tak się staje .$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]

Zamiast opcji składania od dołu do góry w lewo (z tą samą matrycą wejściową powyżej) otrzymujemy następujące wyniki:

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

Z następującymi składanymi odejmowaniami:

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

Zasady konkursu:

• Możesz użyć dowolnych ośmiu różnych liter [A-Za-z]lub odrębnych cyfr z zakresu dla opcji składania. Liczby lub są prawdopodobnie najczęstszymi opcjami, ale jeśli chcesz użyć różnych liczb w zakresie do niektórych inteligentnych obliczeń, możesz to zrobić. Podaj, które opcje składania wykorzystałeś w swojej odpowiedzi.$[-99,99]$$[1..8]$$[0..7]$
• Macierz wejściowa zawsze będzie kwadratową macierzą NxN, więc nie musisz obsługiwać żadnych prostokątnych macierzy NxM. $N$ będzie również zawsze wynosić co najmniej 2, ponieważ nie można złożyć pustej matrycy lub matrycy 1x1.
• Dane wejściowe macierzy zawsze będą zawierać nieujemne liczby w zakresie $[0, 999]$ (dlatego liczby na wyjściu będą zatem w zakresie $[-999, 999]$ ).
• Przy składaniu (anty-) ukośnym lub składaniu pionowym / poziomym w nieparzystych wymiarach środkowa „warstwa” pozostanie niezmieniona.
• I / O jest elastyczny. Może być tablicą 2D / listą liczb całkowitych; może być zwrócony lub wydrukowany jako ciąg rozdzielany spacjami i znakami nowej linii; możesz zmodyfikować macierz wejściową i zastąpić liczby, które powinny zniknąć, nulllub liczby spoza [-999, 999]zakresu, aby wskazać, że zniknęły; itd itd.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
• Zalecane jest również dodanie wyjaśnienia do odpowiedzi.

Przypadki testowe:

Matryca wejściowa 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]]

Matryca wejściowa 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]]

Oktawa , 256 248 244 248 bajtów

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}

Wypróbuj online!

-2 bajty (i odrobina porządków) dzięki Luisowi Mendo

+2 bajty z powodu korekty TB

Operacje 1-indeksowane dla wartości b od 1-8:

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

To sprawiło mi ból głowy, później odpowiednio go zagram

Galaretka ,  39  34 bajtów

_{Możliwe jest dalsze granie w golfa poprzez połączenie niektórych z dwóch „funkcji”.}
... tak: -5 dzięki NickKennedy!

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

Wypróbuj online!

Dyadyczny link akceptujący liczbę całkowitą (instrukcja) i listę list liczb (macierz).

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

W jaki sposób?

Link tworzy kod Jelly, który jest następnie oceniany przy użyciu M jako danych wejściowych ...

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

Każda z ośmiu opcji to:

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Ṛ

Każdy z nich (z wyjątkiem 0i 4) stosuje transformację Mprzy użyciu niektórych Z(transponuj), Ṛ(odwróć) i U(odwróć każdy); następnie jedna z dwóch funkcji (patrz poniżej), a następnie odwrotność transformacji konfiguracji (jeśli była taka) zaimplementowana z odwrotnością kodu.

Dwie wewnętrzne funkcje to:

Œ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 bajtów

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

Wypróbuj online!

Skomentował

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

Galaretka , 71 34 bajtów

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

Wypróbuj online!

Pakiet testowy

Pełny program. Właściwym argumentem jest macierz. Lewy argument to rodzaj fold:

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

Przepisano, aby użyć 5-bitowego binarnego binarnego jako wejścia. Pamiętaj, że program podany powyżej nie będzie działał wielokrotnie dla wielu fałd.

Oktawa , 482 bajtów , 459 bajtów

Dane do decydowania o kierunkach składania są:
1) od lewej do prawej
2) od dołu do góry
3) od prawej do lewej
4) od góry do dołu
5) od tr do bl
6) od br do tl
7) od bl do tr
8) od tl do br
Każde połączenie generuje tylko określone fold, a nie wszystkie (co prawdopodobnie zajęłoby mniej bajtów). Największy problem polega na tym, że w tym przypadku nie mogę dowiedzieć się, jak umieścić fałdy 1-4 i 5-8 w tej samej pętli. Ale przynajmniej oktawa ma ładnie wyglądające matryce.

    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

Wypróbuj online!

Eliminacja wyjściowa kosztuje bajty, więc zignoruj ​​wszystko, co nie jest instrukcją return (ans =).

Węgiel drzewny , 78 77 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wykorzystuje następujące opcje składania:

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

Złożone wartości są zastępowane pustymi ciągami. Wyjaśnienie:

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

Obróć tablicę cztery razy.

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

W razie potrzeby złóż tablicę poziomo.

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

W razie potrzeby złóż tablicę po przekątnej.

»Ｅη⪫ι,

Wyjmij tablicę po jej obróceniu do pierwotnej orientacji.