Update app.py

app.py

@@ -3,22 +3,23 @@ import requests
 import io
 import itertools
 from collections import defaultdict
-import gradio as gr # Importação principal para Gradio
-import os # Para variáveis de ambiente, se necessário
+import gradio as gr
+import time
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import heapq
 
 # 🔧 CONFIGURAÇÕES GLOBAIS
-# O ID da planilha para Consórcio de Automóveis
-# Certifique-se de que este FILE_ID esteja acessível publicamente ou para "Qualquer pessoa com o link"
 FILE_ID = "1EoH8V3Fyls0mNa95VcBN6ZL1B552ty3X"
 URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
 
 # Variável global para armazenar o DataFrame
 df = None
-
+df_filtrado_auto = None
 
 def carregar_planilha():
     """Carrega e prepara a planilha para análise de consórcios de automóveis."""
-    global df
+    global df, df_filtrado_auto
     try:
         print("⏳ Carregando planilha...")
         response = requests.get(URL)
@@ -33,7 +34,6 @@ def carregar_planilha():
         if 'administradora' in df.columns:
             df['administradora'] = df['administradora'].astype(str).str.strip().str.lower()
 
-
         # Converte colunas numéricas
         numeric_cols = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
         for col in numeric_cols:
@@ -46,33 +46,127 @@ def carregar_planilha():
 
         # Remove duplicatas
         df.drop_duplicates(inplace=True)
+        
+        # Pré-filtra dados de automóveis para otimização
+        df_filtrado_auto = df[df['tipo_do_bem'].str.lower() == 'auto'].copy()
+        
+        # Pré-calcula valores importantes
+        df_filtrado_auto['entrada_com_comissao'] = df_filtrado_auto['valor_entrada'] + (df_filtrado_auto['valor_credito'] * 0.085)
+        
         print("✅ Planilha carregada com sucesso!")
         return True
 
     except Exception as e:
         print(f"❌ Erro ao carregar planilha: {str(e)}")
-        # Retorne uma mensagem de erro mais útil para o usuário
         return False
 
-def agrupar_por_administradora(dataframe):
-    """Agrupa cotas por administradora."""
+def agrupar_por_administradora_otimizado(dataframe, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max):
+    """Agrupa cotas por administradora com pré-filtro otimizado."""
     grupos = defaultdict(list)
+    
+    # Pré-filtra as cotas que estão dentro das faixas individuais
     for _, row in dataframe.iterrows():
-        grupos[row['administradora']].append(row.to_dict())
+        credito = row['valor_credito']
+        entrada = row['entrada_com_comissao']
+        parcela = row['valor_parcela']
+        
+        # Verifica se a cota individual está dentro das faixas aceitáveis
+        if (credito_min * 0.1 <= credito <= credito_max * 2.0 and
+            entrada_min * 0.1 <= entrada <= entrada_max * 2.0 and
+            parcela_min * 0.1 <= parcela <= parcela_max * 3.0):
+            
+            grupos[row['administradora']].append(row.to_dict())
+    
     return grupos
 
-def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
-    """Busca combinações de cotas para automóveis dentro dos parâmetros especificados."""
-    global df
-    if df is None:
+def encontrar_combinacoes_otimizado(cotas, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max, max_combinacoes=1000):
+    """Encontra combinações de forma otimizada usando poda de busca."""
+    resultados = []
+    n = len(cotas)
+    
+    # Ordena as cotas por valor de crédito para poda mais eficiente
+    cotas_ordenadas = sorted(cotas, key=lambda x: x['valor_credito'])
+    
+    # Função recursiva com poda
+    def backtrack(start, combinacao_atual, credito_total, entrada_total, parcela_total):
+        # Poda: se já ultrapassou os limites máximos, não continua
+        if credito_total > credito_max * 1.1 or entrada_total > entrada_max * 1.1 or parcela_total > parcela_max * 1.5:
+            return
+            
+        # Se está dentro dos limites, adiciona ao resultado
+        if (credito_min <= credito_total <= credito_max and
+            entrada_min <= entrada_total <= entrada_max and
+            parcela_min <= parcela_total <= parcela_max):
+            
+            # Calcula a diferença para ordenação
+            saldo_total = sum(c['saldo_devedor'] for c in combinacao_atual)
+            valor_final = entrada_total + saldo_total
+            diferenca = abs(valor_final - credito_total)
+            
+            # Usa heap para manter apenas as melhores combinações
+            if len(resultados) < max_combinacoes:
+                heapq.heappush(resultados, (-diferenca, combinacao_atual[:]))
+            else:
+                # Substitui a pior combinação se esta for melhor
+                heapq.heappushpop(resultados, (-diferenca, combinacao_atual[:]))
+        
+        # Limita o tamanho das combinações e continua a busca
+        if len(combinacao_atual) < 10 and start < n:
+            for i in range(start, n):
+                cota = cotas_ordenadas[i]
+                novo_credito = credito_total + cota['valor_credito']
+                nova_entrada = entrada_total + cota['entrada_com_comissao']
+                nova_parcela = parcela_total + cota['valor_parcela']
+                
+                # Poda: se já ultrapassou muito os limites, não continua
+                if novo_credito > credito_max * 1.5 or nova_entrada > entrada_max * 1.5:
+                    continue
+                    
+                combinacao_atual.append(cota)
+                backtrack(i + 1, combinacao_atual, novo_credito, nova_entrada, nova_parcela)
+                combinacao_atual.pop()
+    
+    # Inicia a busca
+    backtrack(0, [], 0, 0, 0)
+    
+    # Converte o heap para lista ordenada
+    resultados_ordenados = []
+    while resultados:
+        diferenca, combinacao = heapq.heappop(resultados)
+        resultados_ordenados.append((combinacao, -diferenca))
+    
+    return resultados_ordenados
+
+def processar_administradora_10_cotas(args):
+    """Processa uma administradora para combinações de até 10 cotas."""
+    adm, cotas, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max = args
+    resultados_adm = []
+    
+    # Limita para as 20 melhores cotas por administradora
+    cotas_limitadas = cotas[:20]
+    
+    # Encontra combinações de forma otimizada
+    combinacoes = encontrar_combinacoes_otimizado(
+        cotas_limitadas, credito_min, credito_max, entrada_min, entrada_max, 
+        parcela_min, parcela_max, max_combinacoes=100
+    )
+    
+    for combinacao, diferenca in combinacoes:
+        resultados_adm.append((adm, combinacao, diferenca))
+    
+    return resultados_adm
+
+def buscar_combinacoes_10_cotas(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
+    """Busca combinações de até 10 cotas de forma otimizada."""
+    global df_filtrado_auto
+    
+    if df_filtrado_auto is None:
         if not carregar_planilha():
             return "❌ Erro: Planilha não carregada. Verifique se o ID do arquivo está correto e público."
 
-    # Filtra por tipo de bem (Auto) e administradoras selecionadas
-    df_filtrado = df[df['tipo_do_bem'].str.lower() == 'auto']
+    # Filtra por administradoras selecionadas
+    df_filtrado = df_filtrado_auto.copy()
     if administradoras:
-        if isinstance(administradoras, tuple):
-            administradoras = list(administradoras)
         administradoras = [a.strip().lower() for a in administradoras]
         df_filtrado = df_filtrado[df_filtrado['administradora'].isin(administradoras)]
 
@@ -84,34 +178,48 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
     entrada_min, entrada_max = entrada_desejada * 0.93, entrada_desejada * 1.07
     parcela_min, parcela_max = parcela_desejada * 0.5, parcela_desejada * 1.5
 
-    grupos = agrupar_por_administradora(df_filtrado)
+    # Agrupa com pré-filtro otimizado
+    grupos = agrupar_por_administradora_otimizado(
+        df_filtrado, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max
+    )
+    
+    # Prepara argumentos para processamento paralelo
+    args_list = []
+    for adm, cotas in grupos.items():
+        if cotas:  # Só processa administradoras com cotas
+            args_list.append((adm, cotas, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max))
+    
     resultados = []
-    MAX_COMBINACOES_POR_ADM = 1000  # Limite para evitar processamento excessivo
+    
+    # Processa em paralelo
+    if args_list:
+        with ThreadPoolExecutor(max_workers=min(4, len(args_list))) as executor:
+            futures = [executor.submit(processar_administradora_10_cotas, args) for args in args_list]
+            for future in as_completed(futures):
+                resultados.extend(future.result())
 
-    for adm, cotas in grupos.items():
-        cotas = cotas[:20]  # Limita a 20 cotas por administradora para evitar combinações explosivas
-        combinacoes_validas = 0
+    if not resultados:
+        # Tenta com faixas mais amplas se não encontrou resultados
+        credito_min, credito_max = credito_desejado * 0.90, credito_desejado * 1.10
+        entrada_min, entrada_max = entrada_desejada * 0.90, entrada_desejada * 1.10
         
-        for r in range(1, min(5, len(cotas)) + 1):  # Agora até 5 cotas
-            for combinacao in itertools.combinations(cotas, r):
-                if combinacoes_validas >= MAX_COMBINACOES_POR_ADM:
-                    break
-                    
-                total_credito = sum(c['valor_credito'] for c in combinacao)
-                total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
-                total_entrada = total_entrada_base + (total_credito * 0.085)
-                total_parcelas = sum(c['valor_parcela'] for c in combinacao)
-
-                if (credito_min <= total_credito <= credito_max and
-                    entrada_min <= total_entrada <= entrada_max and
-                    parcela_min <= total_parcelas <= parcela_max):
-
-                    total_saldo = sum(c['saldo_devedor'] for c in combinacao)
-                    valor_final = round(total_entrada + total_saldo, 2)
-                    diferenca = abs(valor_final - total_credito)
-
-                    resultados.append((adm, combinacao, diferenca))
-                    combinacoes_validas += 1
+        grupos = agrupar_por_administradora_otimizado(
+            df_filtrado, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max
+        )
+        
+        for adm, cotas in grupos.items():
+            if not cotas:
+                continue
+                
+            cotas = cotas[:20]  # Limita a 20 cotas por administradora
+            
+            combinacoes = encontrar_combinacoes_otimizado(
+                cotas, credito_min, credito_max, entrada_min, entrada_max, 
+                parcela_min, parcela_max, max_combinacoes=50
+            )
+            
+            for combinacao, diferenca in combinacoes:
+                resultados.append((adm, combinacao, diferenca))
 
     if not resultados:
         return "Nenhuma combinação adequada encontrada para automóveis com os parâmetros fornecidos."
@@ -119,73 +227,44 @@ def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, adm
     # Ordena por diferença (melhores combinações primeiro)
     resultados.sort(key=lambda x: x[2])
     
-    # Limita o número total de resultados para evitar sobrecarga
-    resultados = resultados[:500]
+    # Limita o número total de resultados
+    resultados = resultados[:200]
     
-    return formatar_resultados(resultados)
+    return formatar_resultados_10_cotas(resultados)
 
 def formatar_moeda(valor):
     return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
 
-def formatar_resultados(resultados):
+def formatar_resultados_10_cotas(resultados):
     """Formata os resultados para exibição."""
-    resposta = ""
+    if not resultados:
+        return "Nenhuma combinação encontrada."
+        
+    resposta = f"📊 **Total de {len(resultados)} combinações encontradas (1-10 cotas)**\n\n"
     
-     # 1. Agrupar os resultados por administradora, mantendo a diferença para ordenação interna
-    # grouped_by_adm = {'Administradora X': [(combinacao_A, 100), (combinacao_C, 180), ...],
-    #                   'Administradora Y': [(combinacao_B, 150), ...]}
+    # Agrupa por administradora mantendo a ordenação por qualidade
     grouped_by_adm = defaultdict(list)
     for adm, combinacao, diferenca in resultados:
         grouped_by_adm[adm].append((combinacao, diferenca))
 
-    # 2. Ordenar as combinações dentro de cada administradora pela diferença (do menor para o maior)
+    # Ordena cada grupo por diferença
     for adm in grouped_by_adm:
-        grouped_by_adm[adm].sort(key=lambda x: x[1]) # x[1] é a diferença
-
-    final_resultados_diversificados = []
+        grouped_by_adm[adm].sort(key=lambda x: x[1])
+
+    # Seleciona as melhores combinações de cada administradora
+    final_resultados = []
+    for adm, combinacoes in grouped_by_adm.items():
+        # Pega as 5 melhores de cada administradora
+        for combinacao, diferenca in combinacoes[:5]:
+            final_resultados.append((adm, combinacao, diferenca))
     
-    # Dicionário para acompanhar o índice da próxima combinação a ser pega de cada administradora
-    # Ex: {'Itau': 0, 'Bradesco': 0, 'Caixa': 0}
-    adm_indices = {adm: 0 for adm in grouped_by_adm.keys()}
-
-    # Lista de administradoras ativas (que ainda têm combinações disponíveis)
-    active_adms = list(grouped_by_adm.keys())
+    # Ordena todas as combinações por qualidade
+    final_resultados.sort(key=lambda x: x[2])
     
-    current_adm_idx = 0 # Índice para ciclar entre as administradoras ativas
+    # Limita a 20 resultados finais para exibição
+    final_resultados = final_resultados[:20]
     
-    # Loop para selecionar até 15 combinações, garantindo diversidade
-    while len(final_resultados_diversificados) < 15 and active_adms:
-        # Pega a administradora da vez para selecionar uma combinação
-        adm_da_vez = active_adms[current_adm_idx]
-        
-        # Pega o índice da próxima combinação para essa administradora
-        idx_na_adm = adm_indices[adm_da_vez]
-        
-        # Verifica se essa administradora ainda tem combinações disponíveis
-        if idx_na_adm < len(grouped_by_adm[adm_da_vez]):
-            # Pega a combinação (ignorando a diferença, que já foi usada para ordenar internamente)
-            combinacao_data, _ = grouped_by_adm[adm_da_vez][idx_na_adm]
-            
-            # Adiciona à lista de resultados final (com a administradora e a combinação)
-            final_resultados_diversificados.append((adm_da_vez, combinacao_data))
-            
-            # Incrementa o índice para a próxima vez que pegarmos dessa administradora
-            adm_indices[adm_da_vez] += 1
-        else:
-            # Se essa administradora não tem mais combinações, remove ela da lista de ativas
-            active_adms.pop(current_adm_idx)
-            # Ajusta o current_adm_idx se a lista diminuiu e estamos no limite
-            if current_adm_idx >= len(active_adms) and active_adms:
-                 current_adm_idx = 0 # Volta para o início da lista se removemos o último
-
-        # Move para a próxima administradora no ciclo (garantindo que não estouramos o índice da lista active_adms)
-        if active_adms: # Só avança se ainda houver administradoras ativas
-            current_adm_idx = (current_adm_idx + 1) % len(active_adms)
-        else:
-            break # Não há mais administradoras ativas, sai do loop
-            
-    # Agora, itera sobre os resultados diversificados para formatar a resposta
-    for idx, (adm, combinacao) in enumerate(final_resultados_diversificados, 1):
+    for idx, (adm, combinacao, diferenca) in enumerate(final_resultados, 1):
         codigos = [str(c.get('codigo', 'N/A')) for c in combinacao]
         total_credito = sum(c['valor_credito'] for c in combinacao)
         total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
@@ -200,46 +279,39 @@ def formatar_resultados(resultados):
         taxa_percentual = (taxa_total / credito_real) * 100 if credito_real > 0 else 0
         taxa_mensal = taxa_percentual / maior_prazo if maior_prazo > 0 else 0
 
-        #comissao = total_entrada * (8.5 / 108.5)
-
         resposta += f"""
 --- COMBINAÇÃO {idx} ---
-�� Administradora: {adm}
-🔢 Códigos: {', '.join(codigos)}
-💰 Crédito Total: {formatar_moeda(total_credito)}
-�� Entrada (+comissão): {formatar_moeda(total_entrada)}
-📉 Saldo Devedor: {formatar_moeda(total_saldo)}
-💲 Parcela: {formatar_moeda(total_parcelas)}
-⏳ Prazo: {maior_prazo} meses
-🔚 Valor Final: {formatar_moeda(valor_final)}
-💠 Crédito Líquido: {formatar_moeda(credito_real)}
-📊 Taxa Total: {taxa_percentual:.2f}% ({formatar_moeda(taxa_total)})
-🗓️ Taxa Mensal: {taxa_mensal:.2f}%
-🗓️ Taxa Anual: {taxa_mensal * 12:.2f}%
-📊 Nº de Cotas: {len(combinacao)}
+🏢 **Administradora:** {adm.upper()}
+🔢 **Códigos ({len(combinacao)} cotas):** {', '.join(codigos)}
+💰 **Crédito Total:** {formatar_moeda(total_credito)}
+💵 **Entrada (+comissão):** {formatar_moeda(total_entrada)}
+📉 **Saldo Devedor:** {formatar_moeda(total_saldo)}
+💲 **Parcela:** {formatar_moeda(total_parcelas)}
+⏳ **Prazo:** {maior_prazo} meses
+🔚 **Valor Final:** {formatar_moeda(valor_final)}
+💠 **Crédito Líquido:** {formatar_moeda(credito_real)}
+📊 **Taxa Total:** {taxa_percentual:.2f}% ({formatar_moeda(taxa_total)})
+🗓️ **Taxa Mensal:** {taxa_mensal:.2f}%
+⭐ **Score de Qualidade:** {diferenca:.2f}
 """
     return resposta
 
 # --- INICIALIZAÇÃO PARA GRADIO ---
-# Carrega a planilha UMA VEZ no início do aplicativo
-# Se der erro, a função de busca tentará carregar novamente.
 if not carregar_planilha():
     print("⚠️ Aviso: Planilha não carregada na inicialização. Tentará carregar na primeira busca.")
 
-# Calcula a entrada adicionando 8,5% ao valor final da entrada.
-def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
+def ajustar_e_buscar_10_cotas(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
     entrada_calculada = credito_desejado * 0.085 + entrada_desejada
-    return buscar_combinacoes(credito_desejado, entrada_calculada, parcela_desejada, administradoras)
+    return buscar_combinacoes_10_cotas(credito_desejado, entrada_calculada, parcela_desejada, administradoras)
 
-# Prepara as opções para o seletor de administradoras do Gradio
 def get_administradoras_options():
-    if df is not None:
-        adm_list = df[df['tipo_do_bem'].str.lower() == 'auto']['administradora'].unique()
-        return sorted(adm_list.tolist()) # Converter para lista, pois .unique() pode retornar um numpy array
+    if df is not None and df_filtrado_auto is not None:
+        adm_list = df_filtrado_auto['administradora'].unique()
+        return sorted(adm_list.tolist())
     return []
 
-# --- Interface Gradio ---
-with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis") as demo:
+# --- Interface Gradio para 10 cotas ---
+with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis (1-10 Cotas)") as demo:
     gr.HTML("""
     <link href="https://fonts.googleapis.com/css2?family=Poppins&display=swap" rel="stylesheet">
     <style>
@@ -248,32 +320,38 @@ with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis") as demo:
         }
         
         body {
-            background-color: #ff8f00 !important;
+            background: linear-gradient(135deg, #ff8f00 0%, #ffa000 100%) !important;
             color: black !important;
         }
         
-        /* Inputs Numéricos: Crédito, Entrada, Parcela */
+        .gr-box {
+            border-radius: 12px !important;
+            border: 2px solid #000 !important;
+        }
+        
         input[type="number"] {
             background-color: white !important;
             border: 2px solid #000 !important;
             border-radius: 12px !important;
             color: black !important;
-            padding: 10px !important;
+            padding: 12px !important;
             font-weight: 500;
         }
         
-        /* Inputs de texto e áreas de texto (como a saída e código) */
-        input[type="text"], textarea {
+        textarea {
             background-color: white !important;
             border: 2px solid black !important;
             border-radius: 12px !important;
             color: black !important;
-            padding: 10px !important;
+            padding: 12px !important;
+            font-size: 14px;
         }
         
-        input::placeholder, textarea::placeholder {
-            color: #333 !important;
-            opacity: 0.7;
+        .gr-checkbox-group {
+            background-color: white !important;
+            border: 2px solid black !important;
+            border-radius: 12px !important;
+            padding: 10px;
         }
         
         .gr-checkbox label {
@@ -281,63 +359,93 @@ with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis") as demo:
             align-items: center;
             gap: 8px;
             font-weight: 600;
+            margin: 5px 0;
         }
         
         input[type="checkbox"] {
-            accent-color: black !important;
+            accent-color: #ff8f00 !important;
             width: 18px;
             height: 18px;
         }
         
         .gr-button {
             font-weight: bold;
-            border-radius: 10px !important;
-            background-color: white !important;
-            color: black !important;
-            border: 2px solid black !important;
+            border-radius: 12px !important;
+            background: linear-gradient(135deg, #000000 0%, #333333 100%) !important;
+            color: white !important;
+            border: none !important;
+            padding: 12px 24px !important;
+            font-size: 16px;
         }
         
         .gr-button:hover {
-            background-color: #fff3e0 !important;
-            color: black !important;
+            background: linear-gradient(135deg, #333333 0%, #555555 100%) !important;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 8px rgba(0,0,0,0.2);
         }
         
         label {
-            font-weight: 600 !important;
+            font-weight: 700 !important;
+            color: #000 !important;
+            margin-bottom: 8px !important;
+        }
+        
+        .gr-markdown h1 {
+            color: #000 !important;
+            text-align: center;
+            margin-bottom: 20px;
         }
     </style>
     """)
     
     gr.Markdown("# 🚗 Sistema de Busca de Combinações de Consórcio (Automóveis)")
-    gr.Markdown("Preencha os campos abaixo para encontrar as melhores combinações de cotas de consórcio de veículo.")
+    gr.Markdown("### 🔥 **Versão 1-10 Cotas - Busca Inteligente**")
+    gr.Markdown("Preencha os campos abaixo para encontrar as melhores combinações de 1 a 10 cotas de consórcio de veículo.")
 
     with gr.Row():
-        credito_input = gr.Number(label="Crédito Desejado (R$)", value=30000, step=1000, interactive=True)
-        entrada_input = gr.Number(label="Entrada Desejada (R$)", value=3000, step=100, interactive=True)
-        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=500, step=10, interactive=True)
-
-    administradoras_options = get_administradoras_options()
-    administradoras_multiselect = gr.CheckboxGroup(
-        label="Filtrar por Administradoras",
-        choices=administradoras_options,
-        value=administradoras_options, # Seleciona todas por padrão
-        interactive=True
+        with gr.Column(scale=1):
+            credito_input = gr.Number(label="Crédito Desejado (R$)", value=30000, step=1000, interactive=True)
+            entrada_input = gr.Number(label="Entrada Desejada (R$)", value=3000, step=100, interactive=True)
+            parcela_input = gr.Number(label="Parcela Desejada (R$)", value=500, step=10, interactive=True)
+            
+            gr.Markdown("### ⚙️ Configurações de Busca")
+            gr.Markdown("O sistema busca automaticamente as melhores combinações de 1 a 10 cotas")
+            
+            submit_btn = gr.Button("🔍 Buscar Combinações (1-10 Cotas)", variant="primary", size="lg")
+
+        with gr.Column(scale=1):
+            administradoras_options = get_administradoras_options()
+            administradoras_multiselect = gr.CheckboxGroup(
+                label="Filtrar por Administradoras",
+                choices=administradoras_options,
+                value=administradoras_options[:5] if len(administradoras_options) > 5 else administradoras_options,
+                interactive=True
+            )
+            
+            gr.Markdown("### 💡 Dicas para busca eficiente:")
+            gr.Markdown("- Selecione até 5 administradoras para busca mais rápida")
+            gr.Markdown("- Use valores aproximados para encontrar mais opções")
+            gr.Markdown("- O sistema mostra até 20 das melhores combinações")
+
+    output_text = gr.Textbox(
+        label="📋 Resultados da Busca (1-10 Cotas)", 
+        lines=25, 
+        max_lines=50, 
+        interactive=False, 
+        placeholder="Os resultados aparecerão aqui...",
+        show_copy_button=True
     )
 
-    submit_btn = gr.Button("🔍 Buscar Combinações", variant="primary")
-
-    output_text = gr.Textbox(label="Resultados da Busca", lines=20, max_lines=40, interactive=False, placeholder="Os resultados aparecerão aqui...")
-
-    # Conecta o botão à função de busca
+    # Conecta o botão à função de busca para 10 cotas
     submit_btn.click(
-        fn=ajustar_e_buscar,
+        fn=ajustar_e_buscar_10_cotas,
         inputs=[credito_input, entrada_input, parcela_input, administradoras_multiselect],
         outputs=output_text
     )
 
-
     gr.Markdown("---")
-    gr.Markdown("Ferramenta desenvolvida para otimizar a busca por consórcios de automóveis.")
+    gr.Markdown("**🔥 Ferramenta avançada** para buscas de combinações de 1 a 10 cotas")
+    gr.Markdown("*Desenvolvido com algoritmos de busca inteligente e poda*")
 
 if __name__ == "__main__":
-    demo.launch() # Você não precisa disso no Colab, mas sim no arquivo que você fará o deploy
+    demo.launch(share=False)