Entrar com uma frase, armazenando em um vetor de caracteres (aceitando espaços como caracteres). Depois, verifique se há a letra ‘a’ no vetor, e para cada ocorrência, substitua por ‘A’ maiúsculo. No fim, mostre a frase já atualizada com as devidas modificações.

Passo 1

O que o enunciado pede (em linguagem simples):
  • Ler uma frase inteira (aceitando espaços) e armazenar em um vetor de caracteres.
  • Verificar se existe a letra ‘a’ nessa frase.
  • Para cada ocorrência de ‘a’, substituir por ‘A’ (maiúsculo).
  • No final, mostrar a frase já modificada.
Informações relevantes que recebemos:
  • A entrada é uma linha de texto (pode ter espaços).
  • A operação é feita caractere a caractere no vetor.
  • A saída é a mesma frase, com todas as letras ‘a’ trocadas por ‘A’.

Passo 2

Escolha do método e visão geral (sem detalhes de código ainda):
  • Vamos usar um vetor de caracteres (string em C) e percorrê-lo com um índice i do início até o fim da string.
  • Para aceitar espaços ao ler a frase podemos usar uma função que leia uma linha inteira (por exemplo, fgets em C).
  • Precisamos lembrar que strings em C terminam com um caractere nulo '\0'. É importante tratar o '\n' que fgets pode deixar no final.
  • A cada posição i do vetor, verificamos se o caractere é 'a'. Se for, atribuímos 'A' naquela posição.
  • Por fim, imprimimos a string resultante.
Motivo da escolha: esse é o método mais direto e explicado passo a passo, fácil de aplicar na prova sem dependências complicadas.

Passo 3

Conceitos necessários (explicados com calma)
  • Vetor de caracteres / string: em C, uma frase é um vetor de char onde os caracteres são armazenados em sequência, e o último elemento é '\0' (o terminador nulo) que indica o fim da string. Vou chamar o vetor de s.
  • Índices: cada posição do vetor tem um índice i (começando em 0). Para percorrer a string, usamos um laço que aumenta i até encontrarmos o terminador ou até conhecermos o tamanho.
  • Tamanho da string: podemos obter o comprimento com strlen(s) (que conta até '\0'), ou percorrer até '\0'.
  • Leitura de linha com espaços: fgets(s, tamanho, stdin) lê até um máximo de tamanho-1 caracteres e inclui espaços; se houver fim de linha, fgets deixa um '\n' antes do '\0', então costumamos removê-lo.
  • Comparação e substituição: comparar um caractere é simples (s[i] == 'a'), e a substituição também (s[i] = 'A').
  • ASCII/charset: comparar 'a' com 'A' é sensível a maiúscula/minúscula; somente 'a' (minúscula) será substituída.

Passo 4

Rascunho do algoritmo passo a passo (em pseudocódigo para fixar a ideia)
  1. Declarar um vetor de char grande o bastante, por exemplo s com tamanho 1000.
  2. Ler a linha com fgets(s, 1000, stdin).
  3. Remover o '\n' final, se existir.
  4. Calcular o comprimento len com strlen(s) (ou percorrer até '\0').
  5. Para i=0 até i < len:
    • Se s[i] == 'a' então s[i] = 'A'.
  6. Imprimir s.

Passo 5

Programa em C com comentários linha a linha (use este código na prova/compilador)
#include <stdio.h>
#include <string.h>

int main(void) {
    char s[1000];                    /* buffer para a frase */
    if (fgets(s, sizeof s, stdin) == NULL) return 0; /* lê a linha com espaços */

    /* remover o '\n' que fgets pode deixar */
    size_t len = strlen(s);
    if (len > 0 && s[len - 1] == '\n') {
        s[len - 1] = '\0';
        len--;                       /* atualizar o comprimento depois de remover '\n' */
    }

    /* percorrer cada caractere e substituir 'a' por 'A' */
    for (size_t i = 0; i < len; ++i) {
        if (s[i] == 'a') {
            s[i] = 'A';
        }
    }

    printf("%s\n", s);               /* imprime a frase modificada */
    return 0;
}
Explicações das partes importantes do código:
  • char s[1000]; cria um vetor s que pode armazenar frases de até 999 caracteres (mais o '\0').
  • fgets(s, sizeof s, stdin) lê até sizeof s - 1 caracteres e aceita espaços.
  • strlen(s) retorna o número de caracteres antes do '\0'.
  • A verificação if (len > 0 && s[len - 1] == '\n') detecta e remove o '\n' deixado pelo fgets.
  • O laço for usa o índice i (do tipo size_t) para acessar cada posição; s[i] == 'a' faz a verificação exata de minúscula.
  • printf("%s\n", s); exibe a frase resultante.

Passo 6

Exemplo de execução (passo a passo com uma frase de exemplo)
  • Entrada (usuário digita): Olá, casa minha
  • Buffer s depois do fgets (supondo que o usuário apertou Enter): "Olá, casa minha\n\0"
  • Ao remover '\n', s vira "Olá, casa minha\0" e len corresponde ao número de caracteres visíveis.
  • O laço percorre cada posição; encontra s[5] == 'c' (não altera), encontra s[6] == 'a' -> substitui por 'A', etc.
  • Resultado final impresso: Olá, cAsA minhA
Observação: acentos (como em á) ocupam mais de um byte em algumas codificações (UTF-8) — o código acima trata caractere por byte; para frases em ASCII ou onde cada caractere acentuado é tratado como um símbolo único por byte, funciona bem na maioria dos exercícios introdutórios. Em ambientes que usam UTF-8 e onde se precisa alterar letras acentuadas específicas, a manipulação por bytes fica mais complexa.

Passo 7

Alternativa curta em Python (se a sua prova permitir outra linguagem — só para insight)
  • Em Python a mesma ideia fica bem curta:
s = input()
s = s.replace('a', 'A')
print(s)
Explicação: input() lê a linha inteira; str.replace substitui todas as ocorrências de 'a' por 'A'.

Passo 8

Dicas para a prova e possíveis pegadinhas
  • Lembre de usar uma função que aceite espaços (em C, não usar scanf("%s", ...) porque para por no primeiro espaço).
  • Não esqueça de remover o '\n' após fgets se for calcular strlen ou for sensível a esse caractere.
  • Comparação de caractere é case-sensitive: 'a' é diferente de 'A'.
  • Se for pedir para substituir também 'á' por 'Á' (acentos), confirme o que se espera — pode ser necessário tratamento especial.
  • Teste com frase vazia e com frases sem 'a' para garantir que o programa não muda nada e não dá erro.

Resposta

#include <stdio.h>
#include <string.h>
int main(void) {
char s[1000];
if (fgets(s, sizeof s, stdin) == NULL) return 0;
size_t len = strlen(s);
if (len > 0 && s[len - 1] == '\n') {
    s[len - 1] = '\0';
    len--;
}

for (size_t i = 0; i < len; ++i) {
    if (s[i] == 'a') {
        s[i] = 'A';
    }
}

printf("%s\n", s);
return 0;
}

Exercícios relacionados