Discuss Color Coordination here

[mith]

Link to puzzle

[Speeder]

Hi All,

I believe I have a guaranteed method of aligning the colour wheels. Only it may not be the quickest.

Here goes...
Invisibled:

There are seven disks, let's call them D1 D2 D3 D4 D5 D6 D7
There are seven positions for the disks (ignoring rotations), let's call them P1 P2 P3 P4 P5 P6 P7 where P1 is the centre position and P2-P7 are the positions of disks around the centre (let's define them as clockwise from the top of the board for sake of argument).

There are 5040 combinations of Disks and Positions on the board.

P1 P2 P3 P4 P5 P6 P7
---------------------------
D1 D2 D3 D4 D5 D6 D7
D1 D2 D3 D4 D5 D7 D6
D1 D2 D3 D4 D7 D5 D6
D1 D2 D3 D4 D7 D6 D5
etc
etc

First we put D1 in P1, D2 in P2, D3 in P3 etc (the first combination)

The solution is then a question of rotating the disks and repositioning them if a colour mismatch occurs.

Disk Rotation procedure:
The disk in P1 remains stationary. We rotate the disk in P2 to match the colour on the disk in P1. Then we rotate the disk in P3 to match the colour on the disk in P1. If the colours on the disks in P2 and P3 match we continue with P4...P7 in a similar manner, each time matching the disk with that at P1 first then comparing it with its previously positioned adjacent disk. If there is a colour mismatch at any time (i.e. the disk matches that in P1 but not its adjacent disk) we need to stop and reposition the disks as per the Disk Re-positioning procedure below. If all colours match when we rotate the final disk then we have succeeded in solving the problem.

Disk Re-positioning procedure:
We re-arrange the disks according to the next combination from the possible combinations of Disks and Positions then go back to the disk rotation procedure.

(I have chosen not to rotate the centre disk as the equivalent of this is happening in the repositioning procedure. We could substitute some of the positions for rotations of the centre and this would reduce the combination of disk/positions to 720. All we would need to do is rotate the centre for every mismatch until it has rotated 6 times [or 7 if you count the initial position as a 'rotation' if you see what I mean] then reposition. But then you would have to eliminate those combinations of positions that were technically equivalent.)


I would be very interested if there is a really quick way of getting the solution. And let me know if my solution is flawed.

Speeder.

[aqua]

The solution procedure seems quite good. I would stick to the assertion that the centre disk never can rotate, period.
Manually I dont see a faster way than the given backtracking procedure. Being too lazy for that I created an integer linear optimization program. Variable X(d,l,r) is 1 if disk d is placed at location l with rotation r. With some nice location and color constraints, this solves the problem in 16 Branch & Bound nodes:

Code:

g n     n y      y 7 r   r 1 w       b w     g b   y b     w g     b w  g 2 r   r 6 n   n 4 r   w n     y b     y g       n y     b y      b 3 g   g 5 r       w r     n w

[ewan]

can you speed up the process by noticing that once one disk is placed with say red joining the center wheet, then red will not be on a center position on any other wheel?

also each colour occurs only once per wheel, so it can only be used in one inner join and one outer join and never on the same wheel

addionaly due to the limited number of colours each colour must be used once in an outer link and once in an inner link.

for each possible inner wheel the order of the middle colour on each outerwheel is fixed. if we make a grid for each inner wheel eg

1
2 rwgnyb
3

there can only be a limited set of combinations of other colours in positions 1 and 3. for instance in the above case you cant have r,w or b in position 1r or 3r.

as each colour is used up are choices become more and more limited

[kevinatilusa]

Another possibility might be to focus on sets of 3 disks. There are only 35 triples of disks, and at first glance it appears that not all triples of disks can be placed to form a triangle. Perhaps there's only one way to place the 7 disks so that each triple falls in the list of "usable triangles"?

[Guest]

i made a mistake you can hav b in r1. hmmmm

[Garfield]

Speeder,

did your proposed method assume the "correct" center color wheel was the one in the center? I'm not sure that's necessarily a good assumption. Possibly any one of the 7 could go there increasing the complexity of the problem under consideration...

Garfield

[Speeder]

Indeed any one of the colour wheels can be in the centre, but I have accounted for this in my method.

I would like to find a quicker way of solving the problem. I can't help but think there might well be an altogether different method. I have been wondering whether it is possible to transform the problem to a topologically or logically equivalent puzzle that makes solving it much easier.

Maybe we can somehow change the wheels to horizontal strips where you just need to line up the like colours vertically? Maybe if we change the colours to numbers we can put them in a matrix and perform transformations? I don't know?

Speeder.

[Highest Prime]

[Highest Prime]

OK, let me try this again.

Our variables, as I see them, are:

* Wheel identity

* Wheel orientation

* Slot number

* Color

I should note that wheel identity isn't a "variable," per se, as it's something we're always going to have to specify in order to determine the color of that wheel at any position. (Or solve for, if we compile a program that looks backward to determine whether a given wheel identity corresponds to a series of colors at given positions.)

* We have a matrix that provides color as a function of wheel identity and wheel orientation (position), but only relationally - I can't tell you what color will be on wheel Alpha at position 1 unless you give me the color of that wheel at another position.

* We have two equations for color equality as a function of slot number and position for the 6 outside slots. (We also have position - at least, those positions we're interested in equating - as a function of slot number.)

* We have one equation for color equality as a function of slot number of position for the center slot as it relates to all 6 outside slots.

So what does all this leave us with? I still don't see any way to solve this that doesn't involve a branching-tree approach ... trying one wheel at a time in the center, coming up with the bounded set of solutions to satisfy the equalities, and looking backwards into the color matrix to determine if our set of wheels contains those series of colors required.

Pah, I hope someone else can run with this information (or tell me that I've wasted an hour and a half of my day ... I'm prepared for either).

H'

[Guest]

I have a method to solve this longhand (if you're not easily bored)
It makes use of recognising the extra information implied when you arrange the wheels as if they were 7 hexagons
(sorry guys, I tried to draw this but it looked rubbish)

Imagine the inner hexagon (I) has sides labelled 1,2,3,4,5 and 6.
The topmost side is labelled 1 and has hexagon II sitting on top of it (joined at side 1), and has hexagon V underneath it (joined at side 4).
Running clockwise from hexagon II we have III (joined to I via side 2, and joined to II via side b) and hexagon IV (joined to I at side 3 and joined to III at side c and joined to V via side d) Completing the set we have hexagon VI (joined to I via side 5, to V via side e) and hexagon VII (joined to I via side 6, to VI via side f and to II via side a)
NB do draw this out before continuing!

The method works by recognising that a <> (1 or 6), b <> (1 or 2), c <> (2 or 3), d<> (3 or 4), e <> (4 or 5) and f <> (5 or 6)
We describe the wheels via their clockwise colours:
where W=white,U=blue,K=black,G=green,R=red,Y=yellow:
Wheel A = W,U,G,R,K,Y,W,U
B = W,U,K,Y,G,R,W,U
C = W,R,G,Y,K,U,W,R
D = W,K,G,U,Y,R,W,K
E = W,G,K,U,Y,R,W,G
F = W,U,Y,G,K,R,W,U
G = W,G,Y,U,R,K,W,G

The method will now involve orientating the central wheel (I) so that we match wheel II via the white spot.

If we choose wheel A as I and fix side 1 as W (white) we get:
1=W,2=U,3=G,4=R,5=K,6=Y

*Try disc B as II => side a = U and side b = R
now since we know disc VII must have clockwise sequence (a,6,[f]) we look for
discs with sequence U,Y [possibles = D,E,F] ,
and disc III must have sequence (c,2,[plus b]) so look for U,R [possible = G]
**with G as only possible III, we know that side c = Y,
hence need disc IV with seq. ([d],3,c) so look for G,Y [poss. C,G]
***G is III so C is IV, hence side d = R,
hence need disc V with seq. ([e],4,d) so look for R,R which is
impossible so B cannot be disc II (if A is I)
*Now try disc C as II => side a = R and side b = U
so look for VII with seq. R,Y [no possibles], so C cannot be disc II
*Try disc D as II => a = K, b = R
so look for VII with seq. K,Y [poss. A, B]
and III with seq. U,R [G]
** G is III => c = Y
so look for IV with seq. G,Y [C,G]
*** G is taken, so C is IV => d = R
so look for V with seq. [R,R] - impossible so D cannot be disc II
*Try disc E as II => a = U, b = R
so look for VII with seq. U,Y [D,F]
and III with seq. U,R [G] - this fails as for the previous wheel, so E not II
*Try F as II => a = U, b = R
- this fails as for previous wheel, F not II
*Try G as II => a = G, b = K
so look for VII seq. G,Y [C,G]
and III seq. U,K [B]
** B is III hence side c = W
so look for IV seq. G,W [none] hence G is not II

Hence we have shown that if wheel A is central no fit can be found.

Now cutting a long story short...

Using wheel E as central (I) gives:
1 = W, 2 = G, 3 = K, 4 = U, 5 = Y, 6 = R
*Try F as II => a = U, b = R
so look for VII seq. U,R [poss. G]
** G is VII hence side f = K
so look for VI seq. K,Y [poss A,B]
*** try B as VI => e = G
so look for V seq. G,U [D]
**** D as V => d = Y
so look for IV seq. Y,K [C]
***** C as IV => c = U
so look for III seq. U,G [A]
This completes the sequence given by aqua earlier...

[Oscar]

...that was me by the way...

[Guest]

not good at the whole mathamatics side but yay for photoshop...heres a link to my photoshopped pic of the solution i found....NOTE LINK TO SPOILER -

http://www.strike9.com/mickyj/colourcorodinationsolved.JPG

[Speeder]

I don't think you are supposed to find the solution to how the wheels should be aligned, but rather the *method* of how to solve the puzzle for any given set of colour wheels.

Speeder.

[dan101]

I have just solved the puzzle and now writing out how I did it. will post it on in a minute. dan101

[dan101]

I just went by the colours on the discs. HOt to Cold. White as the hotest and opposite to hot is cold that is blue. how does that sound??

[Guest]

I just rediscovered this site, and I figured I might as well sign up for the forums this time.

Speeder's method does guarantee to find a solution if it exists (at least if I'm reading it right), but it certainly seems time-inefficient. My original method turned out to be the same as Oscar's. It seems quicker than Speeder's, but I'm not sure. I decided to try formulating it a bit differently to see if I could make it easier to find the solution manually.

Like Oscar, I first wrote down the clockwise sequence for each disc:
1 = WGYURB
2 = WUBYGR
3 = WRGYBU
4 = WBGUYR
5 = WGBUYR
6 = WUYGBR
7 = WUGRBY

Then I made a table (I used Excel) consisting of 6 columns, 1 for each color. Each column had 7 rows, 1 for each disc. The entries of the table were of the format 'xy', where x and y were the colors before and after the color of the column. For example, if my first column was White, then the first row was BG, the second row was RU, the third row was UR, and so on.

To position a disc at the center, I rearranged the columns so that they were in the reverse order for that disc. So if I wanted to test disc 1 as the center, my columns were rearranged as BRUYGW.

To see whether I could find a fit, I started with the first row of the first column (ignoring the row corresponding to the disc in the center). The goal was to find a path starting from that entry, going across the columns in a way such that I never selected an entry in the same row as a previous entry in the path, and that the second letter of any entry matched the first letter of the following entry (and the path wrapped around). It's much easier to understand with an actual table in front of you. But I found that I could quickly determine whether a disc was a possible center disc just by checking whether a path existed.

The idea is pretty much equivalent to Oscar's method, but it was easier for me to use the table because I didn't have physical representations of the discs.

[fadeblue]

Oops, looks like I didn't log in before I posted that...

[lostkiwi]

There is a solution that was immediately obvious when I first saw this puzzle. Many of the assumptions above assume that the centre piece does not move, however since all of colours on the disc are not all in the same pattern thais means that in some cases the centre piece must be moved in order to be completed.

Consider the board like this:

[fadeblue]

lostwiki: That approach assumes that all the discs are in their proper position, and that they only need to be rotated. In most cases, that method would never find a solution, even if one existed, because it doesn't swap any discs.

[lostkiwi]

Ahh, sorry you are indeed correct. I misinterepreted the question. Apologies

[Milo]

I solved it by trial and error (stoneage compared to the computational methods) as did some others. While there are 30,240 (?) possible ways to arrange the 7 discs, I found that only 121 have to be tested to find the solution. Total time to test all 121 was 35 minutes. I actually found the solution after 24 minutes and 86 tests.

[CrystyB]

[sidenote]I'm getting 117,573,120 possible ways to arrange the discs...[/sidenote]

[Milo]

CrystyB-

I thought about it some more and came up with 235,146,240; double what you have. It has been a long, long time since I've done anything with permutations and combinations but I arrived at this figure by 7! * 6^6.

How did you determine your figure?

P.S. If that is explained in your sidenote, I apologize. I'm new to the board and could not figure out how to open it.

[CrystyB]

No, you're right. I did 7! * 6^7 / 12, thinking that for any configuration there are five rotations and one mirror for each that would also appear. I think i forgot that the whole thing is not as abstract as i thought, and we don't know what's on the back of the wooden pieces.

[fadeblue]

In terms of speed, I think the method I mentioned could be the fastest non-computational solution. It has the advantage of testing cases in an almost-parallel fashion. With 7 discs, there are only 7 "grids" you need to check (with a "grid" referring to an arrangement of the columns), and those grids are very easy to check quickly. Once I hit upon this method, it took me less than 10 minutes to find the solution.

Another advantage is that as N increases (with N being the number of colors on each disc, and N+1 being the number of discs), the amount of time used in this process also grows fairly slowly. On the other hand, this method doesn't extend to similar puzzles that don't have the same layout (one central disc with the others around it).

[Fuldu]

The first thing I noticed is that, in the example given, the two connected greens up top can't go together that way because the center would require two yellows. More generally, for any pair of colors X and Y that appear (all orderings are clockwise) XY on one disk and YX on another, those two disks can't connect at X or Y if one is in the center. A quick scan shows a number of these pairings and some more complex math suggests that a good-sized number of these pairings is probable for any set of disks.

In the example given, RW occurs four times and WR once (disk 5). Testing WR in the center means that I only have to test two other disks against that disk's W or R. As it happens, one of those two disks (disk 4)opposes disk 5's WRG with GR, so it can't connect at R, either. So, if WR goes in the center, disk 1 has to connect to it at R. This requires a disk with BW to connect to disk 5 at W, none of which exist. So disk 5 can't go in the center. I've eliminated 1/7 of the possible configurations with substantially less effort than a strict trial-and-error algorithm.

As an aside, I could have drawn that conclusion much more quickly by noting that disk 5 and disk 2 are reversals of one another, that they therefore cannot connect because no piece could then connect to both of them, and that neither of them can thus be in the center, because the center disk connects to all of the other disks. But that's not nearly as useful a general thought process, because it's unlikely that two reversals will occur in a random set of disks.

Scanning again, I see that disk 1 has YB to three BY disks. None of the remaining three disks has RB to contrast the YBR on disk 1, but one of them does have YG to contrast disk 1's GYB. So, now there are only two disks to test against disk 1's Y, disks 4 and 5. Disk 4 at Y requires disk 6 at G, leaving nothing with a KW to connect to 6 and 1. Similarly, disk 5 at Y requires disk 7 at G, leaving nothing with a BW to connect to 7 and 1. Another disk eliminated from the center.

Fundamentally, this isn't any different from the processes described above by fadeblue and Oscar, and I probably could have done the final branching much faster if I had done the up-front work they described instead of going back and forth between the picture and my sheet of paper. It's just using one quick guideline to pick the best starting location around the prospective center disk to require the fewest branches examined to dismiss it. I'm sure this process could be structured to apply to the computer algorithms being discussed, although it's far from clear that it would result in fewer overall computations for the processor. I don't have a good sense of how much effort it would require to tell the computer how to look for this sort of thing compared to simply trying everything.

[Guest]

This not the solution, but I hope it may help others reach it. I do not know if these considerations are new; I apologize if I am repeating ideas, especially if they have already proven unhelpful.


I would note first off that the correct solution to the puzzle probably lies in a combination of speed and efficiency. Everyone has assumed this. But, I would remind you that, in the context of the overall problem, we are dealing with the manipulation of a physical object. While tranferring the data contained in the puzzle pieces to another medium does make manipulation easier, it also requires time and effort. Simply recording the aspects of the puzzle, whether in charts or pictorial representations, seems a rather inconvenient step in the solution. I believe the correct solution will not require any attempt to formalize the puzzle, but will begin and end with the manipulation of the pieces.

Second, because certain disk combinations can be formed without regard for which disk is the center disk (a "triangle" of three pieces, or a "rhombus" of four, for instance), I do not think the trial-and-error-with-an-assumed-center method/s are necessarily the best. (Note that to do this, you should probably remove the disks from the circular floor. Otherwise, it is difficult to shift which disk is treated as the middle without shifting all the disks around.) The trial-and-error method I suggest involves an initial grouping of three (arbitrary, but fitting) disks. From such a group, additional pieces may be placed wherever a fit is possible; when it becomes apparant that the current configuration supports no solution, one may simply step backward to the last point at which there was a choice of which disk to place, and makes an alternate choice. However, the solution need not be a completely mechanical process; the fluidity of the grouping process allows you to see when you are nearing a solution, and identify particular variations that will bring you closer. [I apologize for my unclear language here. I am not sure how to communicate what I mean, but if you print images of the disks and play with them a bit, I think you will see what I mean. The center-based trial-and-error method doesn't seem to inspire intuitive connections as readily as the grouping-based method, at least for me.]


This may be a dead-end, because 1) it much harder to adapt this method to systematic eliminations, and 2) the assumed-center trial-and-error solutions are already fairly fast. The process of elimination is rapid, especially when one is physically manipulating the objects involved.



In summary:

1) When considering the "best" way to solve the wood puzzle, the time time spent recording information and manipulating data must be taken into account.

2) An alternative solution may lie in the treatment of disks as groups without a fixed location on the board, rather than in trying each disk as a fixed center.

[Guest]

The amount of time recording data is much faster than the branch and bound solutions (you only need to record 42 objects, rather than try 5040 cases). For a more general problem with many disks, recording the cost will be neglible.

I feel really silly suggesting this, but perhaps the fastest solution is to repaint the dots? You only need to repaint 42 dots (and since one can keep the center disk invariant, you only need to repaint 35 dots). This, of course, doesn't solve the interesting problem.

[Guest]

Not all permutations need to be tried, obviously; the method of assuming a center disk and thenplacing disks as possible requires actually placing very few configurations. As noted above, the puzzle can be solved in less than ten minutes this way (though luck would obviously change the time required). Actually, I don't see it taking ten minutes if you work quickly, even if you have to test every disk in the center. It just doesn't take that long to try the different combinations. How long does it actually take, from start to finish, to record the marking on all the disks and then manipulate the data in such a way as to find the answer (and then put the disks in the correct formation--a negligible step)?

[fadeblue]

As I stated earlier, my method yielded a solution in under 10 minutes. I tried re-entering the data just now to see how long it would take (at a normal pace), and my data entry took less than 10 minutes as well. So from start to finish, I would've found the solution in less than 20 minutes. I'm not sure what order of speed you're aiming for, but I would guess that 20 minutes is pretty fast for this sort of puzzle.

(Although the fact that no one has "solved" the puzzle yet suggests that there's a very elegant and quick method we haven't found yet.)

[Guest]

I apologize; I confused your 10-minute figure as relating to Speeder's initial T&E method.

I'll try making some disks today and using Speeder's method, to see how close it comes to 20 minutes. Obviously, one person's skill/speed does not determine the correct solution the puzzle, but it should give a rough idea of how much advantage is gained from reorganizing the data into a friendlier form.

[Speeder]

I think there maybe some merit in arranging the discs into triplets as kevinatilusa mentioned previously.

In a triplet each disk *could* be regarded as the centre as we wish. There must be a finite set of triplets where the colours correspond. Ultimately we could choose from these triplets and join them together by overlapping the disks that are similar. But here's my method...

We could draw up a table to say that, for example,(roughly speaking) disks 1,2,3 join on R,G,B. Then we could notice that disks 1,2,4 also join on R,G,B this would imply that 1,2,3,4 can't join together while either 1,2,3 are joining on R,G,B or 1,2,4 are joining on R,G,B. If you get me.

We could put triplets in rows where they do not exclude other triplets. A new row for each triplet combination that is excluded by the above row. (This would include where the same disks have different combinations.)

Once we have a row with enough entries to make the whole, we may find the solution. We may have to look at the frequency of each disk in each row to help choose the correct one. The disk with the highest frequency is probably the centre disk.

Anone think they could make this work?

Speeder.

[cmsenthil]

Found an interesting way to solve this puzzle. This puzzle, like any other, can be solved with a computer program, and I did just that. However, with an approach, that I doubt if anyone has ever taken to solving puzzles.

Without any more rhetoric here goes: I solved this puzzle using a database SQL, and here are the steps leading up to it (the solution took only milliseconds to process):

Create a table called circles:
create table circles
(
blk_num number not null,
color_position number not null,
color_cd char(1) not null
);

Although Primary key needs to be only the 1st two columns I made all three as Primary Key for efficiency.

Create the data with:

Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (1, 0, 'Y');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (1, 1, 'B');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (1, 2, 'R');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (1, 3, 'X');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (1, 4, 'W');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (1, 5, 'G');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (2, 0, 'Y');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (2, 1, 'G');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (2, 2, 'R');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (2, 3, 'W');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (2, 4, 'B');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (2, 5, 'X');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (3, 0, 'Y');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (3, 1, 'X');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (3, 2, 'B');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (3, 3, 'W');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (3, 4, 'R');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (3, 5, 'G');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (4, 0, 'Y');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (4, 1, 'R');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (4, 2, 'W');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (4, 3, 'X');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (4, 4, 'G');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (4, 5, 'B');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (5, 0, 'Y');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (5, 1, 'R');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (5, 2, 'W');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (5, 3, 'G');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (5, 4, 'X');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (5, 5, 'B');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (6, 0, 'Y');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (6, 1, 'G');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (6, 2, 'X');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (6, 3, 'R');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (6, 4, 'W');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (6, 5, 'B');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (0, 0, 'Y');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (0, 1, 'W');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (0, 2, 'B');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (0, 3, 'G');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (0, 4, 'R');
Insert into CIRCLES (BLK_NUM, COLOR_POSITION, COLOR_CD) Values (0, 5, 'X');
COMMIT;


And finally run the SQL:
select c11.*,c12.*,c13.*,c14.*,c15.*,c16.*,cc1.*
from
circles c11, circles c12, circles c13, circles c14, circles c15, circles c16,
circles c21, circles c22, circles c23, circles c24, circles c25, circles c26,
circles c31, circles c32, circles c33, circles c34, circles c35, circles c36,
circles cc1, circles cc2, circles cc3, circles cc4, circles cc5, circles cc6
where
c11.blk_num not in (c12.blk_num, c13.blk_num, c14.blk_num, c15.blk_num, c16.blk_num, cc1.blk_num) and
c12.blk_num not in (c11.blk_num, c13.blk_num, c14.blk_num, c15.blk_num, c16.blk_num, cc1.blk_num) and
c13.blk_num not in (c11.blk_num, c12.blk_num, c14.blk_num, c15.blk_num, c16.blk_num, cc1.blk_num) and
c14.blk_num not in (c11.blk_num, c12.blk_num, c13.blk_num, c15.blk_num, c16.blk_num, cc1.blk_num) and
c15.blk_num not in (c11.blk_num, c12.blk_num, c13.blk_num, c14.blk_num, c16.blk_num, cc1.blk_num) and
c16.blk_num not in (c11.blk_num, c12.blk_num, c13.blk_num, c14.blk_num, c15.blk_num, cc1.blk_num) and
cc1.blk_num not in (c11.blk_num, c12.blk_num, c13.blk_num, c14.blk_num, c15.blk_num, c16.blk_num) and
--
c11.blk_num = c21.blk_num and c11.blk_num = c31.blk_num and
c12.blk_num = c22.blk_num and c12.blk_num = c32.blk_num and
c13.blk_num = c23.blk_num and c13.blk_num = c33.blk_num and
c14.blk_num = c24.blk_num and c14.blk_num = c34.blk_num and
c15.blk_num = c25.blk_num and c15.blk_num = c35.blk_num and
c16.blk_num = c26.blk_num and c16.blk_num = c36.blk_num and
--
cc1.blk_num = cc2.blk_num and
cc1.blk_num = cc3.blk_num and
cc1.blk_num = cc4.blk_num and
cc1.blk_num = cc5.blk_num and
cc1.blk_num = cc6.blk_num and
--
mod(c11.color_position+1,6) = c21.color_position and mod(c11.color_position+5,6) = c31.color_position and
mod(c12.color_position+1,6) = c22.color_position and mod(c12.color_position+5,6) = c32.color_position and
mod(c13.color_position+1,6) = c23.color_position and mod(c13.color_position+5,6) = c33.color_position and
mod(c14.color_position+1,6) = c24.color_position and mod(c14.color_position+5,6) = c34.color_position and
mod(c15.color_position+1,6) = c25.color_position and mod(c15.color_position+5,6) = c35.color_position and
mod(c16.color_position+1,6) = c26.color_position and mod(c16.color_position+5,6) = c36.color_position and
--
cc1.color_cd = c11.color_cd and cc1.color_position < cc2.color_position and
cc2.color_cd = c12.color_cd and cc2.color_position < cc3.color_position and
cc3.color_cd = c13.color_cd and cc3.color_position < cc4.color_position and
cc4.color_cd = c14.color_cd and cc4.color_position < cc5.color_position and
cc5.color_cd = c15.color_cd and cc5.color_position < cc6.color_position and
cc6.color_cd = c16.color_cd and
--
c21.color_cd = c36.color_cd and
c22.color_cd = c31.color_cd and
c23.color_cd = c32.color_cd and
c24.color_cd = c33.color_cd and
c25.color_cd = c34.color_cd and
c26.color_cd = c35.color_cd
;

[stan_oradba]

the sql solution is cool !

[Speeder]

cmsenthil, your solution is ingenious, but I've executed the SQL and got the result and I don't know what it means.

Here's what I got:

blk_num, color_position, color_cd

2 , 0 , Y
1 , 2 , R
6 , 4 , W
0 , 3 , G
3 , 1 , X
4 , 5 , B
5 , 0 , Y

What position/rotation are the wheels in?

Incidentally, I feel there must be an elegant solution that does not involve a spreadsheet, database or computer program.

Bravo for your method though.

Speeder.

[cmsenthil]

Speeder, hope this helps:

The table CIRCLES has the following definition:

BLK_NUM is the Block Number or the Piece Number (corresponds to each cookie and ranges from 0 to 6)
COLOR_POSITION ranges from 0 to 5 and is useful in determining the sequence of the dots on the cookie
COLOR_CD is of course the color of the dot.

When we defined the table data each cookie was given a number from 0 to 6. This is the original number.

The result is the order in which you need to place the cookies (based on the original number). So you place cookie # 2, 1st and keep going clockwise, placing cookie #1 next and so on until you complete the circle. You place the last cookie (# 5) in the center.

The 2nd and 3rd values in the output help you rotate the placed cookies and align the dots. So rotate (or place cookie) # 1 so that Yellow is facing the center. Red dot faces center for cookie # 2 and so on.

Check out the picture below as well for the explanation of the solution above.

Senthil

[mwaring]

I tried posting earlier today, and it hasn't shown up, if there is a lag and this is a duplicate I apologize for being a clueless newbie! Now for my 2 cents:

I printed the puzzle and cut out the pieces, numbered them 1 to 7, and then started with 1 in the middle, lined up the W dot with #2, looked for the next pair to match, etc, and if none was found then matched 1 with 3... then used 2 in the middle, match with 1 (since you are following around 2, you do need to repeat this pair)... I got lucky and my #3 disk was the center that worked, found the solution in about 10 minutes. Any type of matrix or analysis of the disks that I could come up with in the end was more work than just trial and error, so I've pondered a new line of questioning that I haven't seen brought up yet:

My calculations (6!/6) tells me there are 120 possible unique disks that can be created.
--Does every set of 7 disks have a unique solution? (My guess would be no)
--Do any sets of 7 disks have more than one solution? (My guess would be yes). How many?
--What set of 7 disks has the MOST solutions? (Do any have more than 2?)
--Some pairings of colors are over- or under-represented (Fuldu pointed out that RW occurs 4 times, I've noticed GW does not occur at all). Is there a set with a solution that represents all pairs of colors? Is there a combination that has an equal number of each color pair??

I'll leave the actual answers to these questions to those of you with the fancy computer programs that can do this way faster than I could manually...

Mike

[Guest]

Couldnt you just put the middle disc in and then align all the others with it. It would have to fit right?

[Beartalon]