Irá ser dada uma matriz quadrada de inteiros M e outro inteiro positivo n , estritamente menor que o tamanho de M . Sua tarefa é gerar todas as sub-matrizes quadradas de M de tamanho n .

Para os fins deste desafio, um sub-matriz quadrada é um grupo de adjacentes linhas e colunas contido em H .

Formatos de entrada / saída

Você é livre para escolher outros formatos razoáveis; estes são apenas alguns exemplos.

Entrada

• Uma matriz no tipo de matriz nativa (se o seu idioma tiver um)
• Uma matriz 2D (uma matriz de matrizes 1D, cada uma correspondendo a uma linha / uma coluna)
• Uma matriz 1D (uma vez que a matriz é sempre quadrada)
• Uma string (você escolheu o espaçamento, mas não abuse disso de nenhuma maneira), etc.

Resultado

• Uma matriz de matrizes.
• Uma matriz 4D, em que cada elemento (lista 3D) representa as sub-matrizes em uma linha / coluna.
• Uma matriz 3D, em que cada elemento (lista 2D) representa uma sub-matriz.
• Uma representação em cadeia das sub-matrizes resultantes, etc.

Especificações

• Você também pode escolher o tamanho de M como entrada. É garantido que seja pelo menos 2 .
• A orientação da saída é arbitrária: você pode optar por gerar as submatrizes como listas de colunas ou listas de linhas, mas sua escolha deve ser consistente.
• Você pode competir em qualquer linguagem de programação e pode receber e fornecer saída por qualquer método padrão , observando que essas brechas são proibidas por padrão.
• Isso é código-golfe , então a submissão mais curta (em bytes) para todos os idiomas vence.

Exemplo

Dado n = 3 e M :

 1 2 3 4
 5 6 7 8
 9 10 11 12
13 14 15 16

As possíveis submatrizes 3x3 são:

+ ------- + + -------- + 1 2 3 4 1 2 3 4
1 2 3 | 4 1 | 2 3 4 | + -------- + + -------- +
5 6 7 | 8 5 | 6 7 8 | | 5 6 7 | 8 5 | 6 7 8 |
| 9 10 11 | 12 9 | 10 11 12 | | 9 10 11 | 12 9 | 10 11 12 |
+ ------- + + -------- + | 13 14 15 | 16 13 | 14 15 16 |
13 14 15 16 13 14 15 16 + -------- + + -------- +

Portanto, o resultado seria:

[[[1, 2, 3], [5, 6, 7], [9, 10, 11]], [[2, 3, 4], [6, 7, 8], [10, 11, 12]], [[5, 6, 7], [9, 10, 11], [13, 14, 15]], [[6, 7, 8], [10, 11, 12], [14, 15, 16]]]

Como observado acima, uma saída de:

[[[1, 5, 9], [2, 6, 10], [3, 7, 11]], [[2, 6, 10], [3, 7, 11], [4, 8, 12]], [[5, 9, 13], [6, 10, 14], [7, 11, 15]], [[6, 10, 14], [7, 11, 15], [8, 12, 16]]]

também seria aceitável, se você optar por retornar as submatrizes como listas de linhas.

Casos de teste

As entradas M, n :

[[1,2,3],[5,6,7],[9,10,11]], 1
[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], 3
[[100,-3,4,6],[12,11,14,8],[0,0,9,3],[34,289,-18,3]], 2
[[100,-3,4,6],[12,11,14,8],[9,10,11,12],[13,14,15,16]], 3

E as saídas correspondentes (sub-matrizes fornecidas como listas de linhas):

[[[1]],[[2]],[[3]],[[5]],[[6]],[[7]],[[9]],[[10]],[[11]]]
[[[1,2,3],[5,6,7],[9,10,11]],[[2,3,4],[6,7,8],[10,11,12]],[[5,6,7],[9,10,11],[13,14,15]],[[6,7,8],[10,11,12],[14,15,16]]]
[[[100,-3],[12,11]],[[-3,4],[11,14]],[[4,6],[14,8]],[[12,11],[0,0]],[[11,14],[0,9]],[[14,8],[9,3]],[[0,0],[34,289]],[[0,9],[289,-18]],[[9,3],[-18,3]]]
[[[100,-3,4],[12,11,14],[9,10,11]],[[-3,4,6],[11,14,8],[10,11,12]],[[12,11,14],[9,10,11],[13,14,15]],[[11,14,8],[10,11,12],[14,15,16]]]

Ou, como listas de colunas:

[[[1]],[[2]],[[3]],[[5]],[[6]],[[7]],[[9]],[[10]],[[11]]]
[[[1,5,9],[2,6,10],[3,7,11]],[[2,6,10],[3,7,11],[4,8,12]],[[5,9,13],[6,10,14],[7,11,15]],[[6,10,14],[7,11,15],[8,12,16]]]
[[[100,12],[-3,11]],[[-3,11],[4,14]],[[4,14],[6,8]],[[12,0],[11,0]],[[11,0],[14,9]],[[14,9],[8,3]],[[0,34],[0,289]],[[0,289],[9,-18]],[[9,-18],[3,3]]]
[[[100,12,9],[-3,11,10],[4,14,11]],[[-3,11,10],[4,14,11],[6,8,12]],[[12,9,13],[11,10,14],[14,11,15]],[[11,10,14],[14,11,15],[8,12,16]]]]

05AB1E , 8 bytes

2FεŒsù}ø

Experimente online!

Explicação

2F            # 2 times do:
  ε    }      # apply to each element in the input matrix (initially rows)
   Œsù        # get a list of sublists of size input_2
        ø     # transpose (handling columns on the second pass of the loop)

MATL , 4 bytes

thYC

Entradas são n, então M.

A saída é uma matriz, em que cada coluna contém todas as colunas de uma submatriz.

Experimente online!

Explicação

thY    % Address the compiler with a formal, slightly old-fashioned determiner
C      % Convert input to ouput

Mais a sério, tleva a entrada n implicitamente e a duplica na pilha. hconcatena ambas as cópias de n , produzindo a matriz [n, n] . YCpega a entrada M implicitamente, extrai todos os seus blocos de tamanho [n, n] e os organiza como colunas na ordem principal da coluna. Isso significa que as colunas de cada bloco são empilhadas verticalmente para formar uma única coluna.

APL (Dyalog Unicode) , ^{SBCS de} 26 bytes

Infixo anônimo lambda tomando n como argumento à esquerda e M como argumento à direita.

{s↓(-s←2⍴⌈¯1+⍺÷2)↓⊢⌺⍺ ⍺⊢⍵}

Experimente online!

{… } Lambda anônimo, onde ⍺está o argumento da esquerda e ⍵o argumento da direita:

 ⊢⍵ gera o argumento correto ( ⊢separa ⍺ ⍺de ⍵)

 ⊢⌺⍺ ⍺ todas ⍺as ⍺submatrizes, incluindo as que se sobrepõem às arestas (são preenchidas com zeros)

 (… )↓ Solte os seguintes elementos numéricos nas duas primeiras dimensões:

  ⍺÷2 metade de ⍺

  ¯1+ um negativo mais que

  ⌈ arredondar para cima

  2⍴ ciclicamente r eshape para uma lista de dois elementos

  s← armazenar em s(para s hards)

  - negar (ou seja, cair por trás)

 s↓soltar selementos ao longo da primeira e segunda dimensões (de frente)

APL (Dyalog Unicode) , 31 bytes

{(1↓2 1 3 4⍉⊖)⍣(4×⌊⍺÷2)⊢⌺⍺ ⍺⊢⍵}

Experimente online!

Uma abordagem diferente da de Adám.

R , 75 bytes

function(M,N,S,W=1:N,g=N:S-N)for(i in g)for(j in g)print(M[i+W,j+W,drop=F])

Experimente online!

Leva M, Ne o Size da matriz.

Imprime as matrizes resultantes em stdout; drop=Fé necessário para que, no N=1caso, a indexação não elimine o dimatributo e produza um em matrixvez de um vector.

J , 11 8 bytes

-3 bytes graças a milhas

<;._3~,~

Experimente online!

Haskell , 67 bytes

m#n|r<-[0..length m-n]=[take n.drop x<$>take n(drop y m)|x<-r,y<-r]

Experimente online!

Gelatina , 5 bytes

Z⁹Ƥ⁺€

Usa o formato de saída 4D. Para 3D, adicione a Ẏpara 6 bytes .

Experimente online!

Como funciona

Z⁹Ƥ⁺€  Main link. Left argument: M (matrix). Right argument: n (integer)

 ⁹Ƥ    Apply the link to the left to all infixes of length n.
Z        Zip the rows of the infix, transposing rows and columns.
   ⁺€  Map Z⁹Ƥ over all results.

Braquilog , 13 bytes

{tN&s₎\;Ns₎}ᶠ

Experimente online!

Isso retorna listas de colunas.

Tecnicamente, tN&s₎\;Ns₎é um predicado gerador que unifica sua saída com qualquer uma dessas submatrizes. Usamos {…}ᶠapenas para expor todas as possibilidades.

Explicação

 tN&              Call the second argument of the input N
{          }ᶠ     Find all:
    s₎              A substring of the matrix of size N
      \             Transpose that substring
       ;Ns₎         A substring of that transposed substring of size N

Stax , 10 bytes

│Æ☼♂Mqß E╖

Executá-lo

A representação ascii do mesmo programa é

YBFMyBF|PMmJ

Funciona assim.

Y               Store the number in the y register
 B              Batch the grid into y rows each
  F             Foreach batch, run the rest of the program
   M            Transpose about the diagonal
    yB          Batch the transposed slices into y rows each
      F         Foreach batch, run the rest of the progoram
       |P       Print a blank line
         M      Transpose inner slice - restoring its original orientation
          mJ    For each row in the inner grid, output joined by spaces

JavaScript (ES6), 91 bytes

Recebe entrada na sintaxe de currying (a)(n). Retorna os resultados como listas de linhas.

a=>n=>(g=x=>a[y+n-1]?[a.slice(y,y+n).map(r=>r.slice(x,x+n)),...g(a[x+n]?x+1:!++y)]:[])(y=0)

Casos de teste

let f =

a=>n=>(g=x=>a[y+n-1]?[a.slice(y,y+n).map(r=>r.slice(x,x+n)),...g(a[x+n]?x+1:!++y)]:[])(y=0)

;[
  [ [[1,2,3],[5,6,7],[9,10,11]], 1 ],
  [ [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], 3 ],
  [ [[100,-3,4,6],[12,11,14,8],[0,0,9,3],[34,289,-18,3]], 2 ],
  [ [[100,-3,4,6],[12,11,14,8],[9,10,11,12],[13,14,15,16]], 3]
]
.forEach(([m, a]) => console.log(JSON.stringify(f(m)(a))))

APL (Dyalog Classic) , 24 23 bytes

t∘↑¨(¯1-t←-2⍴⎕)↓,⍀⍪\⍪¨⎕

Experimente online!

o resultado é uma matriz de matrizes, embora a formatação de saída de Dyalog não torne isso muito óbvio

insira a matriz ( ⎕), transforme cada elemento em uma matriz aninhada própria ( ⍪¨), obtenha concatenações de prefixo por linha ( ,\) e coluna ( ⍪⍀), insira n ( ⎕), descarte as primeiras n-1 linhas e colunas de matrizes aninhadas ( (¯1-t←-2⍴⎕)↓), pegue o canto inferior direito n-a-n de cada matriz ( t∘↑¨)

                                        ┌─┬──┬───┐
                                        │a│ab│abc│      ┼──┼───┤        ┼──┼───┤
 n=2       ┌─┬─┬─┐      ┌─┬──┬───┐      ├─┼──┼───┤      │ab│abc│        │ab│ bc│
┌───┐      │a│b│c│      │a│ab│bac│      │a│ab│abc│      │de│def│        │de│ ef│
│abc│  ⍪¨  ├─┼─┼─┤  ,\  ├─┼──┼───┤  ⍪⍀  │d│de│def│ 1 1↓ ┼──┼───┤¯2 ¯2∘↑¨┼──┼───┤
│def│ ---> │d│e│f│ ---> │d│de│edf│ ---> ├─┼──┼───┤ ---> │ab│abc│  --->  │  │   │
│ghi│      ├─┼─┼─┤      ├─┼──┼───┤      │a│ab│abc│      │de│def│        │de│ ef│
└───┘      │g│h│i│      │g│gh│hgi│      │d│de│def│      │gh│ghi│        │gh│ hi│
           └─┴─┴─┘      └─┴──┴───┘      │g│gh│ghi│      ┴──┴───┘        ┴──┴───┘
                                        └─┴──┴───┘

Ruby , 63 bytes

->c,g{n=c.size-g+1
(0...n*n).map{|i|c[i/n,g].map{|z|z[i%n,g]}}}

Experimente online!

Este é um lambda que pega uma matriz 2D e uma int, retornando uma matriz 3D.

Ungolfed:

->m,n{
  a = m.size - n + 1     # The count of rows in m that can be a first row in a submatrix
  (0...a*a).map{ |b|     # There will be a*a submatrices
    m[b/a,n].map{ |r|    # Take each possible set of n rows
      r[b%a,n]           # And each possible set of n columns
    }
  }
}

Python 2 , 91 bytes

lambda a,n:(lambda R:[[r[i:i+n]for r in a[j:j+n]]for i in R for j in R])(range(len(a)+1-n))

Experimente online!