Cuboïdes à facteur distinct de sortie

13

Cuboïdes à facteur distinct de sortie

La tâche d'aujourd'hui est très simple: étant donné un entier positif, produire un représentant de chaque cuboïde formable par ses facteurs.

Explications

Le volume d'un cuboïde est le produit de ses trois longueurs latérales. Par exemple, un parallélépipède du volume 4 dont les longueurs de côté sont des nombres entiers pouvant avoir des côtés [1, 1, 4], [1, 2, 2], [1, 4, 1], [2, 1, 2], [2, 2, 1], ou [4, 1, 1]. Cependant, certains d'entre eux représentent le même cuboïde: par exemple [1, 1, 4]et [4, 1, 1]sont le même cuboïde tourné. Il n'y a que deux cuboïdes distincts avec le volume 4 et les côtés entiers: [1, 1, 4]et [1, 2, 2]. La sortie peut être n'importe quelle représentation du premier cuboïde et n'importe quelle représentation du deuxième cuboïde.

Contribution

Votre programme doit prendre un seul entier positif 1≤n≤231−1 .

Production

Vous devrez sortir tous les cuboïdes possibles dans une liste ou de toute autre manière acceptable. Par exemple

Input  Output
  1    [[1, 1, 1]]
  2    [[1, 1, 2]]
  3    [[1, 1, 3]]
  4    [[1, 1, 4], [1, 2, 2]]
  8    [[1, 1, 8], [1, 2, 4], [2, 2, 2]]
 12    [[1, 1, 12], [1, 2, 6], [1, 3, 4], [2, 2, 3]]
 13    [[1, 1, 13]]
 15    [[1, 1, 15], [1, 3, 5]]
 18    [[1, 1, 18], [1, 2, 9], [1, 3, 6], [2, 3, 3]]
 23    [[1, 1, 23]]
 27    [[1, 1, 27], [1, 3, 9], [3, 3, 3]]
 32    [[1, 1, 32], [1, 2, 16], [1, 4, 8], [2, 2, 8], [2, 4, 4]]
 36    [[1, 1, 36], [1, 2, 18], [1, 3, 12],[1, 4, 9], [1, 6, 6], [2, 2, 9], [2, 3, 6], [3, 3, 4]]

Les sous-listes n'ont pas besoin d'être triées, tant qu'elles sont uniques.

Notation

C'est le golf de code, donc la réponse la plus courte en octets l'emporte. Les failles standard sont interdites.

Voici un générateur de cas de test

Classements

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle de démarque suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre en les rayant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

# Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Afficher l'extrait de code

code-golf  math  number  permutations  factoring 
— Lyxal
source
— Arnauld
— Arnauld

Réponses:

4

Gelée , 7 octets

œċ3P⁼¥Ƈ

Un lien monadique acceptant un entier positif qui donne une liste de 3 listes d'entiers positifs.

Essayez-le en ligne!

Comment?

œċ3P⁼¥Ƈ - Link: positive integer, N
  3     - literal three
œċ      - all combinations (of [1..N]) of length (3) with replacement
           i.e. [[1,1,1],[1,1,2],...,[1,1,N],[1,2,2],[1,2,3],...,[1,2,N],...,[N,N,N]]
      Ƈ - filter keep those for which:
     ¥  -   last two links as a dyad:
   P    -     product
    ⁼   -     equals (N)?
— Jonathan Allan
source
5

JavaScript (V8) ,  61  60 octets

Imprime les cuboïdes dans STDOUT.

n=>{for(z=n;y=z;z--)for(;(x=n/y/z)<=y;y--)x%1||print(x,y,z)}

Essayez-le en ligne!

Commenté

n => {                // n = input
  for(                // outer loop:
    z = n;            //   start with z = n
    y = z;            //   set y to z; stop if we've reached 0
    z--               //   decrement z after each iteration
  )                   //
    for(              //   inner loop:
      ;               //     no initialization code
      (x = n / y / z) //     set x to n / y / z
      <= y;           //     stop if x > y
      y--             //     decrement y after each iteration
    )                 //
      x % 1 ||        //     unless x is not an integer,
      print(x, y, z)  //     print the cuboid (x, y, z)
}                     //
— Arnauld
source
5

Haskell , 52 octets

f n=[[a,b,c]|a<-[1..n],b<-[1..a],c<-[1..b],a*b*c==n]

Essayez-le en ligne!

Les tuples sont en ordre décroissant. "3" semble être un nombre suffisamment petit pour que l'écriture des 3 boucles soit plus courte que tout ce que je pouvais trouver.

— xnor
source
J'aime la méta-obfuscation d'appeler les tuples de contenu de la liste retournée.
— Jonathan Frech
4

Gelée , 11 octets

ÆDṗ3Ṣ€QP=¥Ƈ

Essayez-le en ligne!

Un lien monadique prenant un entier comme argument et renvoyant une liste de listes d'entiers.

Explication

ÆD          | Divisors
  ṗ3        | Cartesian power of 3
    Ṣ€      | Sort each list
      Q     | Unique
         ¥Ƈ | Keep only where the following is true (as a dyad, using the original argument as right argument)
       P    | - Product
        =   | - Is equal (to original argument)
— Nick Kennedy
source
2

Haskell , 67 60 59 octets

Pour une donnée n{1,2,…,n}

f n=[x|x@[a,b,c]<-mapM id$[1..n]<$":-)",a*b*c==n,a<=b,b<=c]

Essayez-le en ligne!

— flawr
source
1
Je pense que trois tuples ne peuvent être correctement produits qu'avec un smiley.
— Jonathan Frech
: -)
— flawr
2

Rétine , 59 octets

.+
*
2+%L$`(?<=(_+))(?=(\1)*$)
$` _$#2*
A`_(_+) \1\b
_+
$.&

Essayez-le en ligne! Le lien inclut une suite de tests. Explication:

.+
*

Convertissez en unaire.

2+%L$`(?<=(_+))(?=(\1)*$)
$` _$#2*

En répétant deux fois, divisez le dernier nombre de chaque ligne en toutes ses paires de facteurs possibles. Le lookbehind est gourmand et atomique, donc une fois qu'il correspond au préfixe du dernier numéro, il ne reviendra pas en arrière. Cela génère toutes les permutations possibles de trois facteurs.

A`_(_+) \1\b

Supprimez les lignes où les facteurs ne sont pas dans l'ordre croissant.

_+
$.&

Convertissez en décimal.

— Neil
source
2

Pyth , 11 octets

fqQ*FT.CSQ3

Essayez-le en ligne!

        SQ  #              range(1, Q+1)          # Q = input
      .C  3 # combinations(             , 3)
f           # filter(lambda T: vvv, ^^^)
 qQ         # Q == 
   *FT      #      fold(__operator_mul, T) ( = product of all elements)
— ar4093
source
2

05AB1E , 8 octets

Ò3.ŒP€{ê

Ò               # prime factors of the input
 3.Π           # all 3-element partitions
    P           # take the product of each inner list
     €{         # sort each inner list
       ê        # sort and uniquify the outer list

Essayez-le en ligne!

— Grimmy
source
2

C (clang) , 89 octets

a,b,x;f(n){for(a=n;a;a--)for(b=a;b&&(x=n/a/b)<=b;b--)x*b*a-n||printf("%d,%d,%d ",x,b,a);}

Essayez-le en ligne!

Port de @Arnauld 👍

Enregistré 1 grâce à @Jonathan Frech meilleur format de sortie

— AZTECCO
source
1
"%d %d %d\n"~> "%d,%d,%d "sauverait un octet.
— Jonathan Frech
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.