Palavra Dentro De Outra Palavra

O que acontece quando você precisa encontrar palavras dentro de outras palavras

É comum alguém pedir pra você extrair todas as substrings válidas de um termo maior e a coisa parecer simples até você começar a pensar nos limites. Vou explicar do jeito que eu faço no dia a dia, que é bem prático e não envolve muito conceito.

palavra dentro de outra palavra

Basicamente, a ideia é pegar uma string e buscar ocorrências de outra string menor dentro dela. Em português, você pode estar lidando com isso em validação de dados, jogos de palavras, busca morfossintática ou até processamento de texto para NLP. O caso mais banal é: "saudável" contém "saudade". Já o caso irritante é quando seu algoritmo acha que "s" é uma palavra válida, aí você tem que colocar filtros de tamanho mínimo. Eu costumava trabalhar num sistema de tagging automática para conteúdo editorial onde precisávamos identificar palavras-chave escondidas em nomes próprios e termos técnicos. Achei que seria rápido, mas no meio do caminho tive um problema específico que demorou pra resolver: uma regra de busca encontrava "rato" como substring de "aratacador" e "ratificação", gerando tags completamente erradas. A solução foi adicionar um filtro de palavra completa com boundary -- o famoso \b em regex -- mas aí caímos em outro problema: palavras compostas como "guarda-chuva" não casavam porque o hífen quebrava o boundary. A workaround que funcionou foi normalizar removendo hifens antes de aplicar a busca de substring, mantendo só os caracteres alfanuméricos.

Como fazer na prática

A abordagem mais direta é iterar por todos os índices possíveis da string pai e verificar, a partir de cada posição, se a substring pretendida começa ali. Se estiver usando JavaScript, um `includes()` resolve num linha. Se for Python, o operador `in`. A questão é escala: se você precisar verificar múltiplas palavras candidatas contra um corpus grande, esse método ingênuo fica lento. Para quem precisa de performance, o Aho-Corasick é o algoritmo clássico. Ele constrói um autômato que processa o texto de entrada uma única vez e reporta todas as ocorrências de todas as palavras do dicionário simultaneamente. Em vez de O(n × m) com a abordagem brutal, cai pra O(n + m + z), onde z é o número total de ocorrências. No meu setup de NLP, migrei de str.includes() pra uma implementação Aho-Corasick e o tempo de processamento de um corpus de 50 mil documentos caiu de cerca de 4 minutos pra 18 segundos. Não é mágica, é apenas a diferença entre varrer o texto repetidamente e varrer uma única vez.

Dicas que ninguém conta

Primeiro: normalização de acentos. Se você não tratar "á" e "a" como equivalentes, vai perder ocorrências óbvias. Um NFKD no Python ou um dicionário de mapeamento de acentos em Node resolve isso sem dor de cabeça. Segundo: filtro de tamanho. Definir um tamanho mínimo de substring ajuda muito a reduzir ruído. Palavras com 2 caracteres ou menos geralmente geram falsos positivos massivos. Eu uso 3 como padrão, mas depende do domínio -- em nomes próprios às vezes 2 já é válido.

Terceiro: sobreposição. Se sua substring-alvo é "ana" e o texto é "banana", o algoritmo ingênuo encontra uma ocorrência em índice 1 e para. Se você precisa de todas as ocorrências possíveis (incluindo sobrepostas), use um loop com indexOf acumulando o próximo start a partir de lastIndex + 1, não de lastIndex + tamanho.

Quando isso não funciona

A técnica de substring pura quebra quando você lida com linguagem natural e quer identificar palavras reais. "O rato roeu a roupa" -- achar "rata" em "roeu" não faz sentido linguístico. Para esses casos, você precisa de segmentação morfológica, não de busca de substring. Ferramentas como o Stanza ou o spaCy fazem tokenização e reconhecimento de entidades, o que é infinitamente mais confiável para entender se algo é de fato uma palavra ou apenas um acidente gráfico. Outro ponto: strings com codificação errada. Já vi gente perder horas porque o UTF-8 vinha corrompido e o caractere "ã" virava dois bytes separados que não casavam com nada. Sempre valide a encoding antes de começar a buscar.

Exemplo prático rápido

Aqui vai um esboço simples de como implementaria em JavaScript: function findWords(text, candidates) { return candidates.filter(w => text.toLowerCase().includes(w.toLowerCase())); }

Para múltiplas ocorrências com sobreposição, um pouco mais de código: function findAll(text, target) { const results = []; let i = 0; while ((i = text.toLowerCase().indexOf(target.toLowerCase(), i)) !== -1) { results.push(i); i++; } return results; }

Isso retorna os índices onde cada ocorrência começa. Se precisar das substrings de tamanho variável, basta ajustar o loop para testar todos os comprimentos possíveis a partir de cada posição.

Conclusão (ou o que sobrou)

Buscar palavra dentro de outra palavra parece simples até você precisar escalonar. O pulo do gato é escolher a ferramenta certa pro volume de dados e tratar os casos de borda que aparecem inevitavelmente -- acentos, sobreposição, boundary e codificação. Depois disso, vira rotina.