calculates all possibilites of 4 cubes - math

Question

So, I have 4 cubes with colors on each face, the colors can be orange, blue, red or green
My objective is to know how to position and rotate the cubes in a line so there is the same colors on each face of the line
example
example2
The colors between cubes and at the left and right of the line don't matter
I've tried some stuff in python but I can't even find a way to know how to compute that
If someone can help me out to find a program that takes the colors of the cubes and show the solution would be great. I mainly use Python but if the program is made in another language is okay too

Answer 1

Alright, let's do a little math first. There are four cubes. Each cube has at most 24 unique orientations: first, there are 6 choices for face A; second, there are up to four choices for face B. If we compute 24^4 we find there are 331,776 unique orientations of the set of four cubes. We might as well plan on trying all of these since the number is so low. If the number were higher, we might need to be a little smarter, but bear with me for now.
So, we are going to brute-force this. We need to represent each cube in such a way that, given an orientation, we can get the front, back, top and bottom colors. It might be helpful to model these cubes by naming the faces. We can name them as follows for orientation #1, which we can consider the default orientation:
Face A/0 is the top of the cube
Face B/1 is the front of the cube
Face C/2 is the right of the cube
Face D/3 is the back of the cube
Face E/4 is the left of the cube
Face F/5 is the bottom of the cube
Now, the orientations of the cubes can be thought of as a permutation of these faces. We could try to write code that calculates what the Nth permutation is, or we could just list all 24 unique orientations and the mappings for each:
[0,1,2,3,4,5] ... the identity mapping, since face A/1 is the default
[0,2,3,4,1,5] ... rotate #1 90 deg clockwise around the positive vertical axis
[0,3,4,1,2,5] ... rotate #1 180 deg clockwise around the positive vertical axis
[0,4,1,2,3,5] ... rotate #1 270 deg clockwise around the positive vertical axis
[1,5,2,0,4,3] ... rotate #1 90 deg counterclockwise around the positive horizontal axis
[1,2,0,4,5,3] ... rotate #5 90 deg clockwise around the positive vertical axis
[1,0,4,5,2,3] ... rotate #5 180 deg clockwise around the positive vertical axis
[1,4,5,2,0,3] ... rotate #5 270 deg clockwise around the positive vertical axis
[2,1,5,3,0,4]
[2,5,3,0,1,4]
[2,3,0,1,5,4]
[2,0,1,5,3,4]
[3,0,2,5,4,1]
[3,2,5,4,0,1]
[3,5,4,0,2,1]
[3,4,0,2,5,1]
[4,1,0,3,5,2]
[4,0,3,5,1,2]
[4,3,5,1,0,2]
[4,5,1,0,3,2]
[5,3,2,1,4,0]
[5,2,1,4,3,0]
[5,1,4,3,2,0]
[5,4,3,2,1,0]
Now, we can write a function which, given an orientation and a face, will tell us the color:
GetFaceColor(orientation, face)
1. return colors[permutations[orientation][face]]
Here, permutations is an array of the permutation arrays given above, and colors is an array where the colors of the six cube faces are specified for orientation #1.
Now, all we need to do is use four nested loops to check all 24^4 possibilities:
FindSolution()
1. for w = 1 to 24 do
2. for x = 1 to 24 do
3. for y = 1 to 24 do
4. for z = 1 to 24 do
5. if FacesMatch(w, x, y, z, 0)
and FacesMatch(w, x, y, z, 1)
and FacesMatch(w, x, y, z, 3)
and FacesMatch(w, x, y, z, 5)
then return (w, x, y, z)
6. return null
FacesMatch(or1, or2, or3, or4, face)
1. color1 = cube1.GetFaceColor(or1, face)
2. color2 = cube2.GetFaceColor(or2, face)
3. color3 = cube3.GetFaceColor(or3, face)
4. color4 = cube4.GetFaceColor(or4, face)
5. return color1 = color2 and color2 = color3 and color3 = color4