Fala galera da programação, tudo beleza? Este é um novo algoritmo onde vamos utilizar laços e vetores.É um exercício bem legal para desenvolver a lógica de programação.
Dica do Exercício
Você pode usar um hashmap (dicionário) para otimizar a busca pela primeira letra única.
Neste exercício, podemos aprender várias coisas:
HashMap (em linguagens como Java, C# e Rust) ou dicionários (em Python, Pascal, Delphi) para armazenar a contagem de ocorrências de cada letra.Esses conceitos e habilidades são fundamentais na programação e podem ser aplicados em uma ampla variedade de problemas e projetos do mundo real.
Vamos aos Códigos!
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
#include <iostream>
#include <string>
#include <unordered_map>
char primeira_letra_nao_repetida(const std::string& texto) {
std::unordered_map<char, int> contagem;
// Contagem de ocorrências de cada letra usando um hashmap
for (char letra : texto) {
contagem[letra]++;
}
// Encontrar a primeira letra não repetida
for (char letra : texto) {
if (contagem[letra] == 1) {
return letra;
}
}
// Caso não haja letras únicas
return '_';
}
int main() {
std::string texto;
std::cout << "Digite um texto contendo apenas letras minúsculas: ";
std::getline(std::cin, texto);
char resultado = primeira_letra_nao_repetida(texto);
std::cout << "A primeira letra que não se repete é: " << resultado << std::endl;
return 0;
}
Este código em C++ usa std::unordered_map para contar as ocorrências de cada letra e, em seguida, itera sobre o texto para encontrar a primeira letra não repetida. Se não houver letras únicas, retorna “_”.
(*
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*)
program PrimeiraLetraNaoRepetida;
{$APPTYPE CONSOLE}
uses
SysUtils, Generics.Collections;
function PrimeiraLetraNaoRepetida(const texto: string): Char;
var
contagem: TDictionary<Char, Integer>;
letra: Char;
begin
contagem := TDictionary<Char, Integer>.Create;
try
// Contagem de ocorrências de cada letra usando um TDictionary
for letra in texto do
begin
if contagem.ContainsKey(letra) then
contagem[letra] := contagem[letra] + 1
else
contagem.Add(letra, 1);
end;
// Encontrar a primeira letra não repetida
for letra in texto do
begin
if contagem[letra] = 1 then
Exit(letra);
end;
// Caso não haja letras únicas
Result := '_';
finally
contagem.Free;
end;
end;
var
texto: string;
resultado: Char;
begin
Write('Digite um texto contendo apenas letras minúsculas: ');
Readln(texto);
resultado := PrimeiraLetraNaoRepetida(texto);
Writeln('A primeira letra que não se repete é: ', resultado);
end.
Neste exemplo em Delphi, usamos TDictionary<Char, Integer> para criar um dicionário que mapeia caracteres para o número de vezes que cada caractere aparece no texto. Depois, percorremos o texto para contabilizar as ocorrências de cada letra. Em seguida, percorremos novamente o texto para encontrar a primeira letra não repetida.
Por fim, lembre-se de liberar a memória alocada para o dicionário quando não precisar mais dele, usando contagem.Free no bloco finally.
'''
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
'''
def primeira_letra_nao_repetida(texto):
contagem = {}
# Contagem de ocorrências de cada letra usando um hashmap
for letra in texto:
contagem[letra] = contagem.get(letra, 0) + 1
# Encontrar a primeira letra não repetida
for letra in texto:
if contagem[letra] == 1:
return letra
# Caso não haja letras únicas
return '_'
# Exemplo de uso:
texto = input("Digite um texto contendo apenas letras minúsculas: ")
resultado = primeira_letra_nao_repetida(texto)
print("A primeira letra que não se repete é:", resultado)
Esse programa pedirá ao usuário para inserir um texto contendo apenas letras minúsculas e depois retornará a primeira letra que não se repete. Se não houver letras únicas, retornará “_”.
Neste exemplo utilizamos o método .get() do dicionário Python para obter o valor de uma chave, retornando 0 se a chave não existir (o que é o comportamento padrão). Isso torna o código mais conciso e legível.
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
using System;
using System.Collections.Generic;
class Program
{
static char PrimeiraLetraNaoRepetida(string texto)
{
Dictionary<char, int> contagem = new Dictionary<char, int>();
// Contagem de ocorrências de cada letra usando um dicionário
foreach (char letra in texto)
{
if (contagem.ContainsKey(letra))
contagem[letra]++;
else
contagem[letra] = 1;
}
// Encontrar a primeira letra não repetida
foreach (char letra in texto)
{
if (contagem[letra] == 1)
return letra;
}
// Caso não haja letras únicas
return '_';
}
static void Main(string[] args)
{
Console.Write("Digite um texto contendo apenas letras minúsculas: ");
string texto = Console.ReadLine();
char resultado = PrimeiraLetraNaoRepetida(texto);
Console.WriteLine("A primeira letra que não se repete é: " + resultado);
}
}
Este código em C# implementa a mesma lógica dos exemplos anteriores. Ele usa um Dictionary para contar as ocorrências de cada letra, e então itera sobre o texto para encontrar a primeira letra não repetida. Se não houver letras únicas, retorna “_”.
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
public static char primeiraLetraNaoRepetida(String texto) {
Map<Character, Integer> contagem = new HashMap<>();
// Contagem de ocorrências de cada letra usando um hashmap
for (char letra : texto.toCharArray()) {
contagem.put(letra, contagem.getOrDefault(letra, 0) + 1);
}
// Encontrar a primeira letra não repetida
for (char letra : texto.toCharArray()) {
if (contagem.get(letra) == 1) {
return letra;
}
}
// Caso não haja letras únicas
return '_';
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Digite um texto contendo apenas letras minúsculas: ");
String texto = scanner.nextLine();
char resultado = primeiraLetraNaoRepetida(texto);
System.out.println("A primeira letra que não se repete é: " + resultado);
}
}
Este código em Java implementa a mesma lógica dos exemplos anteriores. Ele usa um HashMap para contar as ocorrências de cada letra, e então itera sobre o texto para encontrar a primeira letra não repetida. Se não houver letras únicas, retorna “_”.
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
use std::collections::HashMap;
use std::io;
fn primeira_letra_nao_repetida(texto: &str) -> char {
let mut contagem = HashMap::new();
// Contagem de ocorrências de cada letra usando um hashmap
for letra in texto.chars() {
*contagem.entry(letra).or_insert(0) += 1;
}
// Encontrar a primeira letra não repetida
for letra in texto.chars() {
if contagem[&letra] == 1 {
return letra;
}
}
// Caso não haja letras únicas
'_'
}
fn main() {
println!("Digite um texto contendo apenas letras minúsculas:");
let mut texto = String::new();
io::stdin().read_line(&mut texto).expect("Falha ao ler a entrada");
let resultado = primeira_letra_nao_repetida(&texto);
println!("A primeira letra que não se repete é: {}", resultado);
}
Este código em Rust implementa a mesma lógica dos exemplos anteriores. Ele usa um HashMap para contar as ocorrências de cada letra, e então itera sobre o texto para encontrar a primeira letra não repetida. Se não houver letras únicas, retorna “_”.
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
htttp://giovanidacruz.com.br
*******************************************************************************/
package main
import (
"fmt"
)
func primeiraLetraNaoRepetida(texto string) rune {
contagem := make(map[rune]int)
// Contagem de ocorrências de cada letra usando um mapa
for _, letra := range texto {
contagem[letra]++
}
// Encontrar a primeira letra não repetida
for _, letra := range texto {
if contagem[letra] == 1 {
return letra
}
}
// Caso não haja letras únicas
return '_'
}
func main() {
var texto string
fmt.Print("Digite um texto contendo apenas letras minúsculas: ")
fmt.Scanln(&texto)
resultado := primeiraLetraNaoRepetida(texto)
fmt.Println("A primeira letra que não se repete é:", string(resultado))
}
Neste código em Go, usamos um mapa (map[rune]int) para contar as ocorrências de cada letra. Em seguida, percorremos o texto para encontrar a primeira letra não repetida. Se não houver letras únicas, retornamos “_”.
Neste exercício, exploramos a implementação de um algoritmo para encontrar a primeira letra não repetida em um texto fornecido. Por meio de várias linguagens de programação, incluindo Python, C++, Java, Rust, Pascal, Delphi e Go, abordamos o problema de maneiras diferentes, mas fundamentais.
Ao praticar este exercício, os programadores podem melhorar suas habilidades de resolução de problemas, ganhar experiência com diferentes linguagens de programação e solidificar conceitos importantes de programação, como manipulação de strings, uso de estruturas de dados e lógica de programação. Isso os prepara para enfrentar uma variedade de desafios na programação de software.
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
#Desenvolvimento
#Algoritmos
#Hashmap
#GiovaniDaCruz
Está gostando do conteúdo?
Considere pagar um cafezinho para nossa equipe!
