Un diagrama de Young es una disposición de cuadros en filas justificadas a la izquierda y columnas justificadas en la parte superior. Para cada cuadro, todos los espacios encima y a su izquierda están ocupados.
XXXXX
XXX
XXX
X
La longitud del gancho de una caja es el número de cajas a su derecha en su fila, y debajo de ella en su columna, contando una sola vez. Por ejemplo, el segundo cuadro tiene una longitud de gancho de 6:
X****
X*X
X*X
X
Aquí están todas las longitudes de gancho:
86521
532
421
1
Su objetivo es calcular el producto de las longitudes de gancho, aquí 8*6*5*2*1*5*3*2*4*2*1*1 = 115200
.
(Lea sobre la fórmula de longitud de gancho si está interesado en por qué es importante esta expresión).
Entrada: Una colección de tamaños de fila como números como [5,3,3,1]
o como un símbolo unario repetido como [[1,1,1,1,1], [1,1,1], [1,1,1], [1]]
o "XXXXX XXX XXX X"
. Puede esperar que la lista se ordene ascendente o descendente, según lo desee. La lista no estará vacía y solo contendrá enteros positivos.
Salida: El producto de las longitudes de gancho, que es un entero positivo. No se preocupe por los desbordamientos de enteros o el tiempo de ejecución.
No se permiten los elementos integrados que tratan específicamente con diagramas de Young o particiones enteras.
Casos de prueba:
[1] 1
[2] 2
[1, 1] 2
[5] 120
[2, 1] 3
[5, 4, 3, 2, 1] 4465125
[5, 3, 3, 1] 115200
[10, 5] 798336000
{ee::+W%}_q~%z%:+:*
(19 bytes) Formato de entrada:[[1][1 1 1][1 1 1][1 1 1 1 1]]
%
: PJ, 24 bytes
25 bytes (con explicación):
Toma la entrada como una lista de listas ascendentes de dígitos unarios similar al ejemplo
[[1], [1,1,1], [1,1,1], [1,1,1,1,1]]
.Uso:
Método
Los resultados intermedios se muestran en la entrada
1 1 1 1 1;1 1 1;1 1 1;1 (5,3,3,1 in unary)
( esto es para una versión anterior con longitudes descendentes pero utilizando el mismo método ):Versión explícita de la misma longitud:
Pruébelo en línea aquí.
fuente
Pyth - 21 bytes
Estoy perdiendo muchos bytes en el cálculo vertical. Me voy a centrar en jugar al golf.
Toma entrada como
[5, 3, 3, 1]
.Pruébalo aquí en línea .
fuente
Pyth, 18 bytes
Toma la entrada en orden ascendente, como
[1, 3, 3, 5]
.Demostración.
Solución alternativa, 19 bytes.
fuente
Python 2,
8988 bytes(Gracias a @xnor por guardar un byte loco combinando
p
yj
)El
d.get
parece un poco sospechoso para mí, pero por lo demás estoy relativamente contento con esto. Intenté algunos otros enfoques, como la recursión y la compresión, pero este es el único que logré tener menos de 100.Toma información de STDIN como una lista en orden ascendente, por ejemplo
[1, 3, 3, 5]
.fuente
Haskell, 68 bytes
Ejemplo de uso:
p [5,4,3,2,1]
->4465125
f
escanea de izquierda a derecha multiplicando la longitud del gancho externo con una llamada recursiva a sí mismo donde cada elemento de la lista de entrada se reduce1
(cayéndolo al llegar0
).p
escanea de arriba a abajo multiplicandof
la lista completa conp
la cola.fuente
R, 174 bytes
Entonces ... Esta solución es bastante larga y probablemente podría ser más golfizada. Lo pensare !
Sin golf:
fuente
Python 2,
135128bytesEsto toma una lista de tipo Python de stdin:
Esta es una implementación muy canónica, pero hasta ahora no he encontrado nada mucho más inteligente. Tengo la sensación de que habrá soluciones mucho más cortas incluso con lenguajes de programación "reales".
Obtenemos el número de cajas en cada fila como entrada. Esta solución primero cuenta el número de cuadros en cada columna, que se almacena
c
(en realidad es el recuento menos 1 para simplificar su uso en el cálculo posterior). Luego itera sobre todos los cuadros y multiplica las longitudes de gancho. La longitud del gancho en sí es trivial para calcular una vez que tiene el recuento de cuadros en cada fila y columna.fuente
m
?JavaScript ( ES6 ) 69
Una función que toma una matriz de enteros en orden ascendente .
Ejecute el fragmento para probar (solo Firefox)
fuente
Python,
9591 bytesEsta es una implementación de Python de la respuesta Haskell de nimi . Sugerencias de golf bienvenidas.
fuente
z and _ or 1
comoz==[]or _
cuandoz
es una lista, utilizando el hecho de queTrue==1
. Las declaraciones de funciones de Python son más verbales que Haskell, por lo que a menudo resulta útil definir una sola función recursiva que realiza los bucles recursivos internos y externos, aunque no sé qué tan factible es eso aquí.