Fala galera da programação, tudo beleza?
Você já pensou como é possível contar palavras únicas em um texto de forma eficiente? Neste nosso post, exploramos como resolver esse problema usando diferentes linguagens de programação, desde Python até Rust! Descubra como manipular strings, usar estruturas de dados como HashMaps e muito mais. Confira agora mesmo e aprimore suas habilidades de programação!
Não é necessário solicitar ao usuário para informar um texto. Vamos deixar ele fixo neste exercício;
Neste problema, um HashMap é útil para armazenar as palavras únicas como chaves e seus contadores como valores. Iteramos sobre cada palavra no texto, removemos pontuações e convertemos para minúsculas. Em seguida, verificamos se a palavra já está no HashMap. Se sim, incrementamos seu contador; caso contrário, adicionamos a palavra ao HashMap com um contador inicial de 1. Isso nos permite contar eficientemente as ocorrências de cada palavra única no texto.
“O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar.”
{ "o": 3, "rato": 2, "roeu": 1, "a": 1, "roupa": 1, "do": 1, "rei": 2, "de": 1, "roma": 1, "e": 1, "ficou": 1, "tão": 1, "irritado": 1, "que": 1, "mandou": 1, "para": 1, "mar": 1 }
Neste exercício, podemos aprender várias coisas:
De modo resumido, este exercício oferece uma oportunidade para praticar habilidades de manipulação de dados, estruturas de dados e algoritmos básicos, enquanto aborda um problema comum de processamento de texto.
Vamos aos códigos!
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ package main import ( "fmt" "strings" ) func countUniqueWords(text string) map[string]int { // Inicializa o mapa para armazenar as contagens de palavras únicas wordCount := make(map[string]int) // Divide o texto em palavras usando espaços em branco como delimitador words := strings.Fields(text) // Itera sobre cada palavra no texto for _, word := range words { // Remove pontuações e converte para minúsculas cleanedWord := strings.ToLower(strings.Trim(word, ".,!?")) // Incrementa o contador da palavra no mapa wordCount[cleanedWord]++ } return wordCount } func main() { // Texto de exemplo text := "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar." // Conta as palavras únicas no texto uniqueWordCount := countUniqueWords(text) // Imprime as contagens de palavras únicas fmt.Println("Contagem de palavras únicas:") for word, count := range uniqueWordCount { fmt.Printf("%s: %d\n", word, count) } }
Neste código Go, usando um HashMap, a função countUniqueWords
recebe o texto como entrada e retorna um mapa onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando espaços em branco como delimitador, e então cada palavra é limpa de pontuações e convertida para minúsculas antes de ser contada. A função main
utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.
''' Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br ''' def count_unique_words(text): # Inicializa o dicionário para armazenar as contagens de palavras únicas word_count = {} # Divide o texto em palavras usando espaços em branco como delimitador words = text.split() # Itera sobre cada palavra no texto for word in words: # Remove pontuações e converte para minúsculas cleaned_word = word.strip(".,!?").lower() # Incrementa o contador da palavra no dicionário if cleaned_word in word_count: word_count[cleaned_word] += 1 else: word_count[cleaned_word] = 1 return word_count def main(): # Texto de exemplo text = "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar." # Conta as palavras únicas no texto unique_word_count = count_unique_words(text) # Imprime as contagens de palavras únicas print("Contagem de palavras únicas:") for word, count in unique_word_count.items(): print(f"{word}: {count}") if __name__ == "__main__": main()
Neste código Python, a função count_unique_words
recebe o texto como entrada e retorna um dicionário onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando espaços em branco como delimitador, e então cada palavra é limpa de pontuações e convertida para minúsculas antes de ser contada. A função main
utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ using System; using System.Collections.Generic; using System.Linq; using System.Text.RegularExpressions; class Program { static Dictionary<string, int> CountUniqueWords(string text) { // Inicializa o dicionário para armazenar as contagens de palavras únicas Dictionary<string, int> wordCount = new Dictionary<string, int>(); // Divide o texto em palavras usando expressões regulares string[] words = Regex.Split(text, @"\W+"); // Itera sobre cada palavra no texto foreach (string word in words) { // Remove pontuações e converte para minúsculas string cleanedWord = word.Trim().ToLower(); // Incrementa o contador da palavra no dicionário if (!string.IsNullOrEmpty(cleanedWord)) { if (wordCount.ContainsKey(cleanedWord)) { wordCount[cleanedWord]++; } else { wordCount[cleanedWord] = 1; } } } return wordCount; } static void Main(string[] args) { // Texto de exemplo string text = "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar."; // Conta as palavras únicas no texto Dictionary<string, int> uniqueWordCount = CountUniqueWords(text); // Imprime as contagens de palavras únicas Console.WriteLine("Contagem de palavras únicas:"); foreach (var kvp in uniqueWordCount) { Console.WriteLine($"{kvp.Key}: {kvp.Value}"); } } }
Neste código C#, a função CountUniqueWords
recebe o texto como entrada e retorna um dicionário onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando expressões regulares para separar palavras de pontuações, e então cada palavra é limpa de espaços em branco, pontuações e convertida para minúsculas antes de ser contada. A função Main
utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.
(*************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br ****************************************) program CountUniqueWords; {$APPTYPE CONSOLE} uses SysUtils, StrUtils, Classes, Generics.Collections, RegularExpressions; function CountUniqueWords(const Text: string): TDictionary<string, Integer>; var Words: TStringList; WordCount: TDictionary<string, Integer>; Word: string; CleanedWord: string; begin // Inicializa o TDictionary para armazenar as contagens de palavras únicas WordCount := TDictionary<string, Integer>.Create; Words := TStringList.Create; try // Divide o texto em palavras usando expressões regulares Words.DelimitedText := TRegEx.Replace(Text, '\W+', ' '); // Itera sobre cada palavra no texto for Word in Words do begin // Remove pontuações e converte para minúsculas CleanedWord := Trim(LowerCase(Word)); // Incrementa o contador da palavra no TDictionary if not CleanedWord.IsEmpty then begin if WordCount.ContainsKey(CleanedWord) then WordCount[CleanedWord] := WordCount[CleanedWord] + 1 else WordCount.Add(CleanedWord, 1); end; end; finally Words.Free; end; Result := WordCount; end; var Text: string; UniqueWordCount: TDictionary<string, Integer>; Word: string; begin // Texto de exemplo Text := 'O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar.'; // Conta as palavras únicas no texto UniqueWordCount := CountUniqueWords(Text); try // Imprime as contagens de palavras únicas WriteLn('Contagem de palavras únicas:'); for Word in UniqueWordCount.Keys do WriteLn(Word + ': ' + IntToStr(UniqueWordCount[Word])); finally UniqueWordCount.Free; end; end.
Neste código Delphi, a função CountUniqueWords
recebe o texto como entrada e retorna um TDictionary onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando expressões regulares para separar palavras de pontuações, e então cada palavra é limpa de espaços em branco, pontuações e convertida para minúsculas antes de ser contada. O programa principal utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ import java.util.*; public class Main { public static Map<String, Integer> countUniqueWords(String text) { // Inicializa o mapa para armazenar as contagens de palavras únicas Map<String, Integer> wordCount = new HashMap<>(); // Divide o texto em palavras usando expressões regulares String[] words = text.split("\\W+"); // Itera sobre cada palavra no texto for (String word : words) { // Remove pontuações e converte para minúsculas String cleanedWord = word.trim().toLowerCase(); // Incrementa o contador da palavra no mapa if (!cleanedWord.isEmpty()) { wordCount.put(cleanedWord, wordCount.getOrDefault(cleanedWord, 0) + 1); } } return wordCount; } public static void main(String[] args) { // Texto de exemplo String text = "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar."; // Conta as palavras únicas no texto Map<String, Integer> uniqueWordCount = countUniqueWords(text); // Imprime as contagens de palavras únicas System.out.println("Contagem de palavras únicas:"); for (Map.Entry<String, Integer> entry : uniqueWordCount.entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); } } }
Neste código Java, a função countUniqueWords
recebe o texto como entrada e retorna um HashMap onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando expressões regulares para separar palavras de pontuações, e então cada palavra é limpa de espaços em branco, pontuações e convertida para minúsculas antes de ser contada. O método main
utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ #include <iostream> #include <string> #include <unordered_map> #include <sstream> #include <algorithm> std::unordered_map<std::string, int> countUniqueWords(const std::string& text) { // Inicializa o unordered_map para armazenar as contagens de palavras únicas std::unordered_map<std::string, int> wordCount; // Cria um stringstream a partir do texto para processar palavra por palavra std::stringstream ss(text); std::string word; // Itera sobre cada palavra no texto while (ss >> word) { // Remove pontuações e converte para minúsculas word.erase(std::remove_if(word.begin(), word.end(), ispunct), word.end()); std::transform(word.begin(), word.end(), word.begin(), ::tolower); // Incrementa o contador da palavra no unordered_map wordCount[word]++; } return wordCount; } int main() { // Texto de exemplo std::string text = "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar."; // Conta as palavras únicas no texto auto uniqueWordCount = countUniqueWords(text); // Imprime as contagens de palavras únicas std::cout << "Contagem de palavras únicas:" << std::endl; for (const auto& pair : uniqueWordCount) { std::cout << pair.first << ": " << pair.second << std::endl; } return 0; }
Neste código C++, a função countUniqueWords
recebe o texto como entrada e retorna um std::unordered_map onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando um std::stringstream, e então cada palavra é limpa de pontuações e convertida para minúsculas antes de ser contada. O método main
utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ use std::collections::HashMap; fn count_unique_words(text: &str) -> HashMap<String, usize> { // Inicializa o HashMap para armazenar as contagens de palavras únicas let mut word_count: HashMap<String, usize> = HashMap::new(); // Divide o texto em palavras for word in text.split_whitespace() { // Remove pontuações e converte para minúsculas let cleaned_word = word.trim_matches(|c: char| !c.is_alphanumeric()).to_lowercase(); // Incrementa o contador da palavra no HashMap *word_count.entry(cleaned_word).or_insert(0) += 1; } word_count } fn main() { // Texto de exemplo let text = "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar."; // Conta as palavras únicas no texto let unique_word_count = count_unique_words(text); // Imprime as contagens de palavras únicas println!("Contagem de palavras únicas:"); for (word, count) in &unique_word_count { println!("{}: {}", word, count); } }
Neste código Rust, a função count_unique_words
recebe o texto como entrada e retorna um HashMap onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando split_whitespace
, e então cada palavra é limpa de pontuações e convertida para minúsculas antes de ser contada. O método main
utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.
Este exercício nos permitiu explorar como resolver um problema prático de contagem de palavras únicas em um texto usando diferentes linguagens de programação. Através deste exercício, aprendemos a utilizar estruturas de dados adequadas, como HashMaps, Dicionários e Unordered Maps, para armazenar as contagens de palavras únicas. Além disso, praticamos técnicas de manipulação de strings, como dividir o texto em palavras, remover pontuações e converter para minúsculas.
Foi uma oportunidade para entender como lidar com dados não estruturados e aplicar algoritmos simples, como algoritmos de contagem, para resolver problemas de processamento de texto. Também destacou a importância da iteração sobre coleções de dados e a necessidade de compreender as peculiaridades de cada linguagem de programação para implementar soluções eficientes e legíveis.
Em resumo, este exercício proporcionou uma valiosa prática para desenvolver habilidades essenciais de programação, além de ilustrar a aplicação de conceitos fundamentais em um contexto prático.
Beleza pessoal? Espero que tenham gostado.
Dúvidas ou sugestões de outras linguagens? Deixe o seu comentário!
Um abraço e até o próximo post. Valeu!
#Programação
#ManipulaçãoDeTexto
#EstruturasDeDados
#DesenvolvimentoDeSoftware
#GiovaniDaCruz
Está gostando do conteúdo?
Considere pagar um cafezinho para nossa equipe!