Exercício: contar ocorrências de palavras num texto (HashMap)
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!
Dicas do Exercício
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.
Exemplo de Texto de Entrada
“O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar.”
Exemplo de saída:
{
"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
}
O que podemos aprender neste exercício?
Neste exercício, podemos aprender várias coisas:
- Uso de Estruturas de Dados: A solução do problema envolve o uso de estruturas de dados adequadas para manipular e armazenar informações. Em diferentes linguagens de programação, foram utilizadas estruturas como HashMaps, Dicionários e Unordered Maps para armazenar as contagens de palavras únicas.
- Manipulação de Strings: O problema requer a manipulação de strings para dividir o texto em palavras, remover pontuações e converter para minúsculas. Isso demonstra a importância de saber como manipular strings eficientemente para processamento de texto.
- Uso de Iteração: A solução envolve iteração sobre as palavras no texto e sobre os itens das estruturas de dados. Iterar sobre coleções de dados é uma habilidade fundamental na programação e é amplamente utilizada para processamento de informações.
- Tratamento de Dados não Estruturados: O texto fornecido é um exemplo de dados não estruturados. Lidar com esse tipo de dados requer técnicas para extrair informações relevantes e tratá-las de maneira eficaz.
- Algoritmos de Contagem: O problema demonstra um tipo de algoritmo de contagem, que é comum em muitos cenários de processamento de dados. Esse tipo de algoritmo é útil em uma variedade de aplicações, como análise de texto, contagem de ocorrências e geração de estatísticas.
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!
Exemplo em GO
/******************************************************************************
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.
Exemplo em Python
'''
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.
Exemplo em C# / C Sharp
/******************************************************************************
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.
Exemplo em Delphi
(***************************************
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.
Exemplo em Java
/******************************************************************************
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.
Exemplo em C++
/******************************************************************************
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.
Exemplo em Rust
/******************************************************************************
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.
Conclusão
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
