Introduction:

Je suis un collectionneur de puzzles sinueux. Ici vous pouvez voir ma collection actuelle de ± 300 puzzles.

Je pense que tout le monde connaît le Rubik's Cube (cube 3x3x3), qui est un cube NxNxN . Il existe également des Cuboids (puzzles en forme de bloc), qui se présentent sous différentes formes, peut - être mieux expliquées par SuperAntionioVivaldi ici :

• Cuboïdes Domino réguliers (comme les 2x2x3 ; 2x3x3 ; 3x3x4 ; etc.) - Ils se présentent sous la forme de NxNx (N + O) ou Nx (N + O) x (N + O) , qui ont soit deux dimensions impaires et un pair, ou deux pairs et un impair.
• Cuboïdes de métamorphe (comme les 2x2x4 ; 3x3x5; 3x3x9 ; 4x4x6 ; etc.) - Ils se présentent sous la forme de NxNx (N + P) qui, comme son nom l'indique, change de forme (dans toutes les directions). Les trois dimensions sont impaires ou paires.
• Cuboids Floppy (comme les 1x3x3 ; 2x4x4 ; etc.) - Ils se présentent sous la forme de Nx (N + P) x (N + P) , qui sont presque les mêmes que les Shapeshifters, mais avec des soi-disant parités de disquette.
• Cuboids en briques (comme les 2x3x4 ; 3x4x5 ; 2x3x5; etc.) - Ils se présentent sous la forme de Nx (N + O) x (N + P), qui, tout comme les cuboïdes Domino réguliers, ont deux dimensions impaires et une paire, ou deux pairs et un impair; mais n'ont pas les mêmes dimensions.
• Shapeshifters ultimes (comme les 2x4x6 ; 3x5x7; 2x4x10; etc.) - Ils se présentent sous la forme de Nx (N + O) x (N + R) et changent de forme dans toutes les directions. Les trois dimensions sont impaires ou paires; mais n'ont pas les mêmes dimensions.

Défi:

Contribution:

Un entier positif n avec la restriction suivante: 8 <= n <= 125.
n peut être décodé de manière unique comme le produit de trois valeurs (les dimensions), dont chacune est comprise entre 2 et 5 inclus.

La raison pour laquelle je l'ai limité à 2-5 est d'empêcher les entrées dupliquées (comme 1x2x4 = 8et 2x2x2 = 8), même s'il existe de nombreux Cuboids d'ordre inférieur / supérieur . Cela signifie également qu'il n'y a pas de cas de test pour Ultimate Shapeshifters.

Cas de sortie / test:

Voici tous les cas que votre programme / fonction devrait prendre en charge, allant des longueurs de bord 2 à 5 dans toutes les configurations tridimensionnelles possibles:

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

Règles du défi:

• Toute entrée non cubique / non cuboïde dans la plage 8-125 devrait entraîner «aucune» en sortie.
• Le format de sortie est votre propre choix. Je pense que le plus raisonnable est des entiers, comme 0= 'aucun'; 1= Cube; 2= Cuboïde Domino régulier; 3= Shapeshifter Cuboid; 4= Floppy Cuboid; 5= Brique cuboïde. Tout autre format de sortie convient également tant que vous spécifiez celui que vous avez utilisé.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés, des programmes complets. Ton appel.
• Les failles par défaut sont interdites. ( REMARQUE: comme je ne sais pas s'il existe une formule intelligente pour la conversion entrée-sortie, il est autorisé de coder en dur les réponses en fonction de l'entrée. )
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

05AB1E , 26 21 octets

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

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

Essayez-le en ligne! ou comme suite de tests

Explication

•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

Le seul endroit où je vois que nous pourrions économiser des octets ici est de trouver une meilleure façon de générer le nombre 123224454212324512210 .

Il n'est qu'à 1-off d'un nombre premier, donc une sauvegarde possible serait de trouver l'indice de ce nombre premier et de générer l'index en moins de 9 octets.
Je ne sais pas à quel point la fonction pi fonctionne pour les nombres premiers à 21 chiffres, mais cela pourrait être une possibilité.

JavaScript (ES6), 97 92 86 octets

Cette fonction vérifie d'abord la validité de l'entrée, puis sélectionne la valeur correcte dans une table de recherche.

Étonnamment, la partie la plus longue est le contrôle de validité ( n est-il de la forme x * y * z avec x , y et z dans [2,3,4,5] ?). Il doit y avoir une façon plus courte de le faire, mais je n'ai pas pu le comprendre jusqu'à présent.

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

Renvoie un caractère:

• N : Aucun
• C : Cube
• R : Cuboïde Domino régulier
• S : Shapeshifter Cuboid
• B : brique cuboïde
• F : Floppy Cuboid

Tester

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

Rubis, 106 98 96 octets

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

Parce que, pourquoi pas, le codage en dur.

Comme spécifié, 0 = 'aucun'; 1 = cube; 2 = Cuboïde Domino régulier; 3 = Shapeshifter Cuboid; 4 = Floppy Cuboid; 5 = brique cuboïde

Perl 6 , 69 58 octets

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

Utilise le format de sortie entier suggéré dans la description de la tâche, sauf qu'il renvoie la valeur non initialisée (Any)au lieu de 0dans le cas d'entrées qui ne forment pas un cube / cuboïde valide.

Comment ça fonctionne

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

   Génère la liste 8 12 16 20 18 24 30 32 40 50 27 36 45 48 60 75 64 80 100 125.

2. :32<AM0K21IHN61H5>.comb

   Génère la liste 1 2 3 2 2 5 5 4 5 2 1 2 3 2 5 4 1 2 2 1(à partir d'un littéral base-32).

3. %(   Z=>   )

   Génère un hachage (carte associative) avec la première liste comme clés et la deuxième liste comme valeurs.

4.    {$_}

   Indexe le hachage avec le numéro d'entrée.

Lot, 163 octets

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

Utilise le format de sortie suggéré. Explication: L'idée de base est de parcourir la liste des cubes telle que définie dans la question. Pour chaque cube, nous calculons pour voir si son volume est l'entier d'entrée, et si c'est le cas, calculons le type de cube à partir d'une table de recherche.

La table de recherche d'origine était une chaîne de lettres, mais la manipulation des chaînes dans une forboucle est délicate, j'ai donc opté pour des chiffres qui peuvent être extraits arithmétiquement. Malheureusement, Batch est limité à des entiers 32 bits, donc je ne pouvais pas ranger tous les chiffres dans une seule variable (même en base 5, vous ne pouvez obtenir que 13 chiffres), alors au lieu de cela, je divise la variable en deux parties, codée en base 6 pour plus de commodité. 29948521est 2545522321en base 6 qui code les 10 plus petits cuboïdes dans l'ordre inverse; quand il manque de chiffres, nous ajoutons 14081593qui est 1221452321en base 6 codant les 10 plus gros cuboïdes.