Bonjour,
On va bien s'amuser
Je tente pour 4 cubes :

 Cliquez pour afficher

il y a 5 façons (sans les symétriques ) de placer  4 cubes.
comme il y a  chaque fois  24 choix de couleurs je dirai 120  dispositions.

Je n'ai pas cherché encore, mais ça ne peut pas être ça.
Mon énoncé n'était peut-être pas suffisamment clair , donc je précise :

Si j'aligne 4 cubes, BJRV ou VRJB, ça donne au final la même chose ; quand les 4 cubes sont alignés, il y a 12 façons de répartir les couleurs
Si je dispose les 4 cubes en carré,  il n'y a plus que 2 façons de répartir les couleurs.
Et si je dispose les 4 cubes en 'dimension 3' , il y a 8 façons de répartir les couleurs si je ne me trompe pas.
Etc etc ..
Quand j'ai assemblé mes 4 cubes, et qu'ils sont collés entre eux, j'ai le droit de faire tourner la composition dans tous les sens... et donc en particulier si j'ai collé mes 4 cubes pour faire un carré, la seule question qui se pose c'est de savoir si Jaune et Bleu sont cote à cote, ou en diagonale. Donc 2 dispositions seulement.

Donc non,  pas ce raisonnement où on compte les dispositions, puis on multiplie par 24.

En éliminant les positions symétriques pour 4 cubes:

 Cliquez pour afficher

On a soit:
* 4 en lignes -->12 positions pour les couleurs
*en L------------>2 figures  x12  
*en T-------------1 figure x12
*en carré------->1 figure x6
Soit 54 solutions.

En carré, ce n'est ni 2 comme j'écrivais précédemment, ni 6, mais 4 dispositions : il faut vraiment voir l'assemblage comme un volume. Je colle mes 4 cubes les uns aux autres. Et si je retourne mon assemblage de 4 cubes BJVR,  je tombe sur BRVJ.

ll te manque une forme où les 4 cubes sont sur un même  plan. (la position en Z, 3ème exemple de l'image)

Et il manque les formes  les 4 cubes ne sont pas tous dans un même plan (entre autres les exemples 1 et 2 de l'image).

En s'y mettant à plusieurs, on va finir par trouver  !
Pas si simple de compter jusqu'à 3.

Bonjour,
En carré, je trouve 3 aussi

Bojour

 Cliquez pour afficher

4 cubes : 95

Chouette, j'ai trouvé la même chose, après correction sur le nombre de carrés.

Bonjour,
Merci d'animer
Je pose une question pour vérifier que je n'ai pas mal compris ce que l'on compte :
Dans l'image du 14 à 9h02, les figures 1 et 2 sont-elles considérées comme identiques (car symétriques) ou pas ?

Bonjour,
Non, elles sont différentes.
On peut prendre en main la forme n°1, coloriée comme on veut, on peut la faire tourner dans tous les sens, elle ne donnera jamais la forme n°2.
On manipule des objets en bois, réels...

Pour détailler un peu la réponse :

 Cliquez pour afficher

95=24+12+12+12+12+12+8+3

Merci pour vos réponses

Bonjour,
Joli exercice, je vous souhaite bien du courage pour généraliser quelque soit le nombre de cubes, je ne vois pas comment le faire

Bonjour,
A  noter que la troisième disposition dans l'espace est identique à celle du plan.

 Cliquez pour afficher

On a les dispositions suivantes:
En noir  celles obtenues par symétrie ou rotation donc à exclure.  
Je trouve un total  88 .

Jolis dessins
Comme j'ai renoncé à traiter n = 5, je me contente de commenter les résultats pour n = 4.

 Cliquez pour afficher

J'ai réussi, non sans mal, à trouver 95.

@dpi,
Pour les quatre carrés en carré, il n'y a que 3 configurations. On peut les retourner comme une crêpe.

Il manque une configuration non plane :
Dans ton avant dernière, descendre le cube vert le long du cube rouge.

Pour compléter la réponse à DPI :

 Cliquez pour afficher

Pour les dispositions en carré.
Une fois qu'on a choisi quel nombre est diamétralement opposé à 1, il n'y a qu'une seule disposition. Peu importe comment on place les 2 autres nombres, l'objet obtenu  
sera le même. Il suffit de le retourner comme une crèpe.

La configuration 3D qui manque :
On a le cube rouge en cube 'de base' , on lui colle le bleu sur la face avant, le jaune sur la face 'dessus', et le vert, qui est actuellement collé au cube jaune, on le colle sur la face droite du cube rouge.
Qu'on le colle sur la face droite ou gauche, peu importe. La forme obtenue est la même.
Mais une fois qu'on a peint les cubes, les 2 objets obtenus sont différents.
Donc 4 choix pour la couleur du cube de base, et 2 orientations pour les 3 autres couleurs.
Forcément , on pense à    ​

Bonjour à vous deux

 Cliquez pour afficher

1/pour la "crêpe"  vous avez vu que  1234 donne 2143 qui figure en noir donc éliminé.
JV            VJ
BR    --->RB        
Je trouve 6 cas  ?

2/d'accord je l'avais pas prévue.

Un peu plus théorique :

 Cliquez pour afficher

En le retournant comme une crêpe, donne .
Ça correspond à un demi tour d'axe la première diagonale de la matrice.
dans l'espace, un demi tour est un déplacement.

On peut préférer un demi tour d'axe vertical suivi d'une rotation dans le plan du carré :

j'avais pas toutes les crêpes

Sur mes 6 cas gardés il faut en éliminer 3 bien vu!

Pour 5 cubes :

 Cliquez pour afficher

29 solides différents si on ne colorie pas les cubes. 543 solides colorés si les cinq cubes sont de couleurs différentes.

 Cliquez pour afficher

166 solides différents si on ne colorie pas les cubes. 3490 solides colorés si les six cubes sont de couleurs différentes.

 Cliquez pour afficher

1023 solides différents si on ne colorie pas les cubes. 23511 solides colorés si les sept cubes sont de couleurs différentes.

J'ai retrouvé une ramette . Pour 8 cubes :

 Cliquez pour afficher

6922 solides différents si on ne colorie pas les cubes. 162922 solides colorés si les huit cubes sont de couleurs différentes.

Aussitôt, je me précipite sur OEIS.
Cette suite est-elle référencée ?
Je ne suis pas très doué pour les recherches sur ce site, et apparement, non.
Par contre, la suite des nombres de solides, sans prendre en compte les couleurs, on la retrouve bien :  
1, 1, 2, 8, 29, 166, 1023, 6922  -->

On trouve même la suite des nombres de solide en 2D :  5, 12, 35, 108, 369, 1285, 4655...
et en 3D : 3, 17, 131, 915, 6553, 47026, 341888...
Donc la somme redonne bien la suite trouvée par GBZM mais même en admettant ce résultat, comment il arrive à en déduire le nombre de coloriage ?
Aucune idée, ce n'est pas le même nombre par solide. Je sens venir un programme en python mais cela reste impressionnant car il ne me parait pas du tout évident de coder ce bazar.

Pour ceux qui veulent visualiser les 5 cubes

Source : wikimedia commons

Oups, je rectifie. Je me suis trompé dans les grandes largeurs pour les nombres de colorés. Heureusement, c'était facile à réparer :

Nombre de cubes : 5.
Nombre de solides : 29.
Nombre de solides colorés (une couleur par cube) : 2715

Nombre de cubes : 6.
Nombre de solides : 166.
Nombre de solides colorés (une couleur par cube) : 104700

Nombre de cubes : 7.
Nombre de solides : 1023.
Nombre de solides colorés (une couleur par cube) : 4937310

Nombre de cubes : 8.
Nombre de solides : 6922.
Nombre de solides colorés (une couleur par cube) : 273708960

Je croyais que les liens ne fonctionnaient au vu du message de ty59847 où cela ne fonctionne pas mais du coup vous avez les references y compris pour les suites en 2D et 3D ici

Voici le lien OEIS :

Je suis curieuse de voir le code ou le raisonnement quand même.
Les valeurs numériques ne m'intéressent pas vraiment par contre comprendre l'algo qui les donne nettement plus

Bah, j'ai écrit en python des procédures toutes bêtes, qui demanderaient sans doute à être optimisées. Les grandes lignes :

- Un cube est représenté par un triplet d'entiers (coordonnées de son centre).

- Une liste de cubes donne un solide. Toutes les listes sont calées dans l'octant positif : le minimum des premières (resp. deuxièmes, troisièmes) coordonnées des cubes est nul.

- On code un solide par :
1) Une liste de cubes calée qui le représente,
2) Une liste d'ensembles de cubes qui sont les "avatars" du solide ; on obtient les avatars en faisant agir les 24 rotations du cube sur la liste de cubes du 1),  on cale et on transforme en ensemble.
3) Une liste des permutations des cubes de la liste 1) induites par les rotations-calages qui préservent l'avatar associé (l'ensemble des cubes de la liste).

- On fabrique de manière incrémentielle les listes de solides à 1,2,3,... cubes. Les avatars permettent de vérifier qu'il n'y a pas de doublon, les listes de permutations permettent de compter les coloriages.

class Solide :   
    def __init__(self, ListeCubes, ListeAvatars,Symetries):
        self.lcub = ListeCubes
        self.lav = ListeAvatars
        self.sym = Symetries

UnCube = Solide([(0,0,0)],[set([(0,0,0)])],[(0)])

def Caler(ListeCubes) :
    minx = min(cub[0] for cub in ListeCubes)
    miny = min(cub[1] for cub in ListeCubes)
    minz = min(cub[2] for cub in ListeCubes)
    return [(cub[0]-minx,cub[1]-miny,cub[2]-minz) for cub in ListeCubes]

def Rotations(Cube) :
    a = Cube[0] ; b = Cube[1] ; c = Cube[2]
    return[(a,b,c),(a,-b,-c),(-a,b,-c),(-a,-b,c),\
          (-a,-c,-b),(-a,c,b),(a,-c,b),(a,c,-b),\
          (c,a,b),(c,-a,-b),(-c,a,-b),(-c,-a,b),\
          (-c,-b,-a),(-c,b,a),(c,-b,a),(c,b,-a),\
          (b,c,a),(b,-c,-a),(-b,c,-a),(-b,-c,a),\
          (-b,-a,-c),(-b,a,c),(b,-a,c),(b,a,-c)]

def Solidifier(ListeCubes):
    s=set(ListeCubes)
    LAva=[] ; LPerm=[]
    LRot=[Rotations(cub) for cub in ListeCubes]
    for i in range(24) :
        lc = Caler([r[i] for r in LRot])
        ava = set(lc)
        if not(ava in LAva) : LAva.append(ava)
        if ava == s :
            perm = [ListeCubes.index(cub) for cub in lc]
            if not(perm in LPerm) : LPerm.append(perm)
    return Solide(ListeCubes,LAva,LPerm)

def PousseCube(Cube) :
    a = Cube[0] ; b = Cube[1] ; c = Cube[2]
    return [(a+1,b,c),(a,b+1,c),(a,b,c+1),\
           (a-1,b,c),(a,b-1,c),(a,b,c-1)]

def AjoutCube(ListeCubes) :
    LAjout=[]
    for cub in ListeCubes :
        for i in range(6) :
            nouv = PousseCube(cub)[i]
            if not(nouv in ListeCubes) :
                LAjout.append(Caler(ListeCubes+[nouv]))
    return LAjout

def PlusUn(ListeSols) :
    LPU = []
    for sol in ListeSols :
        L=AjoutCube(sol.lcub) 
        for listcub in L :
            s=set(listcub)
            if all( not(s in solid.lav) for solid in LPU) :
                LPU.append(Solidifier(listcub))
    return LPU

LSUn=[UnCube]
LSDeux=PlusUn(LSUn)
...
LSSept=PlusUn(LSSix)

%time LSHuit=PlusUn(LSSept)

import math

def Info(ListeSolides,n) :
    nb = len(ListeSolides)
    nbcol = sum(math.factorial(n)//len(sol.sym) for sol in ListeSolides)
    print("Nombre de cubes : {2}.\n\
Nombre de solides : {0}.\n\
Nombre de solides colorés (une couleur par cube) : {1}."\
          .format(nb,nbcol,n))

Info(LSHuit,8)

Là, juste en jetant un coup d'oeil, je vois deux optimisations faciles:
- Utiliser des (frozen)sets au lieu de listes un peu partout:
   par exemple:

if not(perm in LPerm) : LPerm.append(perm)

LPerm.add(perm) est en O(1)

  for i in range(6) :
            nouv = PousseCube(cub)[i]

  for nouv in PousseCube(cub):

Merci des suggestions. On y gagne pas mal :

%time LSHuit=PlusUn(LSSept)

Du coup, j'ai tenté les neuf cubes. Ça rame, mais ça passe.

%time LSNeuf=PlusUn(LSHuit)

Je me suis permis de réécrire ton code GBZM. J'ai bien les même résultats

 Cliquez pour afficher

0: 0 (0) 0.000s
1: 1 (1) 0.000s
2: 1 (1) 0.001s
3: 2 (6) 0.001s
4: 8 (95) 0.005s
5: 29 (2715) 0.030s
6: 166 (104700) 0.128s
7: 1023 (4937310) 0.917s
8: 6922 (273708960) 7.306s
9: 48311 (17431530480) 64.425s

 Cliquez pour afficher

# See subject at https://www.ilemaths.net/sujet-combien-de-dispositions-a-partir-de-n-cubes-865463.html

from math import factorial
from time import perf_counter


class Solid:
    rotations = frozenset((
        lambda x, y, z: (x, y, z),
        lambda x, y, z: (x, -y, -z),
        lambda x, y, z: (-x, y, -z),
        lambda x, y, z: (-x, -y, z),
        lambda x, y, z: (-x, -z, -y),
        lambda x, y, z: (-x, z, y),
        lambda x, y, z: (x, -z, y),
        lambda x, y, z: (x, z, -y),

        lambda x, y, z: (y, z, x),
        lambda x, y, z: (y, -z, -x),
        lambda x, y, z: (-y, z, -x),
        lambda x, y, z: (-y, -z, x),
        lambda x, y, z: (-y, -x, -z),
        lambda x, y, z: (-y, x, z),
        lambda x, y, z: (y, -x, z),
        lambda x, y, z: (y, x, -z),

        lambda x, y, z: (z, x, y),
        lambda x, y, z: (z, -x, -y),
        lambda x, y, z: (-z, x, -y),
        lambda x, y, z: (-z, -x, y),
        lambda x, y, z: (-z, -y, -x),
        lambda x, y, z: (-z, y, x),
        lambda x, y, z: (z, -y, x),
        lambda x, y, z: (z, y, -x),
    ))

    def __init__(self, cubes):
        ordered_avatars = frozenset(Solid.gen_avatars(cubes))
        self.avatars = frozenset(map(frozenset, ordered_avatars))
        self.number_of_permutations = len(ordered_avatars) // len(self.avatars)

    def __eq__(self, other):
        return other and self.avatars == other.avatars

    def __ne__(self, other):
        return not self.__eq__(other)

    def __hash__(self):
        return hash(self.avatars)

    @staticmethod
    def gen_avatars(cubes):
        for rotation in Solid.rotations:
            yield Solid.move_to_origin(tuple(rotation(*cube) for cube in cubes))

    @staticmethod
    def move_to_origin(cubes):
        min_x = min(x for x, y, z in cubes)
        min_y = min(y for x, y, z in cubes)
        min_z = min(z for x, y, z in cubes)
        return tuple((x - min_x, y - min_y, z - min_z) for x, y, z in cubes)

    def add_cube(self):
        avatar = next(iter(self.avatars))
        for cube in avatar:
            x, y, z = cube
            for dx, dy, dz in ((-1, 0, 0), (1, 0, 0), (0, -1, 0), (0, 1, 0), (0, 0, -1), (0, 0, 1)):
                new_cube = (x+dx, y+dy, z+dz)
                if new_cube not in avatar:
                    yield Solid(avatar | {new_cube})


def main(max_nb_cubes):
    start = perf_counter()
    origin_cube = Solid([(0, 0, 0)])
    solids = [set(), {origin_cube}]
    print(f"{0}: {0} ({0}) {perf_counter()-start:3.3f}s")
    print(f"{1}: {1} ({1}) {perf_counter()-start:3.3f}s")

    for nb_cubes in range(2, max_nb_cubes + 1):
        new_solids = set(new_solid for solid in solids[nb_cubes-1] for new_solid in solid.add_cube())

        number_of_colored_solids = sum(factorial(nb_cubes) // solid.number_of_permutations for solid in new_solids)
        print(f"{nb_cubes}: {len(new_solids)} ({number_of_colored_solids}) {perf_counter()-start:3.3f}s")
        solids.append(new_solids)


if __name__ == "__main__":
    main(10)

En ne stockant pas les avatars mais juste la forme canonique de chaque solide (peu importe laquelle), je réduis drastiquement la consommation de mémoire et améliore même le temps.

Calcul de 10 cubes en un peu moins de 8 minutes:

 Cliquez pour afficher

10: 346543 (1254165746400) 427.821s

Bravo, ça c'est du travail de pro dont je serais bien incapable. Je fais du python en dilettante. J'ai essayé ton code sur ma machine. Un peu plus lent, mais tout à fait comparable :

0: 0 (0) 0.000s
1: 1 (1) 0.001s
2: 1 (1) 0.003s
3: 2 (6) 0.006s
4: 8 (95) 0.018s
5: 29 (2715) 0.054s
6: 166 (104700) 0.205s
7: 1023 (4937310) 1.215s
8: 6922 (273708960) 8.912s
9: 48311 (17431530480) 72.788s
10: 346543 (1254165746400) 605.767s

Par contre je ne suis pas d'accord avec ta première ligne : 0: 0 (0). Ça devrait être 0: 1 (1).

Ah oui aussi LittleFox, je ne comprends pas bien pour quoi tu écris : "Ça été galère d'être sûr d'avoir toutes (et que) les rotations possibles" ?

En continuant avec ce programme, il faudrait 9 mois pour calculer les chiffres de l'oeis
Ça reste possible ^^

@GBZM
J'ai d'abord voulu retrouver les rotations possibles et si possible les construire plutôt que d'écrire les 24. Ben j'ai juste fait plein d'erreurs J'ai repris tes rotations du coup. En espérant qu'elles sont juste (ça à l'air)

Il y a combien de solides avec 0 cubes et 0 couleurs? J'ai choisi 0 mais en fait 0 ou 1 ça n'a pas de sens. D'ailleurs l'oeis se garde bien de donner cette valeur.

Ben c'est clair qu'il y en a un seul : le solide vide. Et il est clair aussi que tous ses cubes sont coloriés (n'est-ce pas ?), en utilisant 0 couleur.

Donc, si on veut donner une valeur pour 0 cube, 1 est la seule possible.

Pour les rotations ; les rotations de la grille entière en dimension 3 sont données par des matrices de permutation, avec pour chaque matrice de permutation les quatre combinaisons de signes possibles pour avoir déterminant 1 : donc 0 ou 2 "moins" pour les permutations paires, 1 ou 3 moins pour les permutations impaires. C'est la structure de ma liste de rotations, avec les permutations données dans l'ordre de l'algorithme de Johnson-Trotter :
Le même procédé marche en toute dimension , pour donner les rotations de la grille entière. Au fait, une petite modification du programme permettrait de compter les poly-hypercubes en dimension 4,5,...

J'aimerais bien une procédure python qui produise la liste des rotations (en toute dimension d).  Ça doit être faisable.

Bonjour,
Ce qui est remarquable en "détente c'est qu'un amusement du départ de ty59847
aboutisse à une très belle étude des pros .
Imaginons simplement l'écart entre le niveau 4 proposé et le niveau 10 prouvé par eux.

Version du code générant les rotations via l'algorithme Johnson-Trotter et fonctionnant en dimension quelconque:

C'est trois fois plus lent par contre Je me suis arrêté après 1minute pour chaque dimension

Résultats :

 Cliquez pour afficher

     1D                 2D                  3D                  4D             5D
 1: 1 (1)              1 (1)               1 (1)               1 (1)          1 (1)
 2: 1 (2)              1 (1)               1 (1)               1 (1)          1 (1)
 3: 1 (6)              2 (9)               2 (6)               2 (6)          2 (6)
 4: 1 (24)             7 (114)             8 (95)              7 (79)         7 (79)
 5: 1 (120)           18 (1890)           29 (2715)           27 (2095)      26 (1970)
 6: 1 (720)           60 (38880)         166 (104700)        164 (94560)    154 (80952)
 7: 1 (5040)         196 (957600)       1023 (4937310)      1316 (6102495)
 8: 1 (40320)        704 (27468000)     6922 (273708960)
 9: 1 (362880)      2500 (899035200)
10: 1 (3628800)     9189 (33063811200)

@dpi,
C'était un peu mon objectif en lançant ce sujet ouvert, avec un nombre de cubes pas forcément limité, je voulais pécher du gros poisson

Je savais que pour 4 cubes,  on pourrait trouver la solution à la main, pour 5, ça doit être possible de le faire à la main, mais au delà, c'est une autre histoire.

Je donne quand même le lien vers l'autre sujet similaire, peut-être que LittleFox va mordre à l'hameçon ?

La même question de base, mais avec des tétraèdres réguliers : Combien de dispositions à partir de n tétraèdres

Les nombres sont plus petits, 4 faces au lieu de 6, mais l'approche est plus compliquée.

En tout cas, merci à tous pour vos réponses.