Desenvolva um programa que leia uma string com até 250 caracteres e imprima na tela essa string na ordem invertida. Exemplo: usuário digitou ABRACADABRA , seu programa deve imprimir na tela ARBADACARBA.

Passo 1

O enunciado pede que eu desenvolva um programa que leia uma string (texto) com até 250 caracteres e imprima essa mesma string na ordem invertida. Exemplo dado: usuário digitou ABRACADABRA e o programa deve imprimir ARBADACARBA.
Informações importantes que o enunciado fornece:
  • A entrada é uma string com até 250 caracteres.
  • O programa deve imprimir a string invertida (ou seja, último caractere primeiro, até o primeiro caractere por último).
  • Deve lidar com espaços e qualquer caractere que possa aparecer na string (letras, números, símbolos).
  • Exemplo: entrada ABRACADABRA → saída ARBADACARBA.

Passo 2

Decisão do método: o enunciado não exige uma linguagem ou método específico. Vou usar um método simples e clássico que funciona em provas e implementá-lo em C (linguagem comum em disciplinas de exatas). O método escolhido é o de percorrer a string do final para o início e imprimir caractere por caractere. Isso não usa bibliotecas complexas nem funções avançadas, é rápido de escrever e fácil de explicar na prova.

Passo 3

Entendendo como strings funcionam em C (a teoria que você precisa):
  • Em C, uma string é um vetor de caracteres terminado por um caractere nulo '\0'. Se eu tenho um vetor char s[251];, isso permite armazenar até 250 caracteres úteis mais o '\0'.
  • A função fgets lê uma linha e coloca um '\n' final se houver espaço — normalmente preciso remover esse '\n' antes de processar a string.
  • A função strlen(s) retorna o comprimento da string contado até o '\0', sem incluir o '\0'.
  • Índices: os caracteres estão em posições de índice 0 até n-1, onde n é o comprimento. O último caractere válido está em índice n-1.
  • Para inverter, vou percorrer índices de n-1 até 0 (decrescendo) e imprimir s[i].

Passo 4

Algoritmo passo a passo (metodologia que você pode aplicar na prova):
  1. Reserve um vetor s com espaço para 250 caracteres mais o '\0', ou seja tamanho 251.
  2. Leia a linha com fgets(s, 251, stdin).
  3. Calcule n = comprimento da string usando strlen(s).
  4. Se o último caractere for '\n', substitua por '\0' e faça n = n - 1.
  5. Use um laço que vai de i = n-1 até i = 0 (inclusive) e em cada iteração imprima s[i].
  6. Opcional: imprima um '\n' no final para terminar a linha.
Observação sobre índices e tipos:
  • Em C, strlen retorna size_t. Para usar em laços decrescentes com índices inteiros, é comum copiar para uma variável inteira segura ou usar int/long conforme o ambiente. Aqui vou usar size_t para n e fazer o laço com um índice int convertido, tomando cuidado com casos em que n=0.

Passo 5

Complexidade e comportamento em casos extremos:
  • Complexidade temporal: O(n), onde n é o comprimento da string, porque visitamos cada caractere uma vez.
  • Complexidade espacial: O(1) extra além do vetor que armazena a string.
  • Casos extremos:
    • String vazia: n=0, o laço de impressão não imprime nada (apenas aplicar o '\n' no final, se desejar).
    • String com espaços: fgets lê espaços, então são preservados e invertidos normalmente.
    • String com exatamente 250 caracteres: o vetor char s[251] suporta isso (mais o '\0').

Passo 6

Cuidados práticos para não errar na prova:
  • Sempre dimensione o vetor com mais uma posição para o terminador '\0': para limite 250 use 251.
  • Lembre-se de remover o '\n' que fgets pode deixar, caso contrário o '\n' será considerado caractere e aparecerá no início da saída invertida.
  • Ao usar índices decrescentes, evite ultrapassar índices negativos — use um int para o índice do laço quando for decrementar até zero.
  • Teste com exemplos simples: string vazia, um caractere, e o exemplo do enunciado.

Passo 7

Código em C (implementação direta seguindo o algoritmo explicado). Abaixo explico linha a linha depois do código.

Passo 8

Explicação linha a linha do código (cada variável mencionada em TeX):
  • char s[251]; reserva espaço para até 250 caracteres mais '\0'.
  • if (!fgets(s, sizeof s, stdin)) return 0; lê uma linha da entrada padrão; se não conseguir ler (EOF), termina o programa.
  • size_t n = strlen(s); calcula n, o comprimento da string lida (sem contar o '\0').
  • if (n > 0 && s[n-1] == '\n') { s[n-1] = '\0'; n--; } verifica se o último caractere é '\n' e, se for, remove-o e atualiza n para n-1.
  • for (int i = (int)n - 1; i >= 0; i--) putchar(s[i]); faz o laço de i = n-1 até 0 imprimindo s[i] (cada caractere invertido).
  • putchar('\n'); imprime nova linha no final (estética).
  • return 0; finaliza o main com sucesso.

Passo 9

Exemplo prático usando o exemplo do enunciado:
  • Entrada: ABRACADABRA
  • Leitura: s = "ABRACADABRA", n = 11.
  • Laço imprime indices 10,9,\dots,0 correspondendo aos caracteres A R B A D A C A R B A.
  • Saída: ARBADACARBA (seguido de \n).

Passo 10

Últimas dicas e motivação: respira fundo — esse problema é padrão e a estratégia “achar comprimento e imprimir do final pro início” é direto. Decore mentalmente os passos: alocar + ler + remover \n + descobrir n + laço decrescente. Isso resolve quase qualquer exercício de inversão em prova. Você consegue!

Resposta

#include <stdio.h>
#include <string.h>
int main(void) {
char s[251];
if (!fgets(s, sizeof s, stdin)) return 0;
size_t n = strlen(s);
if (n > 0 && s[n-1] == ‘\n’) { s[n-1] = ‘\0’; n–; }
for (int i = (int)n - 1; i >= 0; i–) putchar(s[i]);
putchar(’\n’);
return 0;
}

Exercícios relacionados