Um diagrama Young é um arranjo de caixas em linhas justificadas à esquerda e colunas justificadas na parte superior. Para cada caixa, todos os espaços acima e à esquerda estão ocupados.
O comprimento do gancho de uma caixa é o número de caixas à sua direita na linha e abaixo da coluna, também contando uma vez. Por exemplo, a segunda caixa tem um comprimento de gancho de 6:
Aqui estão todos os comprimentos de gancho:
Seu objetivo é calcular o produto dos comprimentos do gancho, aqui 8*6*5*2*1*5*3*2*4*2*1*1 = 115200.
(Leia sobre a fórmula do comprimento do gancho, se você estiver interessado em saber por que essa expressão é importante.)
Entrada: Uma coleção de tamanhos de linha como números como [5,3,3,1]ou como um símbolo unário repetido como [[1,1,1,1,1], [1,1,1], [1,1,1], [1]]ou "XXXXX XXX XXX X". Você pode esperar que a lista seja classificada crescente ou decrescente, conforme desejar. A lista não ficará vazia e conterá apenas números inteiros positivos.
Saída: o produto do comprimento do gancho, que é um número inteiro positivo. Não se preocupe com estouros de número inteiro ou tempo de execução.
Built-ins que lidam especificamente com diagramas Young ou partições inteiras não são permitidos.
Isso inclui a lista unária do estilo CJam em uma ordem crescente. Por exemplo:
Esta versão é fornecida por Dennis e usa o fato de que Block ArrayList %ainda funciona no CJam: D
Esta é a versão original de 20 bytes
Isso inclui uma lista de tamanhos de linha no estilo CJam em uma ordem crescente. Por exemplo:
Se olharmos para ele, o comprimento do gancho de cada bloco em um diagrama de blocos Young é a soma do índice desse bloco em sua linha e coluna, contando para trás. ou seja, inicie o índice em cada linha do lado direito e inicie o índice em cada coluna da parte inferior.
Tomamos a entrada em ordem crescente do tamanho da linha para iniciar facilmente o índice da parte inferior de cada coluna. Primeiro, obtemos o índice por linha e o invertemos. Então nós transpomos. Como a ordem da linha original foi revertida, assumir o índice neste diagrama transposto fornecerá diretamente o índice de baixo para cima.
Expansão de código
{ee::+W%}_q~%z%:+:*(19 bytes) Formato de entrada:[[1][1 1 1][1 1 1][1 1 1 1 1]]
@Dennis Nice (ab) uso da ordem arity para %: P
25 bytes (com explicação):
Recebe a entrada como lista de listas ascendentes de dígitos unários semelhantes ao exemplo [[1], [1,1,1], [1,1,1], [1,1,1,1,1]].
Crie uma matriz binária a partir da entrada
Calcule as diferenças de execução nas duas dimensões.
Para cada célula, adicione os dois resultados, subtraia 1, use o valor absoluto (para mapear as células originalmente zero para 1)
Percorra a matriz e pegue o produto dos números.
Resultados intermediários mostrados na entrada 1 1 1 1 1;1 1 1;1 1 1;1 (5,3,3,1 in unary)( isto é para uma versão anterior com comprimentos descendentes, mas usando o mesmo método ):
Versão explícita do mesmo comprimento:
Pitão - 21 bytes
Estou perdendo muitos bytes no cálculo vertical. Vamos focar no golfe.
Toma entrada como [5, 3, 3, 1].
Recebe entrada em ordem crescente, como [1, 3, 3, 5].
Solução alternativa, 19 bytes
(Graças a @xnor por um byte insano, salve combinando pe j)
o d.get parece um pouco suspeito para mim, mas caso contrário, eu sou relativamente feliz com isso. Tentei algumas outras abordagens, como recursão e fechamento, mas essa é a única que consegui obter abaixo dos 100.
Recebe a entrada do STDIN como uma lista em ordem crescente, por exemplo [1, 3, 3, 5].
Exemplo de uso: p [5,4,3,2,1]->4465125
fvarre da esquerda para a direita multiplicando o comprimento do gancho mais externo com uma chamada recursiva para si mesma, onde cada elemento da lista de entrada é reduzido 1(deixando-o cair ao alcançá-lo 0). pdigitaliza de cima para baixo multiplicando fa lista inteira por pda cauda.
Então ... Esta solução é bastante longa e provavelmente poderia ser mais golfe. Vou pensar sobre isso !
Isso pega uma lista de tipos Python do stdin:
Essa é uma implementação muito canônica, mas ainda não cheguei a algo muito mais inteligente. Tenho a sensação de que haverá soluções muito mais curtas, mesmo com linguagens de programação "reais".
Nós obtemos o número de caixas em cada linha como entrada. Essa solução conta primeiro o número de caixas em cada coluna, as quais são armazenadas c(na verdade, é a contagem menos 1 para simplificar seu uso no cálculo posterior). Em seguida, itera sobre todas as caixas e multiplica os comprimentos do gancho. O comprimento do gancho em si é trivial para calcular depois de ter a contagem de caixas em cada linha e coluna.
Parece que você não está usando m?
Poderia jurar que o apaguei! Lembro-me de perceber que estava usando apenas uma vez e substituindo o único uso. Mas então eu devo ter esquecido de excluir a variável. :(
Uma função que recebe uma matriz de números inteiros em ordem crescente ordem .
Execute o trecho para testar (apenas Firefox)
Esta é uma implementação em Python da resposta Haskell de nimi . Sugestões de golfe são bem-vindas.
Bem-vindo ao golfe Python! Você pode fazer z and _ or 1como z==[]or _quando zé uma lista, usando o fato de que True==1. As declarações de função do Python são mais elaboradas do que Haskell, por isso geralmente oferece uma boa recompensa para definir uma única função recursiva que executa os loops recursivos interno e externo, embora eu não saiba o quão viável isso é aqui.
@xnor "Bem-vindo ao golfe em Python"?
Desculpe, você pratica golfe em Python. Eu associo você a Na verdade.
@xnor Muito, muito antes de eu começar, na verdade, eu estava jogando golfe em Python. Eu estou um pouco ofendido que você não lembre-se: P