6 s. Questão: Crie uma função que receba uma data no formato “dd/mm/aaaa” correspondente ao vencimento de um boleto e informe se ele está vencido ou ainda dentro do prazo. Considere a data atual como 22/04/2026.

Passo 1

O enunciado pede que eu crie uma função que receba uma data no formato “dd/mm/aaaa” (string) que representa o vencimento de um boleto e informe se ele está vencido ou ainda dentro do prazo. A data “atual” a ser usada é fixeda: 22/04/2026.
Informações importantes fornecidas:
  • Entrada: uma string no formato “dd/mm/aaaa”.
  • Saída esperada: indicação se o boleto está “vencido” ou “dentro do prazo”.
  • Data atual (para comparação): dia = 22, mês = 04, ano = 2026.
  • Deve-se tratar possíveis datas inválidas (formato errado, dia/mes/ano impossíveis).

Passo 2

Definição clara do que a função deve fazer, passo a passo lógico:
  1. Validar o formato da string (deve haver exatamente dois caracteres ‘/’ separando três partes).
  2. Verificar se cada parte contém apenas dígitos e converter para inteiros: dia, mês, ano.
  3. Verificar se o ano, mês e dia formam uma data válida (ex.: mês entre 1 e 12; dia entre 1 e número de dias daquele mês).
  4. Comparar a data do vencimento com a data atual (22/04/2026) e decidir:
    • Se vencimento < data atual → “Vencido”.
    • Se vencimento >= data atual → “Dentro do prazo”.
  5. Em caso de formato/data inválida → informar erro (por exemplo, “Data inválida”).
Observação importante de interpretação: quando a data de vencimento é exatamente igual à data atual ( 22/04/2026), considero que ainda está dentro do prazo (não é vencido).

Passo 3

Como fazer a validação do formato e a conversão de string para números (explicando bem devagar):
  • Primeiro usar o método de divisão da string por “/” (em pseudocódigo: partes = data_str.split(’/’) ).
  • Verificar que o comprimento de partes é três.
  • Remover espaços em branco com strip e checar que cada parte contém só dígitos (método isdigit() em muitas linguagens).
  • Converter cada parte para inteiro: dia = int(partes[0]), mês = int(partes[1]), ano = int(partes[2]).
    Exemplo concreto:
  • Entrada “05/09/2026” → partes = [“05”, “09”, “2026”] → dia = 5, mês = 9, ano = 2026.
  • Entrada “5/9/2026” também é aceitável com a mesma lógica.

Passo 4

Como verificar se o ano, mês e dia formam uma data válida — conceito de dias por mês e ano bissexto:
  • Meses com dias fixos: janeiro(1)=31, fevereiro(2)=28 ou 29, março(3)=31, abril(4)=30, maio(5)=31, junho(6)=30, julho(7)=31, agosto(8)=31, setembro(9)=30, outubro(10)=31, novembro(11)=30, dezembro(12)=31.
  • Fevereiro tem 29 dias somente em anos bissextos. Regra de ano bissexto:
    • Um ano é bissexto se for divisível por 400, ou se for divisível por 4 e não for divisível por 100.
    • Em linguagem simples: "ano % 400 == 0" ou ("ano % 4 == 0" e "ano % 100 != 0").
      Exemplos:
  • 2024 é bissexto ( 2024\%4==0 e 2024\%100!=0) → fevereiro tem 29 dias.
  • 2100 não é bissexto (divisível por 100 mas não por 400) → fevereiro tem 28 dias.
Validação concreta:
  • Verificar 1 \le mês \le 12.
  • Calcular dias_no_mes de acordo com o mês e se o ano é bissexto.
  • Verificar 1 \le dia \le dias_no_mes.
  • Verificar ano razoável (por exemplo ano >= 1). Para este exercício usar ano positivo.

Passo 5

Como comparar duas datas sem usar bibliotecas prontas (ideia simples e infalível):
  • Representar cada data como uma tupla ordenável: (ano, mês, dia)ê.
  • Comparação lexicográfica funciona porque ano tem peso maior que mês e mês maior que dia.
  • Portanto:
    • se (ano_venc, mes_venc, dia_venc) < (ano_atual, mes_atual, dia_atual) então vencido;
    • caso contrário (igual ou maior) está dentro do prazo.
      Exemplo:
  • Vencimento (2026,4,21) < Atual (2026,4,22) → vencido.
  • Vencimento (2026,4,22) == Atual (2026,4,22) → dentro do prazo.
  • Vencimento (2026,5,1) > Atual → dentro do prazo.

Passo 6

Decisão sobre método de implementação: duas opções possíveis
  • Usar biblioteca de datas (em Python: datetime) — código curto e robusto.
  • Implementar validação e comparação manualmente usando inteiros — mais didático e independente de bibliotecas, fácil de entender na prova.
    Escolhi aqui implementar manualmente (validação + comparação por tuplas) porque é o método mais fundamental e você consegue reproduzir “na caneta” durante uma prova sem depender de API.

Passo 7

Tratamento dos casos de erro e mensagens:
  • Se a string não tem o formato correto ou se os valores não formam uma data válida, a função deve retornar uma indicação clara: por exemplo “Data inválida”.
  • Retorno final deve ser uma das três possibilidades: “Vencido”, “Dentro do prazo” ou “Data inválida”.
  • Mantendo retorno textual facilita leitura direta.

Passo 8

Exemplos de entrada e resultados esperados (para fixar):
  • “21/04/2026” → (2026,4,21) < (2026,4,22) → “Vencido”.
  • “22/04/2026” → igual → “Dentro do prazo”.
  • “23/04/2026” → futuro → “Dentro do prazo”.
  • “29/02/2024” → válido (2024 é bissexto) → comparar normalmente.
  • “29/02/2025” → inválido (2025 não é bissexto) → “Data inválida”.
  • “31/04/2026” → abril tem 30 dias → “Data inválida”.
  • “aa/bb/cccc” → formato inválido → “Data inválida”.

Passo 9

Estratégia final implementada (resumo antes do código):
  • Receber string, dividir por “/”, verificar número de partes.
  • Checar se as partes têm só dígitos, converter para inteiros.
  • Calcular se o ano é bissexto e o número certo de dias no mês.
  • Verificar validade do dia/mês/ano.
  • Comparar tuplas (ano, mês, dia)ê com a tupla fixa (2026,4,22).
  • Retornar “Vencido”, “Dentro do prazo” ou “Data inválida”.

Resposta

def verificar_vencimento(data_str):
    """
    Recebe uma data no formato "dd/mm/aaaa" e retorna:
      - "Vencido"             se a data de vencimento for anterior a 22/04/2026
      - "Dentro do prazo"     se a data for igual ou posterior a 22/04/2026
      - "Data inválida"       se o formato ou valores não formarem uma data válida
    """
    # Data atual fixa para comparação
    ano_atual, mes_atual, dia_atual = 2026, 4, 22

    # 1) Validar formato básico
    partes = data_str.split('/')
    if len(partes) != 3:
        return "Data inválida"
    d_s, m_s, y_s = [p.strip() for p in partes]
    if not (d_s.isdigit() and m_s.isdigit() and y_s.isdigit()):
        return "Data inválida"

    # 2) Converter para inteiros
    dia = int(d_s)
    mes = int(m_s)
    ano = int(y_s)

    # 3) Validar ano e mês
    if ano < 1 or mes < 1 or mes > 12:
        return "Data inválida"

    # 4) Função ano bissexto e dias no mês
    def eh_bissexto(a):
        return (a % 400 == 0) or (a % 4 == 0 and a % 100 != 0)

    dias_no_mes = [0, 31, 29 if eh_bissexto(ano) else 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

    # 5) Validar dia
    if dia < 1 or dia > dias_no_mes[mes]:
        return "Data inválida"

    # 6) Comparar datas por tupla (ano, mes, dia)
    vencimento = (ano, mes, dia)
    atual = (ano_atual, mes_atual, dia_atual)
    if vencimento < atual:
        return "Vencido"
    else:
        return "Dentro do prazo"

Exercícios relacionados