Create app.py

app.py

@@ -0,0 +1,151 @@
+import numpy as np
+
+class RubiksCube:
+    def __init__(self):
+        """
+        Inicializa um cubo mágico resolvido.
+        Faces são numeradas de 0-5:
+        0: Branco (topo)
+        1: Amarelo (base)
+        2: Verde (frente)
+        3: Azul (traseira)
+        4: Vermelho (direita)
+        5: Laranja (esquerda)
+        """
+        # Criar um cubo 3x3x3 com cores padrão
+        self.cube = np.zeros((6, 3, 3), dtype=int)
+        for i in range(6):
+            self.cube[i] = np.full((3, 3), i)
+        
+        self.color_names = {
+            0: "Branco",
+            1: "Amarelo",
+            2: "Verde",
+            3: "Azul",
+            4: "Vermelho",
+            5: "Laranja"
+        }
+    
+    def get_face(self, face_num):
+        """Retorna uma face específica do cubo."""
+        if 0 <= face_num < 6:
+            return self.cube[face_num].copy()
+        raise ValueError("Número de face inválido")
+    
+    def set_face(self, face_num, new_state):
+        """Define o estado de uma face específica."""
+        if 0 <= face_num < 6 and new_state.shape == (3, 3):
+            self.cube[face_num] = new_state.copy()
+        else:
+            raise ValueError("Face inválida ou dimensões incorretas")
+    
+    def rotate_face_clockwise(self, face_num):
+        """Rotaciona uma face no sentido horário."""
+        if 0 <= face_num < 6:
+            self.cube[face_num] = np.rot90(self.cube[face_num], k=-1)
+            self._update_adjacent_faces(face_num, clockwise=True)
+        else:
+            raise ValueError("Número de face inválido")
+    
+    def rotate_face_counterclockwise(self, face_num):
+        """Rotaciona uma face no sentido anti-horário."""
+        if 0 <= face_num < 6:
+            self.cube[face_num] = np.rot90(self.cube[face_num], k=1)
+            self._update_adjacent_faces(face_num, clockwise=False)
+        else:
+            raise ValueError("Número de face inválido")
+    
+    def _update_adjacent_faces(self, face_num, clockwise=True):
+        """Atualiza as faces adjacentes após uma rotação."""
+        # Definição das faces adjacentes e suas bordas afetadas para cada face
+        adjacent_faces = {
+            0: [(2,0), (4,0), (3,0), (5,0)],  # Topo
+            1: [(2,2), (5,2), (3,2), (4,2)],  # Base
+            2: [(0,2), (4,3), (1,0), (5,1)],  # Frente
+            3: [(0,0), (5,3), (1,2), (4,1)],  # Traseira
+            4: [(0,1), (2,1), (1,1), (3,3)],  # Direita
+            5: [(0,3), (3,1), (1,3), (2,3)]   # Esquerda
+        }
+        
+        # Obter as faces e bordas afetadas
+        affected = adjacent_faces[face_num]
+        temp_values = []
+        
+        # Guardar valores temporários
+        for face, edge in affected:
+            if edge == 0:
+                temp_values.append(self.cube[face][0].copy())
+            elif edge == 1:
+                temp_values.append(self.cube[face][:,2].copy())
+            elif edge == 2:
+                temp_values.append(self.cube[face][2].copy())
+            else:  # edge == 3
+                temp_values.append(self.cube[face][:,0].copy())
+        
+        # Rotacionar valores
+        if clockwise:
+            temp_values = [temp_values[-1]] + temp_values[:-1]
+        else:
+            temp_values = temp_values[1:] + [temp_values[0]]
+        
+        # Atualizar faces
+        for (face, edge), new_values in zip(affected, temp_values):
+            if edge == 0:
+                self.cube[face][0] = new_values
+            elif edge == 1:
+                self.cube[face][:,2] = new_values
+            elif edge == 2:
+                self.cube[face][2] = new_values
+            else:  # edge == 3
+                self.cube[face][:,0] = new_values
+    
+    def is_solved(self):
+        """Verifica se o cubo está resolvido."""
+        for face in range(6):
+            if not np.all(self.cube[face] == face):
+                return False
+        return True
+    
+    def scramble(self, num_moves=20):
+        """Embaralha o cubo com um número específico de movimentos aleatórios."""
+        import random
+        moves = []
+        for _ in range(num_moves):
+            face = random.randint(0, 5)
+            direction = random.choice([True, False])
+            if direction:
+                self.rotate_face_clockwise(face)
+                moves.append(f"Rotação horária da face {self.color_names[face]}")
+            else:
+                self.rotate_face_counterclockwise(face)
+                moves.append(f"Rotação anti-horária da face {self.color_names[face]}")
+        return moves
+    
+    def get_state_str(self):
+        """Retorna uma representação string do estado atual do cubo."""
+        state = []
+        for face in range(6):
+            face_str = f"Face {self.color_names[face]}:\n"
+            face_str += str(self.cube[face])
+            state.append(face_str)
+        return "\n\n".join(state)
+
+# Exemplo de uso
+if __name__ == "__main__":
+    # Criar um novo cubo
+    cube = RubiksCube()
+    
+    print("Estado inicial do cubo:")
+    print(cube.get_state_str())
+    
+    # Embaralhar o cubo
+    moves = cube.scramble(5)
+    print("\nMovimentos realizados:")
+    for move in moves:
+        print(move)
+    
+    print("\nEstado após embaralhar:")
+    print(cube.get_state_str())
+    
+    # Verificar se está resolvido
+    print("\nCubo está resolvido?", cube.is_solved())