(0.5) Elabore um programa em Python para encontrar um número inteiro que mais se aproxima da raiz quadrada de um número fornecido pelo usuário.

Passo 1

O enunciado pede: escrever um programa em Python que, dado um número fornecido pelo usuário, encontre um número inteiro que mais se aproxima da raiz quadrada desse número.
Informações relevantes fornecidas (explicitadas):
  • O usuário fornece um número (vamos chamar de x).
  • Queremos encontrar um número inteiro que seja o mais próximo possível de \sqrt{x}.
  • Saída esperada: um número inteiro (por exemplo, para x=10 a raiz quadrada é aproximadamente 3,162, então a saída deve ser 3 ou 4, dependendo de qual estiver mais perto).

Passo 2

Observações e casos especiais que precisamos considerar antes de codificar:
  • Se x<0 a raiz quadrada real não é definida. O programa precisa tratar esse caso (avisar o usuário ou interromper).
  • Se x=0 então \sqrt{x}=0 e o inteiro mais próximo é 0.
  • Se x for um quadrado perfeito (por exemplo x=9), então \sqrt{x} já é inteiro e devemos retornar esse inteiro.
  • Se \sqrt{x} estiver exatamente no meio entre dois inteiros (por exemplo \sqrt{x}=2,5), precisamos definir uma regra de desempate. Aqui vamos escolher, por simplicidade e previsibilidade, o inteiro menor (ou seja, o piso) em caso de empate.

Passo 3

Conceitos matemáticos necessários (explicados passo a passo):
  • A raiz quadrada de x é \sqrt{x}. Em programação usamos uma função como math.sqrt(x) para calcular \sqrt{x}.
  • O piso de um número s é \lfloor s\rfloor: o maior inteiro menor ou igual a s. Em Python usamos math.floor(s).
  • O teto de s é \lceil s\rceil: o menor inteiro maior ou igual a s. Em Python usamos math.ceil(s).
  • Para saber qual inteiro (entre \lfloor s\rfloor e \lceil s\rceil) é o mais próximo de s, comparamos as distâncias: d_{\text{low}} = s - \lfloor s\rfloor
d_{\text{high}} = \lceil s\rceil - s
Se d_{\text{low}} < d_{\text{high}} escolhemos \lfloor s\rfloor. Se d_{\text{low}} > d_{\text{high}} escolhemos \lceil s\rceil. Se forem iguais (empate), pela regra acima escolhemos \lfloor s\rfloor.
  • Observação sobre round() do Python: round(s) resolve arredondamentos, mas em Python o empate (quando a parte fracionária é exatamente 0,5) segue a regra “round to even” (arredonda para o inteiro par), o que pode ser inesperado. Por isso vamos fazer a comparação explícita para termos controle total sobre o desempate.

Passo 4

Algoritmo (em palavras simples):
  1. Ler a entrada do usuário e converter para número (p. ex. float). Chamar esse valor de x.
  2. Se x<0: avisar que a raiz real não está definida e terminar.
  3. Calcular s = \sqrt{x}.
  4. Calcular l = \lfloor s\rfloor e u = \lceil s\rceil.
  5. Calcular d_{\text{low}} = s - l e d_{\text{high}} = u - s.
  6. Se d_{\text{low}} \le d_{\text{high}} retornar l, senão retornar u.
    (Isto implementa a escolha do piso em caso de empate.)

Passo 5

Implementação em Python — linha a linha com explicação:
  • Vamos usar o módulo math para sqrt, floor e ceil.
  • Função principal nearest_int_sqrt(x): recebe x e devolve o inteiro mais próximo de \sqrt{x} ou lança erro/aviso se x<0.
  • Função main() faz a leitura do usuário, trata conversão, trata caso x<0 e imprime o resultado.
Exemplo do fluxo:
  • Usuário digita 10 s=\sqrt{10}\approx 3,162. Temos l=3, u=4. Distâncias: d_{\text{low}}\approx 0,162, d_{\text{high}}\approx 0,838. Como d_{\text{low}}<d_{\text{high}}, retornamos 3.
  • Usuário digita 2,25 s=\sqrt{2,25}=1,5. l=1, u=2. Distâncias iguais 0,5 e 0,5. Pelo desempate escolhemos l=1.

Passo 6

Código completo e comentado (vai ser repetido sem comentários no bloco final):
  • A explicação das linhas:
    • import math importa as funções matemáticas.
    • Em nearest_int_sqrt(x) verificamos x<0, calculamos s, l, u, calculamos as distâncias e retornamos conforme a comparação <= para escolher o piso em empate.
    • Em main() usamos input() para ler, float() para converter; tratamos exceção ValueError caso o usuário escreva algo inválido; tratamos x<0 com mensagem clara; por fim imprimimos o inteiro encontrado.

Passo 7

Testes rápidos (mostrando cálculos):
  • Para x=9: \sqrt{9}=3. Resultado: 3.
  • Para x=8: \sqrt{8}\approx 2,828. l=2, u=3. Distâncias 0,828 e 0,172. Resultado: 3.
  • Para x=2,25: \sqrt{2{,}25}=1{,}5. Distâncias iguais; pelo desempate retornamos 1.

Passo 8

Complexidade e observações finais:
  • A complexidade é O(1): apenas algumas operações aritméticas e chamadas a funções matemáticas.
  • Garantimos comportamento previsível em empates (escolhemos o menor inteiro). Se você preferir outro desempate (por exemplo arredondar para cima), basta trocar a condição <= por <.

Resposta

import math

def nearest_int_sqrt(x):
    """
    Retorna o inteiro que mais se aproxima de sqrt(x).
    Em caso de empate (por exemplo sqrt(x) = 2.5) retorna o piso (maior inteiro menor ou igual).
    Lança ValueError se x < 0.
    """
    if x < 0:
        raise ValueError("Número negativo: raiz quadrada real não definida.")
    s = math.sqrt(x)
    l = math.floor(s)
    u = math.ceil(s)
    d_low = s - l
    d_high = u - s
    if d_low <= d_high:
        return l
    else:
        return u

def main():
    try:
        entrada = input("Digite um número não-negativo: ").strip()
        x = float(entrada)
    except ValueError:
        print("Entrada inválida. Digite um número (ex: 10 ou 2.5).")
        return
    if x < 0:
        print("Número negativo. Raiz quadrada real não definida.")
        return
    resultado = nearest_int_sqrt(x)
    print(resultado)

if __name__ == "__main__":
    main()

Exercícios relacionados