Défi:

Étant donné une matrice NxN où et l'une des huit «options de pliage» distinctes, un tableau / liste 2D avec les valeurs soustraites.$N\geq2$

Les huit options de pliage sont: de gauche à droite; de droite à gauche; de haut en bas; de bas en haut; de haut en bas à droite; de droite à gauche; de gauche à droite; de bas en haut à gauche.

Exemples étape par étape:

Matrice d'entrée:

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

Avec l'option de pliage de haut en bas, nous produisons les résultats suivants:

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

Pourquoi? Nous plions de haut en bas. Étant donné que les dimensions de la matrice sont uniformes, nous n'avons pas de couche intermédiaire à conserver en l'état. La 'e ligne sera soustraite de la ' e ligne (aurait été 'e ligne pour les matrices de dimension impaire); devient ainsi . La 'ème ligne sera alors soustraite par la ' ème ligne (aurait été 'ème ligne pour les matrices de dimension impaire); devient ainsi .$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]

Avec l'option de pliage de droite à droite à la place (avec la même matrice d'entrée ci-dessus), nous produisons les résultats suivants:

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

Avec les soustractions de pliage suivantes:

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

Règles du défi:

• Vous pouvez utiliser huit lettres [A-Za-z]ou nombres distincts dans la plage pour les options de pliage. Les nombres ou sont probablement les options les plus courantes, mais si vous souhaitez utiliser des nombres différents dans la plage pour certains calculs intelligents, n'hésitez pas à le faire. Veuillez indiquer les options de pliage que vous avez utilisées dans votre réponse.$[-99,99]$$[1..8]$$[0..7]$
• La matrice d'entrée sera toujours une matrice NxN carrée, vous n'avez donc pas à gérer de matrices NxM rectangulaires. sera également toujours au moins 2, car une matrice vide ou 1x1 ne peut pas être pliée.$N$
• L'entrée de la matrice contiendra toujours des nombres non négatifs dans la plage (les nombres dans la sortie seront donc dans la plage ).$[0, 999]$$[-999, 999]$
• Avec le pliage (anti) diagonal ou le pliage vertical / horizontal de dimensions impaires, la «couche» centrale restera inchangée.
• Les E / S sont flexibles. Peut être un tableau 2D / liste d'entiers; peut être retourné ou imprimé sous forme de chaîne délimitée par des espaces et des sauts de ligne; vous pouvez modifier la matrice d'entrée et remplacer les nombres qui devraient disparaître nullou un nombre en dehors de la [-999, 999]plage pour indiquer qu'ils sont partis; etc.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test:

Matrice d'entrée 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]]

Matrice d'entrée 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]]

Octave , 256 248 244 248 octets

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}

Essayez-le en ligne!

-2 octets (et un peu de rangement) grâce à Luis Mendo

+2 octets en raison de la correction pour TB

Opérations 1-indexées pour les valeurs de b de 1-8:

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

Cela m'a donné mal à la tête, je le jouerai correctement plus tard

Gelée ,  39  34 octets

_{Il est possible de jouer au golf en combinant certaines des deux "fonctions".}
... oui: -5 grâce à NickKennedy!

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

Essayez-le en ligne!

Un lien dyadique acceptant un entier (l'instruction) et une liste de listes de nombres (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

Comment?

Le lien crée du code Jelly qui est ensuite évalué en utilisant M comme entrée ...

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

Chacune des huit options est alors:

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Ṛ

Celles-ci (sauf 0et 4) appliquent chacune une transformation à l' Mutilisation de Z(transposer), Ṛ(inverser) et U(inverser chacune); puis l'une des deux fonctions (voir ci-dessous), puis l'inverse de la transformation de configuration (s'il y en avait une) implémentée avec l'inverse du code.

Les deux fonctions internes sont:

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

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

Essayez-le en ligne!

Commenté

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

Gelée , 71 34 octets

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

Essayez-le en ligne!

Suite de tests

Un programme complet. Le bon argument est la matrice. L'argument de gauche est le type de pli:

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

Réécrit pour utiliser le binaire bijectif 5 bits en entrée. Notez que le programme ci-dessus ne fonctionnera pas de manière répétée pour plusieurs plis.

Octave , 482 octets , 459 octets

Les entrées pour décider des directions de pliage sont:
1) de gauche à droite
2) de bas en haut
3) de droite à gauche
4) de haut en bas
5) tr à bl
6) br à tl
7) bl à tr
8) tl à br
Chaque appel génère uniquement le pli spécifié, plutôt que tous (ce qui prendrait probablement moins d'octets). Le plus gros problème est que dans ce cas, je ne peux pas comprendre comment mettre les plis 1-4 et 5-8 dans la même boucle. Mais au moins l'octave a de belles 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

Essayez-le en ligne!

La suppression de sortie coûte des octets, donc ignorez tout ce qui n'est pas l'instruction de retour (ans =).

Fusain , 78 77 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Utilise les options de pliage suivantes:

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

Les valeurs pliées sont remplacées par des chaînes vides. Explication:

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

Faites pivoter le tableau quatre fois.

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

Pliez le tableau horizontalement, le cas échéant.

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

Pliez le tableau en diagonale, le cas échéant.

»Ｅη⪫ι,

Sortez la matrice une fois qu'elle est retournée dans son orientation d'origine.