Distância e Números Complexos
Leia quatro valores correspondentes aos eixos x e y de dois pontos quaisquer no plano: ( x 1 , y 1 ) e (x 2 , y 2)
e calcule a distância entre eles, mostrando 4 casas decimais após a vírgula, segundo a fórmula:
((\mathrm{x} 2-\mathrm{x} 1) 2+(\mathrm{y} 2-\mathrm{y} 1) 2) 1 / 2
Leia também um número complexo \mathrm{z}=\mathrm{a}+\mathrm{bj} e calcule seu módulo |\mathrm{z}| (distância até a origem), mostrando 4 casas decimais após a vírgula, usando a fórmula:
|\mathrm{z}|=((\mathrm{a} 2+\mathrm{b} 2)) 1 / 2
Note que Python possui complex como tipo de dados. Um número complexo tem um componente real e um componente imaginário, ambos representados pelo tipo float em Python (é possível acessá-los separadamente).

Entrada:

A entrada contém três linhas de dados. A primeira linha contém dois valores de ponto flutuante x1 e y1, a segunda também contém dois valores de ponto flutuante x2 e y2 e a terceira contém um número complexo no formato \mathrm{a}+\mathrm{bj}.
Saída:
Calcule e imprima o valor da distância e do módulo segundo as fórmulas fornecidas, com 4 casas decimais.
Comentários:
Para ler vários valores em uma mesma linha, use input().split(). Se o argumento de split for vazio, o separador das variáveis é um espaço em branco. Porém, lembre-se que input lê apenas strings do teclado, portanto você deverá converter as strings em floats.
No exemplo a seguir, o usuário digita valores separados por um espaço em branco e aperta enter para enviá-los, então, o programa lê esses valores separados por espaços como strings (na ordem em que aparecem), guardados nas variáveis correspondentes. Em seguida, o programa os converte para floats:
A, B, C = input().split()
A, B, C = [float(A), float(B), float(C)]
Números complexos podem ser manipulados facilmente com o método complex(). Exemplo:
D = complex(’ 2+3 \mathrm{j} ‘)
print(’%.2f % D.real)
print(’%.2f’ % D.imag)
Dica:
O módulo math pode ser usado para calcular a raiz quadrada com a função math.sqrt(A). Neste caso, a biblioteca precisa ser importada antes: import math.
Existe um operador “**” em Python que faz a exponenciação. Exemplo: A ** B = AB
Por exemplo:
Input Resultado
1.07 .0 4.4721
5.09 .0 2.0000
2 j
-2.50 .4 16.1484
12.17 .3 2.2361
1+2 \mathrm{j}

Passo 1

O enunciado pede duas coisas a partir de uma entrada com três linhas:
  • Ler dois pontos no plano: o primeiro ponto com coordenadas x_1 e y_1 (primeira linha) e o segundo ponto com coordenadas x_2 e y_2 (segunda linha).
  • Ler um número complexo z no formato a+bj (terceira linha).
As saídas pedidas são:
  • A distância entre os pontos (x_1,y_1) e (x_2,y_2), calculada e impressa com 4 casas decimais.
  • O módulo do número complexo z=a+bj, ou seja, |z|, calculado e impresso com 4 casas decimais.
Informações relevantes dadas pelo enunciado:
  • A fórmula da distância é \sqrt{(x_2-x_1)^2 + (y_2-y_1)^2}.
  • A fórmula do módulo do complexo é |z| = \sqrt{a^2 + b^2}.
  • A entrada vem em três linhas: primeira com x_1 e y_1, segunda com x_2 e y_2, terceira com o complexo (ex.: \texttt{1+2j} ou \texttt{2j}).
  • A saída deve mostrar os dois valores com 4 casas decimais, cada um em sua linha.

Passo 2

Entendendo a fórmula da distância: ela vem do Teorema de Pitágoras. Se você desloca do ponto (x_1,y_1) ao ponto (x_2,y_2), os deslocamentos nas direções x e y são
\Delta x = x_2 - x_1,\qquad \Delta y = y_2 - y_1.
A distância é a hipotenusa do triângulo retângulo formado por esses deslocamentos, portanto
\text{dist} = \sqrt{(\Delta x)^2 + (\Delta y)^2} = \sqrt{(x_2-x_1)^2 + (y_2-y_1)^2}.
No Python isso pode ser calculado com \texttt{(dx**2 + dy**2)**0.5} ou usando \texttt{math.sqrt(dx**2 + dy**2)}. Aqui:
  • \Delta x e \Delta y são variáveis do tipo float,
  • o operador \texttt{**} faz potência (por exemplo, \texttt{dx**2} é \Delta x^2).

Passo 3

Entendendo o módulo do número complexo: um número complexo z escrito como a+bj tem parte real a e parte imaginária b. O módulo é a distância de z até a origem no plano complexo, dada por
|z| = \sqrt{a^2 + b^2}.
No Python existe o tipo \texttt{complex}. Se você faz \texttt{w = complex("1+2j")}, então \texttt{w.real} é a e \texttt{w.imag} é b. Assim, o módulo pode ser calculado como \texttt{(w.real**2 + w.imag**2)**0.5}. Observação: Python também permite \texttt{abs(w)} diretamente para o módulo, que já retorna um float com |z|.

Passo 4

Como ler a entrada em Python (detalhado e sem pular etapas):
  • Primeira linha: use \texttt{input().split()} para separar os dois valores e converta para float: \texttt{x1\_str, y1\_str = input().split()} \\\ \texttt{x1 = float(x1\_str); y1 = float(y1\_str)}ou mais compacto: \texttt{x1, y1 = map(float, input().split())}.
  • Segunda linha: igual para x_2, y_2.
  • Terceira linha: leia a string do complexo e use \texttt{complex()}, por exemplo: \texttt{z = complex(input().strip())} \texttt{complex()} aceita formatos como \texttt{"1+2j"}, \texttt{"2j"}, \texttt{"-3-4j"}, etc. A função \texttt{strip()} remove espaços em branco no início/fim, caso existam.

Passo 5

Como formatar a saída com 4 casas decimais:
  • Em Python têm-se várias opções. Duas comuns:
    • \texttt{print("{:.4f}".format(valor))}
    • \texttt{print(f"{valor:.4f}")}
  • Cada valor pedido deve aparecer em sua própria linha, no formato com exatamente 4 casas decimais.

Passo 6

Exemplo numérico pequeno e verificável (para fixar a ideia). Suponha:
  • Primeira linha: \texttt{0 0} (ou seja, x_1=0, y_1=0),
  • Segunda linha: \texttt{3 4} (ou seja, x_2=3, y_2=4),
  • Terceira linha: \texttt{1+1j} (ou seja, a=1, b=1).
Cálculo passo a passo:
  • \Delta x = 3 - 0 = 3,
  • \Delta y = 4 - 0 = 4,
  • \text{dist} = \sqrt{3^2 + 4^2} = \sqrt{9 + 16} = \sqrt{25} = 5.0000.
  • Para o complexo: |z| = \sqrt{1^2 + 1^2} = \sqrt{2} \approx 1{,}4142.
Saída esperada para esse exemplo:
  • Primeira linha: \texttt{5.0000}
  • Segunda linha: \texttt{1.4142}

Passo 7

Resumo do algoritmo final (em palavras, pronto para implementar):
  1. Ler x_1,y_1 como floats da primeira linha.
  2. Ler x_2,y_2 como floats da segunda linha.
  3. Ler o complexo z com \texttt{complex()} da terceira linha.
  4. Calcular \Delta x = x_2-x_1 e \Delta y = y_2-y_1.
  5. Calcular \text{dist} = \sqrt{(\Delta x)^2 + (\Delta y)^2}.
  6. Calcular |z| = \sqrt{(\operatorname{Re} z)^2 + (\operatorname{Im} z)^2} (ou usar \texttt{abs(z)}).
  7. Imprimir \text{dist} e |z| com 4 casas decimais, uma por linha.

Resposta

# Programa que lê dois pontos e um número complexo, calcula a distância e o módulo
import sys

# Leitura e conversão das duas primeiras linhas
x1, y1 = map(float, input().split())
x2, y2 = map(float, input().split())

# Leitura do número complexo (ex.: "1+2j" ou "2j")
z = complex(input().strip())

# Cálculo da distância entre (x1,y1) e (x2,y2)
dx = x2 - x1
dy = y2 - y1
dist = (dx**2 + dy**2)**0.5

# Cálculo do módulo do complexo z
mod_z = abs(z)

# Impressão com 4 casas decimais
print("{:.4f}".format(dist))
print("{:.4f}".format(mod_z))

Exercícios relacionados