Introduzione:

Sono un collezionista di puzzle intricati. Qui puoi vedere la mia attuale collezione di ± 300 puzzle.

Penso che tutti conoscano il normale cubo di Rubik (cubo 3x3x3), che è un cubo NxNxN . Ci sono anche cuboidi (puzzle a forma di blocco), che si presentano in diverse forme, forse meglio spiegati da SuperAntionioVivaldi qui :

• Cuboidi Domino regolari (come 2x2x3 ; 2x3x3 ; 3x3x4 ; ecc.) - Si presentano sotto forma di NxNx (N + O) o Nx (N + O) x (N + O) , che hanno due dimensioni dispari e un pari o due pari e dispari.
• Cuboidi di Shapeshifter (come 2x2x4 ; 3x3x5; 3x3x9 ; 4x4x6 ; ecc.) - Si presentano sotto forma di NxNx (N + P) , che come suggerisce il nome, mutaforma (in tutte le direzioni). Tutte e tre le dimensioni sono pari o dispari.
• Floppy Cuboids (come 1x3x3 ; 2x4x4 ; ecc.): Si presentano sotto forma di Nx (N + P) x (N + P) , che sono quasi gli stessi degli Shapeshifters, ma con le cosiddette Floppy Parities.
• Cuboidi in mattoni (come il 2x3x4 ; 3x4x5 ; 2x3x5; ecc.) - Si presentano sotto forma di Nx (N + O) x (N + P), che proprio come i cuboidi Domino regolari hanno due dimensioni dispari e un pari, o due pari e uno dispari; ma non hanno le stesse dimensioni.
• Ultimate Shapeshifters (come il 2x4x6 ; 3x5x7; 2x4x10; ecc.): Si presentano sotto forma di Nx (N + O) x (N + R) e cambiano forma in qualsiasi direzione. Tutte e tre le dimensioni sono pari o dispari; ma non hanno le stesse dimensioni.

Sfida:

Ingresso:

Un numero intero positivo n con la seguente restrizione: 8 <= n <= 125.
n può essere decodificato in modo univoco come prodotto di tre valori (le dimensioni), di cui ciascuno compreso tra 2 e 5 inclusi.

Il motivo per cui l'ho limitato a 2-5 è quello di prevenire input duplicati (come 1x2x4 = 8e 2x2x2 = 8), anche se ci sono molti cuboidi di ordine inferiore / superiore . Questo significa anche che non ci sono casi di test per Ultimate Shapeshifters.

Casi di output / test:

Questi sono tutti i casi che il tuo programma / funzione dovrebbe supportare, che vanno dalle lunghezze dei bordi da 2 a 5 in ogni possibile configurazione tridimensionale:

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

Regole della sfida:

• Qualsiasi input non cubo / non cuboide compreso nell'intervallo 8-125 dovrebbe risultare in "nessuno" come output.
• Il formato di output è una tua scelta. Penso che il più ragionevole siano numeri interi, come 0= 'none'; 1= Cubo; 2= Cuboide domino regolare; 3= Cuboid di Shapeshifter; 4= Cuboide floppy; 5= Cuboide in mattoni. Anche qualsiasi altro formato di output va bene, purché specifichi quale hai usato.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite . ( NOTA: poiché non so se esiste una formula intelligente per la conversione da input a output, è consentito codificare le risposte in base all'input. )
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

05AB1E , 26 21 byte

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

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

Provalo online! o come una suite di test

Spiegazione

•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

L'unico posto in cui vedo che è possibile salvare i byte qui è trovare un modo migliore per generare il numero 123224454212324512210 .

È solo 1-off da un numero primo, quindi un possibile salvataggio sarebbe quello di trovare l'indice di quel numero primo e generare l'indice in meno di 9 byte.
Non so quanto funzioni bene la funzione pi per numeri primi a 21 cifre, ma potrebbe essere una possibilità.

JavaScript (ES6), 97 92 86 byte

Questa funzione controlla prima la validità dell'input, quindi seleziona il valore corretto da una tabella di ricerca.

Sorprendentemente, la parte più lunga è il controllo di validità (è n della forma x * y * z con x , y e z in [2,3,4,5] ?). Deve esserci un modo più breve di farlo, ma non sono riuscito a capirlo finora.

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

Restituisce un personaggio:

• N : nessuna
• C : Cubo
• R : Domino Cuboid regolare
• S : Shapeshifter Cuboid
• B : Cuboid di mattoni
• F : Cuboide floppy

Test

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)) }
)

Rubino, 106 98 96 byte

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

Perché, perché no, hardcoding.

Come specificato, 0 = 'nessuno'; 1 = cubo; 2 = Domino Cuboid regolare; 3 = Shapeshifter Cuboid; 4 = Cuboide floppy; 5 = Cuboide in mattoni

Perl 6 , 69 58 byte

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

Utilizza il formato di output intero suggerito nella descrizione (Any)dell'attività , tranne per il fatto che restituisce il valore non inizializzato anziché 0nel caso di input che non formano un cubo / cuboide validi.

Come funziona

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

   Genera l'elenco 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 l'elenco 1 2 3 2 2 5 5 4 5 2 1 2 3 2 5 4 1 2 2 1(da un valore letterale di base 32).

3. %(   Z=>   )

   Genera un hash (mappa associativa) con il primo elenco come chiavi e il secondo elenco come valori.

4.    {$_}

   Indicizza l'hash con il numero di input.

Lotto, 163 byte

@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%

Utilizza il formato di output suggerito. Spiegazione: L'idea di base è di scorrere l'elenco dei cubi come definito nella domanda. Per ogni cubo, calcoliamo per vedere se il suo volume è l'intero di input e, in tal caso, calcoliamo il tipo di cubo da una tabella di ricerca.

La tabella di ricerca originale era una stringa di lettere, ma fare la manipolazione delle stringhe in un forciclo è complicato, quindi sono passato a cifre che possono essere estratte aritmeticamente. Purtroppo Batch è limitato a numeri interi a 32 bit, quindi non ho potuto inserire tutte le cifre in una singola variabile (anche nella base 5 puoi ottenere solo 13 cifre), quindi ho diviso la variabile in due parti, codificata nella base 6 per comodità. 29948521è 2545522321nella base 6 che codifica i 10 cuboidi più piccoli in ordine inverso; quando si esauriscono le cifre aggiungiamo 14081593che è 1221452321nella base 6 che codifica i 10 cuboidi più grandi.