p
é uma função (classe polimórfica da classe) que recebe uma permutação como uma lista de Int
s e uma lista aninhada que representa uma matriz multidimensional de Int
s.
Chame como p [2,1] [[10,20,30],[40,50,60]]
, no entanto, se o padrão de digitação não for bem-sucedido, talvez você precise adicionar uma anotação de tipo como :: [[Int]]
(aninhada adequadamente) fornecendo o tipo do resultado.
import Data.List
class P a where p::[Int]->[a]->[a]
instance P Int where p _=id
instance P a=>P[a]where p(x:r)m|n<-p r<$>m,y:z<-sort r=last$n:[p(x:z)<$>transpose n|x>y]
Experimente online!
Desafios no golfe com matrizes aninhadas de profundidade arbitrária são um pouco estranhos em Haskell, porque a digitação estática tende a atrapalhar. Embora as listas Haskell (com a mesma sintaxe exata da descrição do desafio) possam ser aninhadas muito bem, listas de diferentes profundidades de aninhamento são de tipos incompatíveis. Além disso, as funções de análise Haskell padrão requerem o conhecimento do tipo do valor que você está tentando analisar.
Como resultado, parece inevitável que o programa precise incluir declarações relacionadas ao tipo, que são relativamente detalhadas. Para a parte do golfe, decidi definir uma classe de tipo P
, que p
pode ser polimórfica sobre o tipo da matriz.
Enquanto isso, o equipamento de teste do TIO mostra uma maneira de contornar o problema de análise.
Como funciona
Para resumir a essência desse algoritmo: Ele realiza uma classificação de bolha na lista de permutações, transpondo as dimensões vizinhas quando os índices de permutação correspondentes são trocados.
Conforme fornecido pela class P a
declaração, em qualquer caso, são p
necessários dois argumentos, uma permutação (sempre do tipo [Int]
) e uma matriz.
- A permutação pode ser dada na forma na descrição do desafio, embora, da maneira como o algoritmo funcione, a escolha dos índices seja arbitrária, exceto por sua ordem relativa. (Portanto, o trabalho baseado em 0 e 1).
- A base
instance P Int
lida com matrizes da dimensão 1, que p
simplesmente retorna inalterada, pois a única dimensão só pode ser mapeada para si mesma.
- A outra
instance P a => P [a]
é definida recursivamente, chamando p
com dimensão n subarrays de modo a defini-lo para a dimensão n + 1 matrizes.
p(x:r)m
primeiro chama p r
recursivamente todos os elementos de m
, fornecendo uma matriz de resultados n
na qual todas as dimensões, exceto a primeira, foram permutadas corretamente em relação uma à outra.
- A permutação restante que precisa ser executada
n
é dada por x:y:z = x:sort r
.
- Se,
x<y
então, a primeira dimensão de n
já estiver corretamente posicionada e n
simplesmente retornada.
- Se
x>y
, então a primeira e a segunda dimensão de n
precisam ser trocadas, o que é feito com a transpose
função Finalmente, p(x:z)
é aplicado recursivamente a todos os elementos do resultado, garantindo que a primeira dimensão original seja transposta para a posição correta.
exec
(economia de dois bytes) , como é uma declaração em Python 2.