a使用javascript訪問堆棧立方體的問題

Question

您有四個彩色立方體。每個立方體的每一面都是單一顏色，並且有四種顏色：藍色（B），紅色（R），綠色（G）和黃色（Y）。描述六個面分別爲前，後，左，右，底部，立方體顏色有：

目的是想辦法堆疊四個立方體爲垂直柱，以使柱的每一側是顯示所有四種顏色。

我能做些什麼，

感謝

PS：

function init(){ 
    var a = [['R','B'],['G','Y'],['B','Y']], 
     b = [['R','G'],['G','Y'],['B','B']], 
     c = [['Y','B'],['R','G'],['Y','R']], 
     d = [['Y','G'],['B','R'],['R','R']] 
    var box = [a,b,c,d] 
    return box; 
} 

Answer 1

搜尋所有可能的狀態：有沒有那麼多（每立方24轉，其中大部分可以過濾出）。僞代碼：

for cubeLevel0 in rotations(cubes[0]): 
    var sidesMatch = function(cube) { 
     return cube.N==cubeLevel0.N and cube.S==cubeLevel0.S and ... 
    } 
    for cubeLevel1 in rotations(cube[1]).filter(sidesMatch): 
     for cubeLevel2 in rotations(cube[2]).filter(sidesMatch): 
      for cubeLevel3 in rotations(cube[3]).filter(sidesMatch): 
       console.log(cubeLevel0, cubeLevel1, cubeLevel2, cubeLevel3) 

嵌套的for循環是醜陋的，你可以通過實現這是一個遞歸函數刪除它們。爲了清晰，我以這種方式離開了它。

要實現rotations(cube)函數，您有幾個選項。最簡單的方法是在你面前取一個物理立方體，並以任意順序標記每一邊{0,1,2,3,4,5}。然後物理執行24次旋轉中的一次，記下排列順序，然後撤消旋轉，以便返回到開始位置。然後寫功能就像這樣：

// You HAVE to manually discover these with the physical method described above 
var rotationPermutations = [[0,1,2,3,4,5,6], [3,4,2,1,5,0], ...(24 of these)...]; 

function rotations(cube) { // representing a cube as a 6-tuple 
    return rotationPermutations.map(function(permutation) { 
     // return [cube[i] for i in permutation] 
     return permutation.map(function(x){return cube[x]}) 
    });  
} 

你可以的事情更聰明，如果你能想出一個辦法來檢測時，置換是無效的;那麼你可以產生所有48個軸的排列（使用[[axis0top, axis0bottom], [axis1top, axis1bottom], [axis2top, axis2bottom]]表示法，通過排列軸3！方法，並且翻轉每個軸2種方式，所以2^3 = 8個翻轉可能性，3！* 2^3 = 48）和用錯誤的手性過濾掉其中的一半。然而，考慮到這一點將花費比使用上述手動方法記錄排列更長的時間。

Answer 2

Array.prototype.in_array = function(e) { 
    for (i = 0; i < this.length; i++) { 
     if (this[i] == e) return true; 
    } 
    return false; 
} 
Array.prototype.clone = function() { 
    return this.slice(); 
} 

function deepcopy(obj) { 
    var out = [],i = 0,len = obj.length; 
    for (; i < len; i++) { 
     if (obj[i] instanceof Array){ 
      out[i] = deepcopy(obj[i]); 
     } 
     else out[i] = obj[i]; 
    } 
    return out; 
} 

function Cube (id, front, back, left, right, top, bottom) { 
    var self = this; 
    self.id=id; 
    self.front = front; 
    self.back = back; 
    self.left = left; 
    self.right = right; 
    self.top = top; 
    self.bottom = bottom; 
    self.turnMethod1 = function(){//left-front-right-back 
     var tmp=self.left; 
     self.left=self.front; 
     self.front=self.right; 
     self.right=self.back; 
     self.back=tmp; 
    } 
    self.turnMethod2 = function(){//left-top-right-bottom 
     var tmp=self.left; 
     self.left=self.top; 
     self.top=self.right; 
     self.right=self.bottom; 
     self.bottom=tmp; 
    } 
    self.turnMethod3 = function(){//front-top-back-bottom 
     var tmp=self.front; 
     self.front=self.top; 
     self.top=self.back; 
     self.back=self.bottom; 
     self.bottom=tmp; 
    } 

    self.fn = [ 
     self.turnMethod1,self.turnMethod2,self.turnMethod3 
    ] 

} 

Cube.prototype.toString = function(){ 
    return this.id+"\t"+this.front+"\t"+this.back+"\t"+this.left+"\t"+this.right+"\t"+this.top+"\t"+this.bottom+"\n"; 
} 


var cube1=new Cube(1,"R","B","G","Y","B","Y"); 
var cube2=new Cube(2,"R","G","G","Y","B","B"); 
var cube3=new Cube(3,"Y","B","R","G","Y","R"); 
var cube4=new Cube(4,"Y","G","B","R","R","R"); 

function count() { 
    for (var i = 0; i < 3; i++) { 
     for (var n = 0; n < 4; n++) { 
      cube1.fn[i]() 
      for (var a = 0; a < 3; a++) { 
       for (var b = 0; b < 4; b++) { 
        cube2.fn[a]() 
        for (var c = 0; c < 3; c++) { 
         for (var d = 0; d < 4; d++) { 
          cube3.fn[c]() 
          for (var e = 0; e < 3; e++) { 
           for (var f = 0; f < 4; f++) { 
            if(done()){ 
             printPermutation(); 
            } 
            cube4.fn[e]() 
           }; 

          }; 

         }; 

        }; 
       }; 

      }; 
     }; 

    }; 
} 

function done() { 
    var arr = []; /*front validation*/ 
    arr.push(cube1.front); 
    if (arr.in_array(cube2.front)) { 
     return false; 
    } else { 
     arr.push(cube2.front); 
    } 

    if (arr.in_array(cube3.front)) { 
     return false; 
    } else { 
     arr.push(cube3.front); 
    } 
    if (arr.in_array(cube4.front)) { 
     return false; 
    } else { 
     arr.push(cube4.front); 
    } /*back validation*/ 
    var arr = []; 
    arr.push(cube1.back); 
    if (arr.in_array(cube2.back)) { 
     return false; 
    } else { 
     arr.push(cube2.back); 
    } 
    if (arr.in_array(cube3.back)) { 
     return false; 
    } else { 
     arr.push(cube3.back); 
    } 

    if (arr.in_array(cube4.back)) { 
     return false; 
    } else { 
     arr.push(cube4.back); 
    } 
    /*left validation*/ 
    var arr = []; 
    arr.push(cube1.left); 
    if (arr.in_array(cube2.left)) { 
     return false; 
    } else { 
     arr.push(cube2.left); 
    } 
    if (arr.in_array(cube3.left)) { 
     return false; 
    } else { 
     arr.push(cube3.left); 
    } 
    if (arr.in_array(cube4.left)) { 
     return false; 
    } else { 
     arr.push(cube4.left); 
    } /*right validation*/ 
    var arr = []; 
    arr.push(cube1.right); 
    if (arr.in_array(cube2.right)) { 
     return false; 
    } else { 
     arr.push(cube2.right); 
    } 
    if (arr.in_array(cube3.right)) { 
     return false; 
    } else { 
     arr.push(cube3.right); 
    } 
    if (arr.in_array(cube4.right)) { 
     return false; 
    } else { 
     arr.push(cube4.right); 
    } 

    return true; 
} 

function printPermutation(){ 
     console.log("----------------------------"); 
     var arr = [] 
     arr.push("Cube\tFront\tBack\tLeft\tRight\tTop\tBottom\n"); 
     arr.push(cube1.toString()); 
     arr.push(cube2.toString()); 
     arr.push(cube3.toString()); 
     arr.push(cube4.toString()); 
     console.log(arr.join("")) 
} 


function main(){ 
    count() 
} 

main()