Introducción:

Soy un coleccionista de rompecabezas retorcido. Aquí puedes ver mi colección actual de ± 300 rompecabezas.

Creo que todos conocen el Cubo de Rubik normal (Cubo 3x3x3), que es un Cubo NxNxN . También hay cuboides (rompecabezas en forma de bloque), que vienen en diferentes formas, tal vez mejor explicadas por SuperAntionioVivaldi aquí :

• Cuboides regulares de dominó (como el 2x2x3 ; 2x3x3 ; 3x3x4 ; etc.): vienen en forma de NxNx (N + O) o Nx (N + O) x (N + O) , que tienen dos dimensiones impares y una par, o dos pares y un impar.
• Cuboides cambiaformas (como el 2x2x4 ; 3x3x5; 3x3x9 ; 4x4x6 ; etc.): vienen en forma de NxNx (N + P) , que como su nombre indica, cambia de forma (en todas las direcciones). Las tres dimensiones son impares o pares.
• Cuboides flexibles (como el 1x3x3 ; 2x4x4 ; etc.): vienen en forma de Nx (N + P) x (N + P) , que son casi lo mismo que los Cambiaformas, pero con las llamadas Paridades de disquete.
• Cuboides de ladrillo (como el 2x3x4 ; 3x4x5 ; 2x3x5; etc.): vienen en forma de Nx (N + O) x (N + P), que al igual que los Cuboides regulares de dominó tienen dos dimensiones impares y un par, o dos pares y un impar; pero no tiene ninguna de las mismas dimensiones.
• Ultimate Shapeshifters (como el 2x4x6 ; 3x5x7; 2x4x10; etc.): vienen en forma de Nx (N + O) x (N + R) y cambian de forma en cualquier dirección. Las tres dimensiones son impares o pares; pero no tiene ninguna de las mismas dimensiones.

Desafío:

Entrada:

Un entero positivo n con la siguiente restricción: 8 <= n <= 125.
n puede decodificarse de forma única como el producto de tres valores (las dimensiones), cada uno de los cuales está entre 2 y 5 inclusive.

La razón por la que lo he restringido a 2-5 es para evitar entradas duplicadas (como 1x2x4 = 8y 2x2x2 = 8), a pesar de que existen muchos Cuboides de orden inferior / superior . Esto también significa que no hay casos de prueba para Ultimate Shapeshifters.

Salida / casos de prueba:

Estos son todos los casos que su programa / función debería admitir, que van desde las longitudes de borde 2 a 5 en cada configuración tridimensional posible:

Input   Cuboid/Cube   Type/Output
8       2x2x2         Cube
12      2x2x3         Regular Domino Cuboid
16      2x2x4         Shapeshifter Cuboid
20      2x2x5         Regular Domino Cuboid
18      2x3x3         Regular Domino Cuboid
24      2x3x4         Brick Cuboid
30      2x3x5         Brick Cuboid
32      2x4x4         Floppy Cuboid
40      2x4x5         Brick Cuboid
50      2x5x5         Regular Domino Cuboid
27      3x3x3         Cube
36      3x3x4         Regular Domino Cuboid
45      3x3x5         Shapeshifter Cuboid
48      3x4x4         Regular Domino Cuboid
60      3x4x5         Brick Cuboid
75      3x5x5         Floppy Cuboid
64      4x4x4         Cube
80      4x4x5         Regular Domino Cuboid
100     4x5x5         Regular Domino Cuboid
125     5x5x5         Cube

Reglas de desafío:

• Cualquier entrada que no sea Cubo / No Cuboide dentro del rango 8-125 debería dar como resultado 'ninguno' como salida.
• El formato de salida es su propia elección. Creo que lo más razonable son los enteros, como 0= 'ninguno'; 1= Cubo; 2= Cuboide de dominó regular; 3= Cuboide de cambiaformas; 4= Disquete cuboide; 5= Cuboide de ladrillo. Cualquier otro formato de salida también está bien, siempre que especifique cuál ha utilizado.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados, programas completos. Tu llamada.
• Las lagunas predeterminadas están prohibidas. ( NOTA: como no sé si existe una fórmula inteligente para la conversión de entrada a salida, se permite codificar las respuestas en función de la entrada ) .
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

05AB1E , 26 21 bytes

None: 0 Cube: 1 Regular Domino Cuboid: 2 Shapeshifter Cuboid: 3 Brick Cuboid: 4 Floppy Cuboid: 5

•S3X@I¨%÷'•5L¦3ãPÙIkè

Pruébalo en línea! o como un conjunto de pruebas

Explicación

•S3X@I¨%÷'•            # push base-214 compression of the number 123224454212324512210
           5L¦         # push the list [2,3,4,5]
              3ã       # cartesian product with repetion of size 3
                P      # product of each sublist
                 Ù     # remove duplicates
                  Ik   # get the index of input in that list (-1 if non-existant)
                    è  # get the element at this index in the above number

El único lugar donde veo que podríamos guardar bytes aquí es encontrar una mejor manera de generar el número 123224454212324512210 .

Es solo 1 fuera de una prima, por lo que una posible salvación sería encontrar el índice de esa prima y generar el índice en menos de 9 bytes.
No sé qué tan bien funciona la función pi para primos de 21 dígitos, pero eso podría ser una posibilidad.

JavaScript (ES6), 97 92 86 bytes

Esta función primero verifica la validez de la entrada, luego selecciona el valor correcto de una tabla de búsqueda.

Sorprendentemente, la parte más larga es la verificación de validez (¿es n de la forma x * y * z con x , y y z en [2,3,4,5] ?). Debe haber una forma más corta de hacerlo, pero no pude resolverlo hasta ahora.

n=>'NBBF..CRCC.BRR..SFRRRRR.B..C'[[34707324,0x80000800,4240,262208][n&3]>>n/4&1&&n%29]

Devuelve un caracter:

• N : ninguno
• C : cubo
• R : Cuboide de dominó regular
• S : Cuboide cambiaformas
• B : ladrillo cuboide
• F : disquete cuboide

Prueba

let f =

n=>'NBBF..CRCC.BRR..SFRRRRR.B..C'[[34707324,0x80000800,4240,262208][n&3]>>n/4&1&&n%29]

// invalid
;[9,13,99].map(
  n => { console.log(n, f(n)) }
)

// valid
;[8,12,16,20,18,24,30,32,40,50,27,36,45,48,60,75,64,80,100,125].map(
  n => { console.log(n, f(n)) }
)

Ruby, 106 98 96 bytes

->n{[[x=25,2421],[15,53],[9,21],[4,1232504350200510002]].any?{|a,b|n%a<1&&x="00#{b}"[n/a]}?x:?0}

Porque, por qué no, hardcoding.

Como se especifica, 0 = 'ninguno'; 1 = cubo; 2 = Cuboide de dominó regular; 3 = Cuboide cambiaformas; 4 = disquete cuboide; 5 = Cuboide de ladrillo

Perl 6 , 69 58 bytes

{%(unique([X*] (2..5)xx 3)Z=>:32<AM0K21IHN61H5>.comb){$_}}

Utiliza el formato de salida entero sugerido en la descripción de la tarea, excepto que devuelve el valor no inicializado en (Any)lugar de 0en el caso de entradas que no forman un cubo / cuboide válido.

Cómo funciona

1. unique([X*] (2..5)xx 3)

   Genera la lista 8 12 16 20 18 24 30 32 40 50 27 36 45 48 60 75 64 80 100 125.

2. :32<AM0K21IHN61H5>.comb

   Genera la lista 1 2 3 2 2 5 5 4 5 2 1 2 3 2 5 4 1 2 2 1(a partir de un literal de base 32).

3. %(   Z=>   )

   Genera un Hash (mapa asociativo) con la primera lista como las claves y la segunda lista como los valores.

4.    {$_}

   Indexa el hash con el número de entrada.

Lote, 163 bytes

@set/as=0,c=29948521
@for /l %%i in (2,1,5)do @for /l %%j in (%%i,1,5)do @for /l %%k in (%%j,1,5)do @set/as+=c%%6*!(%%i*%%j*%%k-%1),c/=6,c+=14081593*!c
@echo %s%

Utiliza el formato de salida sugerido. Explicación: La idea básica es recorrer la lista de cubos como se define en la pregunta. Para cada cubo, calculamos para ver si su volumen es el entero de entrada, y si es así, calculamos el tipo de cubo de una tabla de búsqueda.

La tabla de búsqueda original era una cadena de letras, pero hacer la manipulación de cadenas en un forbucle es complicado, por lo que cambié a dígitos que se pueden extraer aritméticamente. Lamentablemente, Batch está limitado a enteros de 32 bits, por lo que no pude ajustar todos los dígitos en una sola variable (incluso en la base 5 solo puede obtener 13 dígitos), por lo que dividí la variable en dos partes, codificada en la base 6 por conveniencia. 29948521está 2545522321en la base 6 que codifica los 10 cuboides más pequeños en orden inverso; cuando se queda sin dígitos agregamos 14081593que está 1221452321en la base 6 que codifica los 10 cuboides más grandes.