----------------------------------------------
2009-01-06 20:52:51
this is my comments page

chris

----------------------------------------------
2009-01-07 10:29:19
Have you tried to rotate the matrix ccw 90 deg? Im just curious if this would give you the same corresponding colors in your sample output.

----------------------------------------------
2009-01-07 19:49:23
You can solve this.
The Orange 6 tier tower fits on to one of the 5 tier spaces. The Yellow 5 tier fits on to one of the 6 tier spaces.
booyah!

----------------------------------------------
2009-01-12 22:24:33
Your last commentor seems to be correct and that does seem to be the answer... the only way to resolve this puzzle is by using the Orange 6 tier / Yellow 5 tier trick, not by math, not by logic. How disappointing, but at least now I can put it away and stop racking my brains over finding the solution. Thanks for posting this site Professor Raphael. And thanks to your brother for posting your website on Yahoo Answers!

Lee

----------------------------------------------
2009-01-14 20:32:47
if you switch the orange 6 and yellow 5 they miraculously fit onto the others pegs - this was very disheartening but unbelievably observed by my genius 5 year old son who clearly was thinking outside the box

----------------------------------------------
2009-01-27 17:44:36
I did the same as you, wrote a program to prove that it wasn't solvable. After that, we kept studying it, and finally found the "trick"

----------------------------------------------
2009-02-14 10:31:17
it is possible because one of the 5 towers fits into the a spot where the 6 is supposed to go. A 6 tower fits into a spot where the 5 spot goes. so it becomes possible

----------------------------------------------
2009-02-14 17:05:44
Prof. Raphael,

I just purchased a 36 cube for my AI students to try their hand at, and was about to write a program myself when I realized that the problem was so constrained that it would be about as quick for me to try a brute force solution by hand. I eschewed the puzzle itself, instead working with Microsoft Journal and using different colors of "ink". In that fashion I could be pretty comfortable using their "undo" operation, secure that my backtracking was correct. I confirmed in less than an hour that there is no solution.

Dorian Yeager
Professor of Computer Science and Mathematics
Grove City College
dpyeager@gcc.edu


----------------------------------------------
2009-02-14 17:09:09
Wow! After reading the other comments I feel like a fool. Now how can I adjust this "assignment" to allow for the "trick"?

Dorian

----------------------------------------------
2009-03-29 17:49:22
I did the same thing - this puzzle is very cheap because it is designed in such a way that the orange 6 fits on one (and only one) of the 5 spaces and the yellow 5 fits on one (and only one) of the six spaces. We actually figured that out one time, but thought it was not right until we saw others thought that was the same solution as well.

I plugged the new 6x6 matrix into my program and came up with 4 possible solutions once the 5 and 6 are switche... Bad puzzle in my mind.

----------------------------------------------
2009-04-21 19:20:57
one 6 peg can fit on a 5 slot and one 5 peg can fit on a 6 slot!!!!!!!!!!!!!!!!!!!!!


----------------------------------------------
2009-04-28 11:26:33
I am very impressed with your program. However there is a solution to this puzzle. The reason why there is a solution is because there are two trick pieces in the puzzle - an orange one and a yellow one. I tried writing a program also put it was way to clonky to be efficient. It was a GUI and ran on windows not linux like yours. I will be trying yours on Linux. I will also try to change the code to take into consideration the two trick pieces.

----------------------------------------------
2009-04-28 11:31:05
If anyone has updated source code that takes the trick into consideration I would be very glad for it. Any language or platform is O.K. You can e-mail me at geek2823-businessrepresentative@yahoo.com

----------------------------------------------
2009-07-29 15:52:55
Here is a diff to include the trick:

19,24c19,24
< int layout[6][6] = {0, 4, 3, 1, 2, 5, /* the grid where we put the pieces is a 6x6 where each location allows */
< 1, 2, 5, 0, 4, 3, /* a single size piece. These are the sizes associated with the grid */
< 4, 5, 2, 3, 1, 0, /* locations. 0 means the smallest piece, while 5 is the largest piece */
< 3, 0, 4, 2, 5, 1,
< 5, 3, 1, 4, 0, 2,
< 2, 1, 0, 5, 3, 4};
---
> int layout[6][6] = {0, 4, 3, 1, 2, 5, /* the grid where we put the pieces is a 6x6 where each location allows */
> 1, 2, 5, 0, 4/* trick ong 5 */, 3, /* a single size piece. These are the sizes associated with the grid */
> 4, 5, 2, 3, 1, 0, /* locations. 0 means the smallest piece, while 5 is the largest piece */
> 3, 0, 4, 2, 5/* trick yel 4 */, 1,
> 5, 3, 1, 4, 0, 2,
> 2, 1, 0, 5, 3, 4};
50a51,54
> /* don't change the trick slots */
> if ((n == 10)

(n == 22))
> return (search(n+1,last));
>
59,62c63,66
< for (j=0; j < c; j++) if (board[r][j] == i) break;
< if (j < c) continue; /* if ith color already appears in row r, ith color impossible */
< for (j=0; j < r; j++) if (board[j][c] == i) break;
< if (j < r) continue; /* if ith color already appears in column c, ith color impossible */
---
> for (j=0; j < 6; j++) if (board[r][j] == i) break;
> if (j < 6) continue; /* if ith color already appears in row r, ith color impossible */
> for (j=0; j < 6; j++) if (board[j][c] == i) break;
> if (j < 6) continue; /* if ith color already appears in column c, ith color impossible */
75,76c79,82
<
< num = atoi(argv[1]); /* num is the number of positions in the grid we will solve for */
---
> if (argc == 2)
> num = atoi(argv[1]); /* num is the number of positions in the grid we will solve for */
> else
> num = 36;
80a87,92
> /* put in trick pieces */
> board[1][4] = 4; /* column 4, row 1 is orange */
> used[5][4] = 1; /* this place is for size 4, but orange 5 fits here */
> board[3][4] = 1; /* column 4, row 3 is yellow */
> used[4][1] = 1; /* this place is for size 5, but yellow 4 fits here */
>

I don't have the game and deduced the location of the trick pieces from other peoples web pages.

I played this game in a store today and was initially upset that there was no solution.

mike at estlick dot com

----------------------------------------------
2009-09-06 09:11:55
Hey there seem to be a problem withe code you posted:
num = atoi(argv[1]);

the atoi statement isn't working as the "atoi" is not defined

----------------------------------------------
2009-10-27 18:40:26
AaPSTs qbxywinwhukd, [url=http://zkfjlyyhrfco.com/]zkfjlyyhrfco[/url], [link=http://ivlosadduegx.com/]ivlosadduegx[/link], http://lboekivrgbzh.com/

----------------------------------------------
2009-10-27 18:40:28

----------------------------------------------
2009-10-29 11:05:04
hojotevemac, buy karelina sposa bridal dress online, 7536, whole saler sweet almond oil, >:[, bridesmaids dresses san diego christinas, dkl, black opal mask scrub, 767247, dress barn salisbury maryland, 090890,

----------------------------------------------
2009-10-29 11:05:07
linisbackpadsump, peasant dress patterns, 82007, roberts bridal dresses, oje, dress barn in chandler arizona, >:]], gilson mosaic black opal, 491,

----------------------------------------------
2009-10-29 11:28:47
comsoftnolino, off the shoulder dress patterns, pqruay, bridesmaids dresses parramatta, eofka, bridesmaids dresses pink and sage, 2121, cheep sage green bridesmaids dresses, fiptg, cattle drives of montana, uiy,

----------------------------------------------
2009-10-29 11:28:53
speedbotybuje, garage door openers goleta, :DD, eden bridal dresses 1517, 33226, yakima and bridal dress, 551491,

----------------------------------------------
2009-10-31 05:00:42
peotogeseru, Buy Zovirax, 88240, Buy Reglan, :-(,

----------------------------------------------
2009-11-05 05:14:19
скачать jimm

2010-01-17 12:53:13
Hi,

I Denis from France, and as I'm training in java for my work, I decided to attempt to solve the 36 cube puzzle too. I wrote a java program, which puts at first at the right place the 1 sized towers, then the 2 sized towers, aso. That gives an astronomic number of possibilities ( think 720^6), but at each step, my program examins then partially filled grid, and can exclude the majority of the wrong configurations very soon, without needing to construct them completely.
How long is the execution of your C program ? My java program, which is not truely compiled takes 10 minutes to give its result.
My program as yours, found no solution. I think 720 (= 6! = 6 x 5 x 4 x 3 x 2) is a key number in that problem, because I found by means of the same program, with a very light modification, 720 combinations at step 5 (the 1, 2 ,3 ,4, and 5 sized towers in a right place). But the 6th step seems impossible. I laught finding on the web a lot of people writing that they found a solution, I even found a photo of a solution, with 2 false towers to make it correct (http://www.passionforpuzzles.com/solution/solution-36-cube.php).
Like you I think this puzzle is impossible, and I wonder if people who organized a competition for solving the puzzle, and gave a list of winners, are very honest persons.

Best regards
Denis
denis.blion@wanadoo.fr

2010-01-17 16:38:57
The puzzle is a trick... except that one of the yellow pieces fits in two spaces. Once you figure out which one that is you can solve the puzzle.

2010-01-25 05:00:59
i solved the puzzle in about an hour (think fun 36), i stumbled across the trick while messing around with the blocks and is also proof that a computer cannot solve this puzzle because the program wont allow for trickery!!! the trick is that one of the 6 cube towers fits on a five cube stack and there for a five cubed tower fits on a 6 cube stack.once you have worked that out its pretty easy!

2010-01-25 05:02:06
ha ha ooopppss ive just relised that other people have already commented

2010-01-27 01:46:00
Damn it.

I wrote a program in python to solve this, and it didn't find a solution. Found this webpage to discover that my program likely doesn't have any logic bugs.

There are 46656 ways to place the towers without regard to height or legality. My first program found there are only 24 legal ways to place the six towers of one color. The arrays I've included are the height maps to place an individual color.

ones = [123564, 132465, 143652, 146325] -- choose a color, say, red.

twos = [213546, 245631, 251463, 264315] -- orange

threes = [312456, 345126, 356412, 365214] -- yellow

fours = [426531, 431526, 461253, 462135] -- green

fives = [512634, 516243, 524163, 534612] -- blue

sixes = [624351, 635241, 651324, 653142] -- purple

My second program attempts to place the towers, then place a second set of towers, then a third set, etc. The height maps of each placed set should sum to 2,333,331. The path that WOULD sum to that would tell you how to place each set of towers. 1+2+3+4+5+6 = 21, 21+210+2100+ etc = 2,333,331.
2,333,331 is significant because it shows that each tower height was used once, and exactly once.

No solution found.

# Cube36 Solutions Path Finder
# This program finds the available legal ways to place the towers.
# T. Haske
# Written 26 JAN 2010
# python2.5
# GPLv3

# COPY AND PASTE INTO THE INTERPRETER.
# HIT ENTER.

import math

def load_heights_into_array(row1, row2, row3, row4, row5, row6, position_list):
height_list = []
height_list.append(row1[position_list[0]])
height_list.append(row2[position_list[1]])
height_list.append(row3[position_list[2]])
height_list.append(row4[position_list[3]])
height_list.append(row5[position_list[4]])
height_list.append(row6[position_list[5]])
return height_list

def slice_to_list(x): # Takes a number like "1" and makes it into -> [0,0,0,0,0,0]
list_index = []
if x < 100000:
list_index.append(0)
else:
while(100000 <= x <= 999999):
a = 0
a = math.floor (x / 100000)
list_index.append(int(a))
x = x - (100000 * a)
if x < 10000:
list_index.append(0)
else:
while(10000 <= x <= 99999):
a = 0
a = math.floor (x / 10000)
list_index.append(int(a))
x = x - (10000 * a)
if x < 1000:
list_index.append(0)
else:
while(1000 <= x <= 9999):
a = 0
a = math.floor (x / 1000)
list_index.append(int(a))
x = x - (1000 * a)
if x < 100:
list_index.append(0)
else:
while(100 <= x <= 999):
a = 0
a = math.floor (x / 100)
list_index.append(int(a))
x = x - (100 * a)
if x < 10:
list_index.append(0)
else:
while(10 <= x <= 99):
a = 0
a = math.floor (x / 10)
list_index.append(int(a))
x = x - (10 * a)
list_index.append(int(x))
return list_index

def valid_heights(list): # checks to see if all heights are present.
score = 1
if 1 not in list:
score = 0
if 2 not in list:
score = 0
if 3 not in list:
score = 0
if 4 not in list:
score = 0
if 5 not in list:
score = 0
if 6 not in list:
score = 0
return score

def valid_position(list): #checks to see no numbers are repeated.
score = 1
if 0 not in list:
score = 0
if 1 not in list:
score = 0
if 2 not in list:
score = 0
if 3 not in list:
score = 0
if 4 not in list:
score = 0
if 5 not in list:
score = 0
return score

def convert_to_base_6(x): #the Cube36 uses a base 6 number system.
total = 0
while(7776 <= x < 46656):
a = 0
a = math.floor (x / 7776)
total = total + a * 100000
x = x - (7776 * a)
while(1296 <= x < 7776):
a = 0
a = math.floor ( x / 1296)
total = total + a * 10000
x = x - (1296 * a)
while (216 <= x < 1296):
a = 0
a = math.floor (x / 216)
total = total + a * 1000
x = x - (216 * a)
while (36 <= x < 216):
a = 0
a = math.floor (x / 36)
total = total + a * 100
x = x - (36 * a)
while(6 <= x < 36):
a = 0
a = math.floor (x / 6)
total = total + a * 10
x = x - (6 * a)
total = total + x
return int(total)

evaluation_10 = 0 #base 10 number
evaluation_6 = 0 #base 6 number
position_in_array = [] #list with six positional indexes.
values_for_array = [] #the height map

row1 = [1,2,5,4,6,3] #displacement of towers from the Cube36 puzzle.
row2 = [5,3,6,1,4,2] #These displacements will determine legal arraignments.
row3 = [4,6,3,5,2,1]
row4 = [2,1,4,3,5,6]
row5 = [3,5,2,6,1,4]
row6 = [6,4,1,2,3,5]

Print "Each Height is a possible legal move"

while evaluation_6 < 555555:
values_for_array[:] = []
evaluation_6 = convert_to_base_6(evaluation_10)
position_in_array = slice_to_list(evaluation_6)
#print position_in_array
if valid_position(position_in_array) == 1:
#print "valid position"
#print position_in_array
heights = load_heights_into_array(row1,row2,row3,row4,row5,row6,position_in_array)
if valid_heights(heights) == 1:
print "heights -->", heights, "Position in array", position_in_array
evaluation_10 = evaluation_10 + 1

print "Evaluations made", evaluation_10

---------------------------------------------
#Cube36 Solutions Finder
# 2nd program. Attempts to sum each path to the magic number 2,333,331
# T. Haske
# 27 JAN 2010
# GPLv3
# python2.5

#COPY AND PASTE INTO THE INTERPRETER.
#HIT ENTER.

import math

def slice_to_list(x): # Takes a number like "1" and makes it into -> [0,0,0,0,0,0]
list_index = []
if x < 100000:
list_index.append(0)
else:
while(100000 <= x <= 999999):
a = 0
a = math.floor (x / 100000)
list_index.append(int(a))
x = x - (100000 * a)
if x < 10000:
list_index.append(0)
else:
while(10000 <= x <= 99999):
a = 0
a = math.floor (x / 10000)
list_index.append(int(a))
x = x - (10000 * a)
if x < 1000:
list_index.append(0)
else:
while(1000 <= x <= 9999):
a = 0
a = math.floor (x / 1000)
list_index.append(int(a))
x = x - (1000 * a)
if x < 100:
list_index.append(0)
else:
while(100 <= x <= 999):
a = 0
a = math.floor (x / 100)
list_index.append(int(a))
x = x - (100 * a)
if x < 10:
list_index.append(0)
else:
while(10 <= x <= 99):
a = 0
a = math.floor (x / 10)
list_index.append(int(a))
x = x - (10 * a)
list_index.append(int(x))
return list_index

def convert_to_base_4(x):
total = 0
while(1024 <= x < 4096):
a = 0
a = math.floor (x / 1024)
total = total + a * 100000
x = x - (1024 * a)
while(256 <= x < 1024):
a = 0
a = math.floor ( x / 256)
total = total + a * 10000
x = x - (256 * a)
while (64 <= x < 256):
a = 0
a = math.floor (x / 64)
total = total + a * 1000
x = x - (64 * a)
while (16 <= x < 64):
a = 0
a = math.floor (x / 16)
total = total + a * 100
x = x - (16 * a)
while(4 <= x < 16):
a = 0
a = math.floor (x / 4)
total = total + a * 10
x = x - (4 * a)
total = total + x
return int(total)


# These are the legal moves given by the first program.

ones = [123564, 132465, 143652, 146325]

twos = [213546, 245631, 251463, 264315]

threes = [312456, 345126, 356412, 365214]

fours = [426531, 431526, 461253, 462135]

fives = [512634, 516243, 524163, 534612]

sixes = [624351, 635241, 651324, 653142]

evaluation_10 = 0
evaluation_4 = 0
sum = 0

while evaluation_4 < 333333:
sum = 0
evaluation_4 = convert_to_base_4(evaluation_10)
position_in_array = slice_to_list(evaluation_4)
sum = ones[position_in_array[0]] + twos[position_in_array[1]] + threes[position_in_array[2]] + fours[position_in_array[3]] + fives[position_in_array[4]] + sixes[position_in_array[5]]
if ( 2333000 < sum < 2334000):
print "Sum -->", sum, "Array Location", position_in_array
#print ones[position_in_array[0]], twos[position_in_array[1]], threes[position_in_array[2]], fours[position_in_array[3]], fives[position_in_array[4]], sixes[position_in_array[5]]
evaluation_10 = evaluation_10 + 1

print "Evaluations made", evaluation_10

print "Look 2,333,331. It isn't there, because there is no solution. This output is more exciting :)"