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

Passo 1

O enunciado pede para implementar a função is_palindrome(word) de forma iterativa, usando while.
Informações dadas:
  • Temos uma função chamada is_palindrome que recebe um parâmetro word (uma string).
  • O objetivo é retornar um valor booleano que indique se word é um palíndromo (ou seja, se a string lê-se igual da esquerda para a direita e da direita para a esquerda).
  • A implementação deve ser feita de forma iterativa, obrigatoriamente com uso de while.

Passo 2

O que é um palíndromo?
  • Uma palavra é palíndroma se, ao ler de frente ou de trás, os caracteres aparecem na mesma ordem. Exemplos: "radar", "level". Não é palíndromo: "hello".
  • Formalmente, para uma string word com comprimento \,n=\text{len}(word)\,, ela é palíndroma se para todo índice \,k com 0 \le k < n vale \,word[k] = word[n-1-k].

Passo 3

Estratégia escolhida (método): dois ponteiros (dois índices).
  • Vamos usar dois índices: \,i\, começando em 0 (início da string) e \,j\, começando em \text{len}(word)-1 (final da string).
  • Enquanto \,i < j\, comparamos os caracteres word[i] e word[j]. Se algum par diferir, a palavra não é palíndroma e retornamos False. Se conseguirmos avançar até que os índices se cruzem sem achar diferença, retornamos True.
    Esse método é simples, eficiente e combina bem com um while.

Passo 4

Revisão rápida do while (como funciona em Python) para garantir que você entenda a construção:
  • Sintaxe básica:
    while condição:
        bloco_de_código
    
  • O bloco é repetido enquanto condição for verdadeira. Aqui usaremos while i < j: para avançar os ponteiros até se encontrarem ou cruzarem.
  • Precisamos garantir que dentro do laço os ponteiros mudem (i += 1 e j -= 1) para que o laço não seja infinito.

Passo 5

Construção passo a passo do algoritmo (linha a linha), explicando o porquê de cada coisa:
  1. Inicializar \,i = 0 e \,j = \text{len}(word) - 1.
    • \,i aponta para o primeiro caractere; \,j para o último.
  2. Iniciar o laço while i < j:.
    • Enquanto houver pares a comparar (ou seja, enquanto não cruzamos), continuamos.
  3. Dentro do laço, comparar word[i] com word[j].
    • Se word[i] != word[j], já sabemos que não é palíndromo => return False.
  4. Se forem iguais, avançar os ponteiros: i += 1 e j -= 1 e repetir.
    • Assim comparamos o próximo par.
  5. Se o laço terminar sem encontrar diferença, retornamos True.
    • Isso significa que todos os pares simétricos coincidiram.
Observação didática: strings em Python são indexáveis (ex.: word[0], word[1], etc.) e o operador != compara caracteres. A função len(word) dá o comprimento da string. Tudo isso é suficiente para implementar o algoritmo sem alterar a string.

Passo 6

Complexidade e justificativa rápida (importante para prova):
  • Seja \,n=\text{len}(word)\,. O laço compara no máximo \lceil n/2\rceil pares, então a complexidade de tempo é O(n).
  • A complexidade de espaço é O(1) porque usamos apenas duas variáveis extras ( \,i e \,j).

Passo 7

Exemplos passo a passo (simulação mental) para fixar:
  • Exemplo 1: word = "radar":
    • \,i=0, \,j=4: comparar r e r → iguais → \,i=1, \,j=3.
    • \,i=1, \,j=3: comparar a e a → iguais → \,i=2, \,j=2.
    • Agora \,i \not< j (iguais), laço termina → retorna True.
  • Exemplo 2: word = "hello":
    • \,i=0, \,j=4: comparar h e o → diferentes → retorna False imediatamente.
Dica prática para a prova: escreva o algoritmo em poucas linhas com essa ideia de dois ponteiros; é rápido de justificar e fácil de codar.

Passo 8

Implementação em Python (iterativa, usando while). Esta implementação é direta e segue exatamente os passos anteriores:
def is_palindrome(word):
    """
    Retorna True se 'word' for um palíndromo, False caso contrário.
    Implementação iterativa usando while e dois ponteiros.
    """
    i = 0
    j = len(word) - 1

    while i < j:
        if word[i] != word[j]:
            return False
        i += 1
        j -= 1

    return True

Passo 9

Observações finais e variações que podem aparecer na prova (lembre-se disso):
  • Se a questão pedir para ignorar maiúsculas/minúsculas, normalize antes com word = word.lower().
  • Se pedir para ignorar espaços e pontuação (ex.: frases como “A man, a plan, a canal: Panama”), filtre apenas os caracteres alfanuméricos antes da verificação, por exemplo com ''.join(ch.lower() for ch in word if ch.isalnum()).
  • Mas se o enunciado não mencionar normalização, use a verificação direta da string (como fizemos), que é a forma mais simples pedida.

Resposta

def is_palindrome(word):
    """
    Retorna True se 'word' for um palíndromo, False caso contrário.
    Implementação iterativa usando while e dois ponteiros.
    """
    i = 0
    j = len(word) - 1

    while i < j:
        if word[i] != word[j]:
            return False
        i += 1
        j -= 1

    return True

Exercícios relacionados