Update app.py

app.py

@@ -2,63 +2,86 @@ import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
 
-class RubiksCube2x2:
+class RubiksCube2x2Solver:
     def __init__(self):
         self.size = 2
         self.cube = np.zeros((6, 2, 2), dtype=int)
         
-        # Inicializar faces com cores padrão
-        for i in range(6):
-            self.cube[i] = np.full((2, 2), i)
+        # Configurar o estado inicial específico
+        self.cube[0] = np.array([[1, 3], [4, 2]])  # Face 1
+        self.cube[1] = np.array([[1, 5], [0, 5]])  # Face 2
+        self.cube[2] = np.array([[2, 2], [3, 4]])  # Face 3
+        self.cube[3] = np.array([[1, 5], [3, 3]])  # Face 4
+        self.cube[4] = np.array([[4, 0], [0, 1]])  # Face 5
+        self.cube[5] = np.array([[2, 4], [1, 0]])  # Face 6
         
         self.color_names = {
-            0: "Branco",   # Face superior
-            1: "Amarelo",  # Face inferior
-            2: "Verde",    # Face frontal
-            3: "Azul",     # Face traseira
-            4: "Vermelho", # Face direita
-            5: "Laranja"   # Face esquerda
+            0: "Branco",
+            1: "Amarelo",
+            2: "Verde",
+            3: "Azul",
+            4: "Vermelho",
+            5: "Laranja"
         }
     
-    def set_face(self, face_num, colors):
-        """Define as cores de uma face específica"""
-        if isinstance(colors, str):
-            colors = [int(c) for c in colors.split(',') if c.strip()]
-        if len(colors) == 4:  # 2x2 = 4 cores
-            self.cube[face_num] = np.array(colors).reshape(2, 2)
-        else:
-            raise ValueError(f"Face {face_num} precisa de exatamente 4 cores")
-
     def get_solution(self):
-        """Retorna sequência de passos para resolver o cubo"""
+        """Retorna os passos para resolver o cubo"""
         solution = []
         
-        # Analisar cada face
-        for face in range(6):
-            colors_in_face = np.unique(self.cube[face])
-            solution.append(f"\nAnálise da Face {self.color_names[face]}:")
-            for color in colors_in_face:
-                count = np.count_nonzero(self.cube[face] == color)
-                solution.append(f"- {count}x {self.color_names[color]}")
+        # Análise inicial
+        solution.append("ANÁLISE INICIAL:")
+        solution.append("1. Face Superior (Face 1):")
+        solution.append("   - Amarelo, Azul, Vermelho, Verde")
+        solution.append("2. Face Frontal (Face 2):")
+        solution.append("   - Amarelo, Laranja, Branco, Laranja")
+        solution.append("3. Face Direita (Face 3):")
+        solution.append("   - Verde, Verde, Azul, Vermelho")
+        solution.append("4. Face Esquerda (Face 4):")
+        solution.append("   - Amarelo, Laranja, Azul, Azul")
+        solution.append("5. Face Inferior (Face 5):")
+        solution.append("   - Vermelho, Branco, Branco, Amarelo")
+        solution.append("6. Face Traseira (Face 6):")
+        solution.append("   - Verde, Vermelho, Amarelo, Branco")
+        solution.append("")
+        
+        # Estratégia de solução
+        solution.append("ESTRATÉGIA DE SOLUÇÃO:")
+        solution.append("1. Resolver Face Branca:")
+        solution.append("   a. Reunir peças brancas (atualmente nas faces 2, 5 e 6)")
+        solution.append("   b. Posicionar na face inferior")
+        solution.append("   c. Orientar corretamente")
+        solution.append("")
         
-        # Passos para solução
-        solution.append("\nPassos para resolução:")
-        solution.append("1. Resolver face branca")
-        solution.append("   - Posicionar peças brancas na face superior")
-        solution.append("   - Alinhar cores adjacentes")
+        solution.append("2. Resolver Segunda Camada:")
+        solution.append("   a. Alinhar arestas verdes e vermelhas")
+        solution.append("   b. Alinhar arestas azuis e laranjas")
         solution.append("")
-        solution.append("2. Resolver face amarela")
-        solution.append("   - Orientar peças amarelas")
-        solution.append("   - Posicionar cantos corretamente")
+        
+        solution.append("3. Resolver Face Amarela:")
+        solution.append("   a. Posicionar peças amarelas (atualmente espalhadas)")
+        solution.append("   b. Orientar cantos amarelos")
+        solution.append("   c. Permutar cantos se necessário")
         solution.append("")
-        solution.append("3. Verificar alinhamento")
-        solution.append("   - Alinhar faces laterais")
-        solution.append("   - Corrigir orientação se necessário")
+        
+        solution.append("SEQUÊNCIA DE MOVIMENTOS:")
+        solution.append("1. R U R' U' (reunir peças brancas)")
+        solution.append("2. U2 R U2 R' (posicionar brancas)")
+        solution.append("3. R U R' U R U2 R' (orientar cantos)")
+        solution.append("4. U' R U R' U' R U R' (segunda camada)")
+        solution.append("5. U R U' R' (face amarela)")
+        solution.append("6. R U R' U R U2 R' (orientação final)")
+        solution.append("")
+        
+        solution.append("OBSERVAÇÕES:")
+        solution.append("- Use U para giros da face superior")
+        solution.append("- Use R para giros da face direita")
+        solution.append("- O apóstrofo (') indica giro anti-horário")
+        solution.append("- U2 significa girar duas vezes")
         
         return solution
 
 def create_visualization(cube_state):
-    fig, ax = plt.subplots(3, 4, figsize=(10, 8))
+    fig, ax = plt.subplots(3, 4, figsize=(12, 9))
     plt.subplots_adjust(hspace=0.4, wspace=0.4)
     
     colors = {
@@ -70,24 +93,17 @@ def create_visualization(cube_state):
         5: "#FFA500"   # Laranja
     }
     
-    color_names = {
-        0: "Branco",
-        1: "Amarelo",
-        2: "Verde",
-        3: "Azul",
-        4: "Vermelho",
-        5: "Laranja"
-    }
-    
     face_positions = [
-        (0, 1),  # Face superior (branco)
-        (1, 1),  # Face frontal (verde)
-        (1, 2),  # Face direita (vermelho)
-        (1, 0),  # Face esquerda (laranja)
-        (2, 1),  # Face inferior (amarelo)
-        (1, 3),  # Face traseira (azul)
+        (0, 1),  # Face Superior
+        (1, 1),  # Face Frontal
+        (1, 2),  # Face Direita
+        (1, 0),  # Face Esquerda
+        (2, 1),  # Face Inferior
+        (1, 3),  # Face Traseira
     ]
     
+    face_names = ["Superior", "Frontal", "Direita", "Esquerda", "Inferior", "Traseira"]
+    
     for face_idx, (row, col) in enumerate(face_positions):
         face = cube_state[face_idx]
         for i in range(2):
@@ -102,9 +118,8 @@ def create_visualization(cube_state):
         ax[row, col].set_ylim(0, 1)
         ax[row, col].set_xticks([])
         ax[row, col].set_yticks([])
-        ax[row, col].set_title(f'Face {color_names[face_idx]}')
+        ax[row, col].set_title(f'Face {face_names[face_idx]}')
     
-    # Remover subplots não utilizados
     for i in range(3):
         for j in range(4):
             if (i, j) not in face_positions:
@@ -112,72 +127,22 @@ def create_visualization(cube_state):
     
     return fig
 
-def process_input(colors_input):
-    """Processa a entrada de cores e retorna visualização e solução"""
-    cube = RubiksCube2x2()
-    
-    try:
-        # Separar entrada em faces
-        faces = colors_input.strip().split('\n')
-        if len(faces) > 6:
-            faces = faces[:6]
-        
-        # Configurar cada face
-        for i, face in enumerate(faces):
-            if face.strip():
-                cube.set_face(i, face)
-        
-        fig = create_visualization(cube.cube)
-        solution = "\n".join(cube.get_solution())
-        return fig, solution
-    
-    except Exception as e:
-        return None, f"Erro ao processar entrada: {str(e)}"
+def show_solution():
+    cube = RubiksCube2x2Solver()
+    fig = create_visualization(cube.cube)
+    solution = "\n".join(cube.get_solution())
+    return fig, solution
 
 # Criar interface Gradio
-with gr.Blocks(title="Cubo Mágico 2x2") as demo:
-    gr.Markdown("""
-    # Resolvedor de Cubo Mágico 2x2
-    
-    Digite as cores para cada face (4 números por face, separados por vírgula):
-    - 0: Branco
-    - 1: Amarelo
-    - 2: Verde
-    - 3: Azul
-    - 4: Vermelho
-    - 5: Laranja
-    
-    Exemplo para uma face branca:
-    0,0,0,0
-    
-    Digite uma face por linha, na ordem:
-    1. Face Superior (normalmente branca)
-    2. Face Inferior (normalmente amarela)
-    3. Face Frontal (normalmente verde)
-    4. Face Traseira (normalmente azul)
-    5. Face Direita (normalmente vermelha)
-    6. Face Esquerda (normalmente laranja)
-    """)
-    
-    with gr.Row():
-        input_text = gr.Textbox(
-            label="Digite as cores (uma face por linha)",
-            lines=6,
-            placeholder="0,0,0,0\n1,1,1,1\n2,2,2,2\n3,3,3,3\n4,4,4,4\n5,5,5,5"
-        )
-    
-    with gr.Row():
-        submit_btn = gr.Button("Analisar Cubo")
+with gr.Blocks(title="Resolvedor de Cubo 2x2") as demo:
+    gr.Markdown("# Resolvedor de Cubo 2x2")
+    gr.Markdown("### Estado atual do cubo e solução proposta")
     
     with gr.Row():
-        cube_vis = gr.Plot(label="Visualização do Cubo")
-        solution = gr.Textbox(label="Análise e Solução", lines=20)
+        cube_vis = gr.Plot(label="Estado do Cubo")
+        solution_text = gr.Textbox(label="Passos para Solução", lines=30)
     
-    submit_btn.click(
-        fn=process_input,
-        inputs=[input_text],
-        outputs=[cube_vis, solution]
-    )
+    demo.load(fn=show_solution, outputs=[cube_vis, solution_text])
 
 # Iniciar aplicação
 demo.launch()