1. Implemente a função is_palindrome (word) de forma iterativa, com uso de for.

Passo 1

O que o enunciado pede: implementar a função iterativa is_palindrome(word) usando for.
Informações dadas (implícitas no enunciado): a função recebe uma string word e deve retornar um valor booleano que indica se word é um palíndromo (ou seja, se a string lida da esquerda para a direita é igual à mesma string lida da direita para a esquerda). Não foi especificado tratamento de maiúsculas/minúsculas ou caracteres não alfanuméricos, então vamos implementar a versão mais direta: comparação exata dos caracteres na ordem dada.

Passo 2

Definição e ideia principal (explicação didática): um palíndromo é uma sequência que lê igual em ambos os sentidos. Para testar isso sem criar cópias auxiliares (como word[::-1]) podemos comparar pares de caracteres simétricos: o primeiro com o último, o segundo com o penúltimo, e assim por diante, até o meio da palavra. Se alguma dessas comparações falhar, a palavra não é palíndroma; se todas passarem, é palíndroma.
Seja n o tamanho da string (ou seja, n = \text{len(word)}). Precisamos comparar, para cada índice i começando em 0, o caractere em i com o caractere em n-1-i. Não é necessário ir além do meio, portanto i varia de 0 até \left\lfloor\frac{n}{2}\right\rfloor - 1.

Passo 3

Por que usar um for e qual é o critério de parada: usamos um for que percorre i em range(n // 2). A razão para n // 2 (divisão inteira) é que quando o comprimento é par precisamos comparar exatamente n/2 pares; quando é ímpar o caractere do meio não precisa ser comparado com nada (ex.: em “radar” o d no meio fica sozinho). Assim, o for percorre todos os pares necessários uma única vez.

Passo 4

Estrutura do algoritmo passo a passo (tradução em pseudo-raciocínio):
  • calcular n = \text{len(word)};
  • para cada i em 0, 1, 2, ..., n//2 - 1:
    • comparar word[i] com word[n - 1 - i];
    • se forem diferentes, retornar False imediatamente (podemos parar ali: já sabemos que não é palíndromo);
  • se o laço terminar sem encontrar diferenças, retornar True.

Passo 5

Explicando cada linha do código (vou mostrar o código em seguida e comentar linha a linha):
  • n = len(word) calcula o comprimento da string e guarda em n. Esse valor é usado para acessar o índice oposto n - 1 - i.
  • for i in range(n // 2): percorre os índices da metade esquerda da palavra. n // 2 é a divisão inteira de n por 2.
  • if word[i] != word[n - 1 - i]: compara o caractere atual com o correspondente do fim; se diferente, não é palíndromo.
  • return False sai da função imediatamente indicando que a palavra não é palíndroma.
  • return True (fora do laço) é executado apenas se todas as comparações foram iguais, indicando que a palavra é palíndroma.

Passo 6

Complexidade e observações práticas:
  • Tempo: a função faz no máximo \left\lfloor\frac{n}{2}\right\rfloor comparações, então a complexidade é O(n).
  • Espaço: uso de espaço constante O(1), já que não criamos cópias da string.
  • Observação sobre sensibilidade: esta versão faz comparação exata (case-sensitive). Se quiser ignorar maiúsculas/minúsculas ou caracteres que não sejam letras/dígitos, é preciso normalizar word antes (ex.: word = ''.join(c.lower() for c in word if c.isalnum())), mas isso cria uma cópia — a versão pedida foi a iterativa simples.

Passo 7

Exemplos rápidos para fixar (mentalmente):
  • is_palindrome("radar") deve retornar True (comparações: r↔r, a↔a).
  • is_palindrome("abba") deve retornar True (a↔a, b↔b).
  • is_palindrome("abc") deve retornar False (a↔c falha).
  • is_palindrome("") (string vazia) deve retornar True por convenção (não há pares diferentes).
  • is_palindrome("a") retorna True (somente um caractere).

Resposta

def is_palindrome(word):
    n = len(word)
    for i in range(n // 2):
        if word[i] != word[n - 1 - i]:
            return False
    return True

Exercícios relacionados