Leia uma frase qualquer. Depois elabore um algoritmo que a converta para maiúscula essa frase. Ao final apresente na tela a frase convertida. Usar repetição e no máximo uma função pronta.

Passo 1

O enunciado pede que eu faça um algoritmo que:
  • Leia uma frase qualquer (entrada do usuário).
  • Converta essa frase inteira para maiúsculas.
  • Apresente na tela a frase convertida ao final.
    Condições adicionais impostas pelo enunciado:
  • Usar repetição (ou seja, percorrer caractere a caractere com um laço).
  • Usar no máximo uma função pronta. Vou interpretar isso como permitir uma única chamada de função pronta para ler a entrada (por exemplo, uma função que lê a linha do teclado). Todo o restante do trabalho (detecção e conversão de letras) será feito manualmente com laços e comparações, sem usar funções prontas de conversão de maiúsculas.

Passo 2

Entendendo a ideia geral (sem ainda programar): uma string é uma sequência de caracteres. Minha estratégia é:
  • Ler a frase como uma sequência de caracteres.
  • Construir uma nova sequência (resultado) vazia.
  • Percorrer cada caractere da frase original usando um laço.
  • Para cada caractere:
    • Se for uma letra minúscula (por exemplo, ‘a’, ‘b’, …, ‘z’), substituo pela respectiva letra maiúscula correspondente (‘A’, ‘B’, …, ‘Z’).
    • Se não for letra minúscula (espaço, pontuação, número, letra já maiúscula etc.), deixo o caractere igual.
  • Ao final do laço, exibirei a sequência resultante (tudo em maiúsculas).
Por que faço assim? Porque o enunciado pediu explicitamente usar repetição e limitar o uso de funções prontas. Assim eu tento não usar funções prontas de conversão automática (como toUpperCase) e implemento a conversão manualmente.

Passo 3

Conceitos necessários (explicados de forma simples):
  • O que é um caractere: é um símbolo da frase (letra, número, espaço, pontuação). Uma string é só uma lista desses símbolos.
  • Comparação de caracteres: dá para comparar se um caractere é igual a outro, ou se ele pertence a um conjunto (por exemplo, as 26 letras minúsculas).
  • Indexação manual: para transformar uma letra minúscula em maiúscula sem chamar funções prontas, eu mantenho duas sequências paralelas:
    • uma com todas as letras minúsculas na ordem: “abcdefghijklmnopqrstuvwxyz”
    • outra com todas as letras maiúsculas na mesma ordem: “ABCDEFGHIJKLMNOPQRSTUVWXYZ”
    • Ao encontrar um caractere que está na lista de minúsculas, eu procuro sua posição (índice) com um pequeno laço de busca e pego o caractere correspondente na lista de maiúsculas.
  • Laço de repetição: percorro todos os caracteres da frase original e vou construindo a frase convertida.
Observação sobre acentuação: este algoritmo, na forma mostrada, cuida das 26 letras latinas sem acento. Se for necessário tratar letras acentuadas (á, ç, ã, etc.), a mesma técnica funciona: basta incluir essas letras nas duas sequências (minúsculas e maiúsculas) correspondentes.

Passo 4

Algoritmo detalhado passo a passo (explicado em palavras):
  1. Chamar uma função pronta para ler a frase do usuário (esta será a única função pronta que usarei). Guardar a frase em uma variável chamada frase.
  2. Criar duas strings:
    • minusculas = “abcdefghijklmnopqrstuvwxyz”
    • maiusculas = “ABCDEFGHIJKLMNOPQRSTUVWXYZ”
      (se quiser tratar acentos, adicionar os pares correspondentes em ambas)
  3. Criar uma string vazia resultado = “”.
  4. Para cada caractere c na frase faça:
    a) Criar uma variável achou = falso.
    b) Percorrer cada posição i de 0 até comprimento de minusculas - 1 com um laço interno:
    • Se minusculas[i] == c então:
      • concatenar maiusculas[i] ao resultado
      • definir achou = verdadeiro
      • quebrar o laço interno (já converti esse caractere)
        c) Se, depois do laço interno, achou ainda for falso, concatenar c ao resultado (porque não era letra minúscula da tabela).
  5. Ao final do laço externo, exibir resultado na tela.
Explicando operações importantes:
  • “Concatenar” significa adicionar um caractere ao final da string resultado.
  • O laço interno faz a busca da posição da letra minúscula correspondente, sem usar funções prontas de busca. É um pequeno laço de comparação que verifica uma a uma.
  • O laço externo garante que a repetição exigida pelo enunciado está sendo usada (percorrer caractere a caractere).

Passo 5

Exemplo prático (passo a passo com uma frase de exemplo):
  • Suponha a entrada (dito pelo usuário): Oi, tudo bem?
    frase = “Oi, tudo bem?”
  • Percorrendo caractere a caractere:
    • ‘O’ → não está em minusculas → resultado += ‘O’ (fica “O”)
    • ‘i’ → está em minusculas na posição 8 (considerando ‘a’ pos 0) → maiusculas[8] = ‘I’ → resultado += ‘I’ (fica “OI”)
    • ‘,’ → não está em minusculas → resultado += ‘,’ (fica “OI,”)
    • ’ ’ → espaço → resultado += ’ ’ (fica "OI, ")
    • ‘t’ → está em minusculas → vira ‘T’ → resultado += ‘T’ (fica “OI, T”)
    • ‘u’ → vira ‘U’ → …
    • ‘d’ → vira ‘D’
    • ‘o’ → vira ‘O’
    • ’ ’ → mantém
    • ‘b’ → vira ‘B’
    • ‘e’ → vira ‘E’
    • ‘m’ → vira ‘M’
    • ‘?’ → mantém
  • Resultado final exibido: “OI, TUDO BEM?”

Passo 6

Complexidade e observações finais:
  • O algoritmo usa dois laços aninhados no pior caso: para cada caractere da frase (n), eu posso fazer uma busca linear em minusculas (até 26 comparações). Isso é O(26·n) que, como 26 é constante, é linear em n, ou seja O(n). Na prática é bem rápido para frases.
  • Usei exatamente uma função pronta (a de leitura da entrada). Todo o resto é feito com laços e comparações manuais, conforme pedido.
  • Para suportar letras acentuadas adicione os pares minúscula/maiúscula correspondentes nas strings minusculas e maiusculas.

Resposta

Algoritmo para ler uma frase, converter para maiúsculas usando repetição e no máximo uma função pronta:
LerFrase() := função pronta que retorna a linha lida do teclado
Algoritmo ConverterParaMaiusculas:
  1. frase ← LerFrase()
  2. minusculas ← “abcdefghijklmnopqrstuvwxyz”
  3. maiusculas ← “ABCDEFGHIJKLMNOPQRSTUVWXYZ”
  4. resultado ← “” // string vazia
  5. para cada caractere c em frase faça
    5.1) achou ← falso
    5.2) i ← 0
    5.3) enquanto i < comprimento_de(minusculas) e achou = falso faça
    5.3.1) se minusculas[i] = c então
    resultado ← resultado concatenado com maiusculas[i]
    achou ← verdadeiro
    senão
    i ← i + 1
    5.4) se achou = falso então
    resultado ← resultado concatenado com c
  6. exibir(resultado)

Exercícios relacionados