Problem:
Distance Write a program which calculates the distance between two points P1(x1, y1) and P2(x2, y2). Input Four real numbers x1, y1, x2 and y2 are given in a line. Output Print the distance in real number. The output should not contain an absolute error greater than 10 -4 . Sample Input 0 0 1 1 Sample Output 1.41421356

Solution (Python):
import math

x_1,y_1,x_2,y_2 = map(float,input().split())

d = math.sqrt((x_2 - x_1)**2 + (y_2 - y_1) ** 2)
print(d)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print("{:.8f}".format(((x1-x2)**2+(y1-y2)**2)**0.5))

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print(((x1 - x2)**2 + (y1 - y2)**2)**0.5)

Solution (Python):
import math
a,b,c,d = map(float, input().split())

print("{0:.8f}".format(math.sqrt(abs(a-c)**2 + abs(b-d)**2)))

Solution (Python):
a,b,c,d=map(float,input().split())
print(((c-a)**2+(d-b)**2)**(1/2))

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())

import math
print('%.5f'%(math.sqrt((x2-x1)**2 + (y2-y1)**2)))

Solution (Python):
def distance(A):
    return ((A[0]-A[2])**2+(A[1]-A[3])**2)**0.5

A=list(map(float,input().split()))
print(distance(A))

Solution (Python):
import math

x1, y1, x2, y2 = list(map(float, input().split()))

x = abs(x2 - x1)
y = abs(y2 - y1)

answer = math.sqrt(x ** 2 + y ** 2)

print("{:.8f}".format(answer))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
print(str(math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)))

Solution (Python):
import math
x1,y1,x2,y2 = list(map(float, input().split() ))
d = math.sqrt( (x1-x2)**2+(y1-y2)**2 )
print(d)

Solution (Python):
x1,y1,x2,y2=map(float,raw_input().split())
d=((x1-x2)**2+(y1-y2)**2)**(0.5)
print d

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
x = abs(x1 - x2)
y = abs(y1 - y2)
print(math.sqrt(x * x + y * y))

Solution (Python):

import math

x1,y1,x2,y2 = map(float, input().split())

ans = (x2 - x1) **2 + (y2 - y1) **2

ans = math.sqrt(ans)

print(ans)

Solution (Python):

import math
input_data = list(map(float, input().split()))


result = math.sqrt((input_data[2]-input_data[0])**2+(input_data[3]-input_data[1])**2)
print(f"{result:.8f}")

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print(((x1 - x2) ** 2 + (y1 - y2) ** 2) ** (1 / 2))

Solution (Python):
import math

x1,y1,x2,y2 = map(float,input().split())
print(math.sqrt((x1-x2)**2+(y1-y2)**2))

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print(((x1-x2)**2+(y1-y2)**2)**0.5)

Solution (Python):
import math
x1,y1,x2,y2=map(float,input().split())
print('{:.8f}'.format(math.sqrt((x2-x1)**2+(y2-y1)**2)))

Solution (Python):
import math

a,b,c,d = list(map(float,input().split()))
x = c - a
y = d - b
print(math.sqrt(x ** 2 + y ** 2))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
d = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
print(d)

Solution (Python):
import math

x1,y1,x2,y2 = map(float,input().split())
a = x2 - x1
b = y2 - y1
c = math.sqrt(a * a + b * b)
print(c)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())

distance = pow((x2 - x1) ** 2 + (y2 - y1) **2, 0.5)
print(distance)

Solution (Python):
import math
a,b,c,d=map(float,input().split())
print("{:.10f}".format(math.sqrt((a-c)**2 + (b-d)**2)))

Solution (Python):
import math


x1, y1, x2, y2 = map(float, input().split())


sub1 = abs(x1 - x2)
sub2 = abs(y1 - y2)
dstncsqr = sub1 ** 2 + sub2 ** 2
print(math.sqrt(dstncsqr))

Solution (Python):
import math

if __name__ == "__main__":

    param = input().split(" ")
    x1 = float(param[0])
    y1 = float(param[1])
    x2 = float(param[2])
    y2 = float(param[3])

    dist = math.sqrt( (x1 - x2)**2 + (y1 - y2)**2 )

    print(dist)

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
if x1 > x2:
    if y1 > y2:
        print(math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2))
    else:
        print(math.sqrt((x1 - x2) ** 2 + (y2 - y1) ** 2))
else:
    if y1 > y2:
        print(math.sqrt((x2 - x1) ** 2 + (y1 - y2) ** 2))
    else:
        print(math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2))

Solution (Python):
from enum import Enum
import sys

BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001

class Point():
    def __init__(self,arg_x,arg_y):
        self.x = arg_x
        self.y = arg_y

def calc_len(a,b):
    from math import sqrt
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))

x1,y1,x2,y2 = map(float,input().split())

p1 = Point(x1,y1)
p2 = Point(x2,y2)

print("%.10f"%calc_len(p1,p2))

Solution (Python):
a,b,c,d = map(float,input().split())
print(((c-a)**2+(d-b)**2)**0.5)

Solution (Python):
x1, x2, y1, y2 = [float(i) for i in input().split()]
ans = ((x1-y1)**2 + (x2-y2)**2) ** 0.5
print(f"{ans:.5f}")

Solution (Python):
x1,y1,x2,y2=map(float,input().split())
print(((x2-x1)**2+(y2-y1)**2)**0.5)

Solution (Python):
import math

def calc_dist(x, y):
    if x > 0 and y > 0:
        result = abs(x) - abs(y)
    elif x < 0 and y > 0:
        result = abs(x) + abs(y)
    elif x > 0 and y < 0:
        result = abs(x) + abs(y)
    elif x < 0 and y < 0:
        result = abs(x) - abs(y)
    elif x == 0 or y == 0:
        result = abs(x) + abs(y)
    return abs(result)

x1, y1, x2, y2 = map(float, input().split())
dist1 = calc_dist(x1, x2)
dist2 = calc_dist(y1, y2)
dist3 = math.sqrt(dist1**2 + dist2**2)
print('{:.8f}'.format(dist3))

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())

print(((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split(" "))
x = (x2 - x1) ** 2
y = (y2 - y1) ** 2
print(round((x + y) ** 0.5, 8))

Solution (Python):
import math
x1,y1,x2,y2=map(float,input().split())
print(math.sqrt((abs(x2-x1))**2 + (abs(y2-y1))**2))

Solution (Python):
import math

x, y, xx, yy = map(float,input().split())
dx = abs(x - xx)
dy = abs(y - yy)

result = math.sqrt(dx**2 + dy**2)
print(result)

Solution (Python):
import math
x1, y1, x2, y2 = map(float,input().split())
d = math.sqrt(math.pow(x2 - x1,2) + math.pow(y2 - y1,2))
print(d)

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
d = math.sqrt((x2-x1)**2 + (y2-y1)**2)
print('%.8f' % d)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print(f"{((x1-x2)**2+(y1-y2)**2)**0.5:.6f}")

Solution (Python):
from math import *
x1,y1,x2,y2=map(float,input().split())
print('{:4f}'.format(sqrt((x1-x2)**2+(y1-y2)**2)))

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
dist = ((x2-x1)**2 + (y2-y1)**2)**0.5
print("{:.8f}".format(dist))

Solution (Python):
x1,y1,x2,y2 = map(float,input().split())
d = ((x1-x2)**2+(y1-y2)**2)**0.5
print(d)

Solution (Python):
import math

x1, y1, x2, y2 = map(float, input().split())

distance=math.sqrt((x1-x2)**2+(y1-y2)**2)

print(distance)

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
print(math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2))

Solution (Python):
import math
x1,y1,x2,y2 = [ float(s) for s in input().split() ]

print(math.sqrt((x2-x1)**2+(y2-y1)**2))

Solution (Python):
import math
x1,y1,x2,y2 = map(float, input().split())

print(math.sqrt(pow(x2-x1,2) + pow(y2-y1,2)))

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")

def main():
    x1,y1,x2,y2 = map(float, input().split())
    print(((x1-x2)**2+(y1-y2)**2)**0.5)

main()

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
print(round(math.sqrt((x1-x2)**2+(y1-y2)**2),5))

Solution (Python):
a,b,c,d = map(float,input().split())
print(float((abs(a-c)**2)+(abs(b-d)**2))**(1/2))

Solution (Python):
import math

p = list(map(float, input().split()))

res = math.sqrt((p[0] - p[2])**2 + (p[1] - p[3])**2)

print(res)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())

import math

print(math.sqrt((x2-x1)**2 + (y2-y1)**2))

Solution (Python):
x1,y1,x2,y2=map(float,input().split())

def dist(a1,b1,a2,b2):
    d = ( (a2 - a1)**2 + (b2 - b1)**2 )**0.5
    return d
    
a = dist(x1,y1,x2,y2)
print("{:.10f}".format(a))

Solution (Python):
x1, y1, x2, y2 = [float(i) for i in input().split()]

d = ((x2-x1)**2 + (y2-y1)**2)**0.5

print(d)

Solution (Python):
a, b, c, d = map(float, input().split())
t = (a-c)**2 + (b-d)**2
print(t**(1/2))

Solution (Python):
from math import sqrt
x1,y1,x2,y2=list(map(float,input().split()))
print(sqrt((x1-x2)**2+(y1-y2)**2))

Solution (Python):
x1,y1,x2,y2 = map(float,input().split())
x = abs(x1 - x2)
y = abs(y1 - y2)
z = float((x**2+y**2)**(1/2))
print(z)

Solution (Python):
from math import sqrt 
x1, y1, x2, y2 = map(float, input().split())
print(sqrt((x2-x1)**2+(y2-y1)**2))

Solution (Python):
import math

x1,y1,x2,y2 = [ float( val ) for val in input().split( ' ' ) ]
distance = math.sqrt( pow(abs(x1-x2),2)+pow(abs(y1-y2),2) )
print( distance )

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
print(math.sqrt((x1-x2)**2 + (y1-y2)**2))

Solution (Python):
x1,y1,x2,y2=map(float,input().split())
def dist(a,b):
    return (a-b)**2
print((dist(y2,y1)+dist(x2,x1))**0.5)

Solution (Python):
import math
x1,y1,x2,y2=[float(k) for k in input().split()]
print(math.hypot(math.fabs(x1-x2),math.fabs(y1-y2)))

Solution (Python):
import math
x1, y1, x2, y2 = [float(i) for i in input().split()]
v = math.pow(x1 - x2, 2) + math.pow(y1 - y2, 2)
v = math.sqrt(v)
print(v)

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
d = math.sqrt( (x1-x2)**2 + (y1-y2)**2)
print('{:.8f}'.format(d))

Solution (Python):
x1, y1, x2, y2 = map(float, input().split(" "))
print(((x1-x2)**2 + (y1-y2)**2)**0.5)

Solution (Python):
import math

x1,y1,x2,y2=map(float,input().split())

print(math.sqrt((x1-x2)**2+(y1-y2)**2))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
distance = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
print(format(distance, '.4f'))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
print('{:.8f}'.format(math.sqrt((x2-x1)**2 + (y2-y1)**2)))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
z = abs(x2-x1)**2 + abs(y2-y1)**2
print(math.sqrt(z))

Solution (Python):
import math
x1,y1,x2,y2=map(float,input().split(" "))
distance=math.sqrt((x1-x2)**2+(y1-y2)**2)
print("{:.8f}".format(distance))

Solution (Python):
import math
x1,y1,x2,y2 = map(float,input().split())
x2=(x1-x2)*(x1-x2)
y2=(y1-y2)*(y1-y2)
ans = math.sqrt(x2+y2)
print(ans)

Solution (Python):
x1,y1,x2,y2=map(float,input().split())
d2=(x1-x2)**2+(y1-y2)**2
print(d2**(.5))

Solution (Python):
from math import sqrt

x1, y1,  x2, y2 = map(float, input().split())

distance = sqrt((x2-x1) ** 2 + (y2-y1) ** 2)
print(distance)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print(((x2-x1)**2 + (y2-y1)**2)**0.5)

Solution (Python):
x1,y1,x2,y2 = map(float,input().split())
distance = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
print('{:.8f}'.format(distance))

Solution (Python):
x1,y1,x2,y2=map(float,input().split())
print("%.8f"%((y2-y1)**2+(x2-x1)**2)**0.5)

Solution (Python):
import math


x1, y1, x2, y2 = list(map(float, input().split()))


dist = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)


print('{:.8f}'.format(dist))

Solution (Python):
import math

x1,y1,x2,y2 = map(float,input().split())
x = x1-x2
y = y1-y2
n = pow(x,2) + pow(y,2)

print(math.sqrt(n))

Solution (Python):
x1, y1, x2, y2 = [float(i) for i in input().split()]

xdistance = x1 - x2
ydistance = y1 - y2

print(((xdistance**2) + (ydistance**2)) ** 0.5)

Solution (Python):
x1, y1, x2, y2 = [float(i) for i in input().split()]
print(((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print( (abs(x2 - x1) ** 2 + abs(y2 -y1) ** 2) ** 0.5)

Solution (Python):
import math
x1, y1, x2, y2 = [float(x) for x in input().split()]

print(format(math.sqrt((x1-x2)**2+(y1-y2)**2), '.8f'))

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print((((x2-x1)**2)+((y2-y1)**2))**0.5)

Solution (Python):
import math

x1,y1,x2,y2=map(float,input().split())
print(math.sqrt((x2-x1)**2+(y2-y1)**2))

Solution (Python):


import math
x1, y1, x2, y2 = map(float, input().split())
ans = (x2 - x1) ** 2 + (y2 - y1) ** 2
print(math.sqrt(ans))

Solution (Python):
import math
x1, y1, x2, y2=map(float,input().split())
distance = math.sqrt( pow(x1-x2, 2.0) + pow(y1-y2, 2.0) )
print(f"{distance:.5f}")

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
print(math.sqrt((x2-x1)**2 + (y2-y1)**2))

Solution (Python):
import math
x1, y1, x2, y2 = [float(x) for x in input().split()]

print( math.sqrt( (x1-x2)**2 + (y1-y2)**2 ) )

Solution (Python):
x_1,y_1,x_2,y_2 = map(float,input().split())
d_2 =(x_2 - x_1)**2 + (y_2 - y_1)**2
d = d_2**0.5
print(d)

Solution (Python):
import math
s = input().split()

x1=float(s[0])
y1=float(s[1])
x2=float(s[2])
y2=float(s[3])

delta_x = x1-x2
delta_y = y1-y2

distance = math.sqrt(delta_x*delta_x+delta_y*delta_y)
print(distance)

Solution (Python):
def test():

	points = input().split()

	x1 = float(points[0])
	y1 = float(points[1])
	x2 = float(points[2])
	y2 = float(points[3])

	output = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5

	print(f"{output:.8f}")

if __name__ == "__main__":
	test()

Solution (Python):
x1, y1, x2, y2 = map(float,input().split())

ans = ((x2-x1)**2 + (y2-y1)**2) ** 0.5
print(round(ans,6))

Solution (Python):
import math
x1,y1,x2,y2 = map(float,input().split())
sum = (x1-x2)**2 + (y1-y2)**2
print(math.sqrt(sum))

Solution (Python):
x1, y1, x2, y2 = [float(_) for _ in input().split()]

ans = ((x2-x1)**2 + (y2-y1)**2)**0.5
print(ans)

Solution (Python):
import math

x1, y1, x2, y2 = map(float, input().split())

dis = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

print(dis)

Solution (Python):
import math
x1,y1,x2,y2 = map(float,input().split())
print("{0:.8f}".format(math.sqrt((x1-x2)**2+(y1-y2)**2)))

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print(((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5)

Solution (Python):
a,b,c,d = map(float,input().split())
print(abs(complex(c-a,d-b)))

Solution (Python):
import math
a,b,x,y=map(float,input().split())
f=x-a
d=((x-a)*(x-a)+(y-b)*(y-b))**(1/2)
print('%5f'%(d))

Solution (Python):
from enum import Enum
import sys
 
BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001
 
class Point():
    def __init__(self,arg_x,arg_y):
        self.x = arg_x
        self.y = arg_y
 
def calc_len(a,b):
    from math import sqrt
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))
 
x1,y1,x2,y2 = map(float,input().split())
 
p1 = Point(x1,y1)
p2 = Point(x2,y2)
 
print("%.10f"%calc_len(p1,p2))

Solution (Python):
import math
x1,y1,x2,y2=map(float,input().split())
dx=abs(x1-x2)
dy=abs(y1-y2)
print(math.sqrt(dx*dx+dy*dy))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
n = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
print(n)

Solution (Python):
import  math
x1, y1, x2, y2 = map(float, input().split())
t = pow(x1 - x2, 2) + pow(y1 - y2, 2)
print(math.sqrt(t))

Solution (Python):
import math
x1,y1,x2,y2=map(float,input().split())
dx=abs(x1-x2)
dy=abs(y1-y2)
print(math.sqrt(dx*dx+dy*dy))

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())

print(((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print(((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5)

Solution (Python):
import math

input_nums = input().split()
distance = math.sqrt( (float(input_nums[2]) - float(input_nums[0]))**2 + (float(input_nums[3])-float(input_nums[1]))**2 )
print(distance)

Solution (Python):
import math

x1,y1,x2,y2 = map(float,input().split())
w = abs(x2 - x1)
h = abs(y2 - y1)

s = math.sqrt(w**2 + h**2)

print(s)

Solution (Python):
import math

x1,y1,x2,y2 = map(float,input().split())
ans = ((x1-x2)**2+(y1-y2)**2)**0.5
print("%.4f"%ans)

Solution (Python):
import math as mt
x1, y1, x2, y2 = map(float, input().split())
xd = abs(x1 - x2)
yd = abs(y1 - y2)
d = mt.sqrt(xd*xd + yd*yd)
print(d)

Solution (Python):
w, x, y, z = map(float, input().split())
print('%5f' % ((w - y)**2 + (x - z)**2)**0.5)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())

print(((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5)

Solution (Python):
import math
a,b,c,d=map(float,input().split())
X=a-c
Y=b-d
print(math.sqrt(X**2+Y**2))

Solution (Python):
x,y,xx,yy=map(float, input().split())
print('%5f'%((x-xx)**2+(y-yy)**2)**0.5)

Solution (Python):
from enum import Enum
import sys

BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001

class Point():
    def __init__(self,arg_x,arg_y):
        self.x = arg_x
        self.y = arg_y

def calc_len(a,b):
    from math import sqrt
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))

x1,y1,x2,y2 = map(float,input().split())

p1 = Point(x1,y1)
p2 = Point(x2,y2)

print("%.10f"%calc_len(p1,p2))

Solution (Python):
x1,y1,x2,y2 = map(float, input().split())
result = ((x2-x1) ** 2 + (y2-y1) ** 2) ** 0.5
print(round(result,8))

Solution (Python):
x,y,xx,yy=map(float,input().split())
print('%5f'%((x-xx)**2+(y-yy)**2)**0.5)

Solution (Python):
import math

x1, y1, x2, y2 = map(float,input().split())
x = x2 - x1
y = y2 - y1
s = x ** 2 + y ** 2


print(math.sqrt(s))

Solution (Python):
import math as mp
l = list(map(float,input().split()))
print(mp.sqrt((l[0]-l[2])**2+(l[1]-l[3])**2))

Solution (Python):
import math
x1, y1, x2, y2 = input().split()
x1 = float(x1)
y1 = float(y1)
x2 = float(x2)
y2 = float(y2)
dist = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
print(dist)

Solution (Python):
import math

x1, y1, x2, y2 = map(float, input().split())

d = math.sqrt((x2-x1)**2 + (y2-y1)**2)

print(d)

Solution (Python):
import math

x1,y1,x2,y2 = map(float,input().split())
d = math.sqrt((x2-x1)**2 + (y2-y1)**2)
print("{:.8f}".format(d))

Solution (Python):
import math
 
x1, y1, x2, y2 = map(float,input().split())
 
print(math.sqrt( (x2-x1)**2 + (y2-y1)**2 ))

Solution (Python):
import math
x1,y1,x2,y2 = map(float,input().split())
print("{0:.8f}".format(math.sqrt((x1-x2)**2+(y1-y2)**2)))

Solution (Python):
import math

x1, y1, x2, y2 = map(float,input().split())

print(math.sqrt( (x2-x1)**2 + (y2-y1)**2 ))

Solution (Python):
import math
x1,y1,x2,y2 = map(float,input().split())
print("{0:.8f}".format(math.sqrt((x1-x2)**2+(y1-y2)**2)))

Solution (Python):
import math
x1,y1,x2,y2 = map(float,input().split())
print("{0:.8f}".format(math.sqrt((x1-x2)**2+(y1-y2)**2)))

Solution (Python):
x1,y1,x2,y2=map(float,input().split())
distance=round(((x1-x2)**2+(y1-y2)**2)**0.5,5)
print(f'{distance}')

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print((((x1-x2)**2+(y1-y2)**2))**0.5)

Solution (Python):
import math


if __name__ == "__main__":
    x1, y1, x2, y2 = map(lambda x: float(x), input().split())
    print("{:.5f}".format(math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)))

Solution (Python):
a = list(map(float,input().split()))

x = abs(a[0]-a[2])
y = abs(a[1]-a[3])

L = (x**2 + y**2)**(1/2)

print(L)

Solution (Python):






import sys
import math


class mymath:
    
    pi = 3.14159265358979323846264338

    
    def pnum_eratosthenes(self, n):
        ptable = [0 for i in range(n+1)]
        plist = []

        for i in range(2, n+1):
            if ptable[i]==0:
                plist.append(i)
                for j in range(i+i, n+1, i):
                    ptable[j] = 1
        return plist

    
    def gcd(self, a, b):
        if b == 0:
            return a
        return self.gcd(b, a%b)

    
    def lcm(self, a, b):
        return (a*b)//self.gcd(a,b)

    
    def mul(self, A, B):
        ans = []
        for a in A:
            c = 0
            for j, row in enumerate(a):
                c += row*B[j]
            ans.append(c)
        return ans

mymath = mymath()


class output:
    
    def list(self, l):
        l = list(l)
        
        for i, num in enumerate(l):
            print(num, end="")
            if i != len(l)-1:
                print(" ", end="")
        print()

output = output()






















def get_input():
    N = []
    while True:
        try:
            N.append(input())
        except EOFError:
            break
    return N

def main():
    X1, Y1, X2, Y2 = [float(x) for x in input().split()]
    
    dx = (X1 - X2)**2
    dy = (Y1 - Y2)**2

    print(math.sqrt(dx+dy))

if __name__ == '__main__':
    main()

Solution (Python):
import math


x1, y1, x2, y2 = map(float, input().split())

print(math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2))

Solution (Python):


x1, y1, x2, y2 = map(float, input().split())
print(((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5)

Solution (Python):
x1,y1,x2,y2=map(float,input().split())
print(((x1-x2)**2+(y1-y2)**2)**0.5)

Solution (Python):
x1,y1,x2,y2=map(float,input().split())
print(((x2-x1)**2+(y2-y1)**2)**0.5)

Solution (Python):
import math

x1,y1,x2,y2=map(float,input().split())

dx=abs(x1-x2)
dy=abs(y1-y2)

print(math.sqrt(dx*dx+dy*dy))

Solution (Python):
import math
x1,y1,x2,y2=map(float,input().split())
dx=abs(x1-x2)
dy=abs(y1-y2)
print(math.sqrt(dx*dx+dy*dy))

Solution (Python):
import math
x1,y1,x2,y2 = map(float,input().split())
print("{0:.8f}".format(math.sqrt((x1-x2)**2+(y1-y2)**2)))

Solution (Python):
a, b, x, y = map(float, input().split())
print(((a - x) ** 2 + (b - y) ** 2) ** 0.5)

Solution (Python):
import math
a,b,c,d = map(float, input().split())
print(math.sqrt( pow(abs(a-c),2) + pow(abs(b-d),2) ))

Solution (Python):
import math
x1, y1, x2, y2= map(float, input().split())
d = math.sqrt((x1-x2)**2 + (y1-y2)**2)
print(f"{d:.6f}")

Solution (Python):
import math
x1, y1, x2, y2 = map(float,input().split())

x = x1-x2
y = y1-y2

print(math.sqrt(x**2+y**2))

Solution (Python):
(n,m,o,p) = map(float, raw_input().split())
print ((n-o)**2 + (m-p)**2)**0.5

Solution (Python):
x1, y1, x2, y2 = map(float,input().split())
ans = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
print("{0:.5f}".format(ans))

Solution (Python):
import math
a, b, c, d = map(float,input().split())
print(((c-a)**2+(d-b)**2)**0.5)

Solution (Python):
import math
a, b, c, d = map(float,input().split())
print(((c-a)**2+(d-b)**2)**0.5)

Solution (Python):
import math

L=input().split( )
x1=float(L[0])
x2=float(L[2])
y1=float(L[1])
y2=float(L[3])
r2=(x1-x2)**2+(y1-y2)**2
r=math.sqrt(r2)
print(r)

Solution (Python):
a,b,c,d=map(float, input().split())

dis =((c-a)**2 + (d-b)**2)**0.5
print(format(dis,'.8f'))

Solution (Python):
import math
x1,y1,x2,y2 = map(float,input().split())
length = math.sqrt((x1 - x2)**2 + (y1 - y2)**2)
print(length)

Solution (Python):


from collections import* 
from fractions import gcd
from functools import* 
from itertools import* 
from operator import mul
from bisect import* 
from heapq import* 
from math import factorial,pi
from copy import deepcopy
import sys

sys.setrecursionlimit(10**6)

def f(i):
    xa,ya,xb,yb=i
    return ((xa-xb)**2+(ya-yb)**2)**0.5



def main():
    print(f(list(map(float,input().split()))))
if __name__ == '__main__':
    main()

Solution (Python):
import decimal
import math


x1, y1, x2, y2 = map(decimal.Decimal, input().split())


print(math.sqrt((x1 - x2)**2 + (y1 - y2)**2))

Solution (Python):

a = input()
num = a.split(" ")

sq = ( float(num[0])-float(num[2]) )*( float(num[0])-float(num[2]) ) + ( float(num[1])-float(num[3]) )*( float(num[1])-float(num[3]) )
print (round(sq**0.5,8))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())

d = math.sqrt(((x2 - x1) ** 2 + (y2 - y1) ** 2))
print(d)

Solution (Python):
from math import sqrt
x1, y1, x2, y2 = map(float, input().split())
ans = sqrt((x2 - x1) ** 2 + (y2 -y1) ** 2)
print(ans)

Solution (Python):
import math

x1, y1, x2, y2 = list(map(float, input().split())) 
d = math.sqrt((x2 - x1)**2 + (y2-y1)**2)
print(d)

Solution (Python):
from enum import Enum
import sys
 
BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001
 
class Point():
    def __init__(self,arg_x,arg_y):
        self.x = arg_x
        self.y = arg_y
 
def calc_len(a,b):
    from math import sqrt
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))
 
x1,y1,x2,y2 = map(float,input().split())
 
p1 = Point(x1,y1)
p2 = Point(x2,y2)
 
print("%.10f"%calc_len(p1,p2))

Solution (Python):
import math
x1,y1,x2,y2=map(float, input().split())
p=math.sqrt((x1-x2)**2+(y1-y2)**2)
print(p)

Solution (Python):
import math
x1,y1,x2,y2=map(float,input().split())
dist = math.sqrt(abs(x2-x1)**2+abs(y2-y1)**2)
print("%f"%(dist))

Solution (Python):
import math

class Point():
    def __init__(self, __x, __y):
        self.__x = __x
        self.__y = __y
    
    def get_x(self):
        return self.__x
    
    def get_y(self):
        return self.__y

def dist(__p1, __p2):
    __dist_x = abs(__p2.get_x() - __p1.get_x())
    __dist_y = abs(__p2.get_y() - __p1.get_y())
    return math.sqrt(__dist_x ** 2 + __dist_y ** 2)

str = input().split()
x1, y1, x2, y2 = [float(i) for i in str]
p1 = Point(x1, y1)
p2 = Point(x2, y2)
print(dist(p1, p2))

Solution (Python):
import math

inputdata = input().split()
datax1 = float(inputdata[0])
datax2 = float(inputdata[2])
datay1 = float(inputdata[1])
datay2 = float(inputdata[3])

print( math.sqrt( math.pow(datax2-datax1,2) + math.pow(datay2 - datay1,2)))

Solution (Python):
import math
x1,y1,x2,y2 = map(float,input().split())
distance = math.sqrt((x2 - x1)**2 + (y2-y1)**2)
print("{0:.8f}".format(distance))

Solution (Python):
from math import sqrt
x1, y1, x2, y2 = map(float, input().split())
dx = x1 - x2
dy = y1 - y2
dd = sqrt(dx**2 + dy**2)
print(dd)

Solution (Python):
import math
x1,x2,y1,y2 = map(float,input().split())
d=math.hypot(y1-x1,y2-x2)

print(float(d))

Solution (Python):
import math
x1,x2,y1,y2 = map(float, input().split())
d = math.hypot(y1-x1,y2-x2)
print(float(d))

Solution (Python):
x1,y1,x2,y2=map(float,input().split())
x=float(x1-x2)
y=float(y1-y2)
import math
l=math.hypot(x,y)
print("{:.8f}".format(l))

Solution (Python):
import math
x1, y1, x2, y2  = map(float, input().split())
x=float(x2-x1)
y=float(y2-y1)
r=math.hypot(x,y)
print("{:.8f}".format(r))

Solution (Python):
import math
x1, y1, x2, y2  = map(float, input().split())
x=float(x2-x1)
y=float(y2-y1)
r=math.hypot(x,y)
print("{:.8f}".format(r))

Solution (Python):
import math
x1,y1,x2,y2=map(float,input().split())
x=x2-x1
y=y2-y1
r=math.hypot(x,y)
print("{:.8f}".format(r))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
print(math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2))

Solution (Python):
import math

def get_distance(x1, y1, x2, y2):
    d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
    return d

if __name__ == '__main__':
    x1, y1, x2, y2 = map(float,input().split())
    d = get_distance(x1, y1, x2, y2)
    print(d)

Solution (Python):
import math
x1,y1,x2,y2 = map(float, input().split())
a=x2-x1
b=y2-y1
d=math.hypot(a,b)
print(d)

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input(). split())
print(math.hypot(x1-x2,y1-y2))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())



print(math.hypot(x1 - x2 , y1 - y2))

Solution (Python):
import math
x1,y1,x2,y2=map(float,input().split())
x=x2-x1
y=y2-y1
print(math.hypot(x,y))

Solution (Python):
x1,y1,x2,y2 = map(float,input().split())
print(abs(complex(x1-x2,y1-y2)))

Solution (Python):
import math
a,b,c,d = map(float, input().split())
length = math.sqrt((c-a)*(c-a) + (d-b)*(d-b))
print(length)

Solution (Python):
import math

class Point(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y
    

def d(u, v):
    return math.sqrt((u.x - v.x) ** 2 + (u.y - v.y) ** 2)


a = [float(e) for e in input().split()]
u = Point(a[0], a[1])
v = Point(a[2], a[3])
print(d(u, v))

Solution (Python):
if __name__ == '__main__':
	x1,y1,x2,y2 = map(float,input().split())
	
	distance = (abs(x2 - x1)**2 + abs(y2 - y1)**2)**0.5
	print(distance)

Solution (Python):
x1,y1,x2,y2 = input().split(" ")
x1 = float(x1)
x2 = float(x2)
y1 = float(y1)
y2 = float(y2)

d =((x2 - x1)**2 +(y2 - y1)**2)**(0.5)
print("{:8}".format(d))

Solution (Python):
import math

x1, y1, x2, y2 = map(float, input().split())
print(math.sqrt((x1 - x2)**2 + (y1 - y2)**2))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
ans = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
print(ans)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print("{:.5f}".format(((y2-y1)**2 + (x2-x1)**2)**0.5))

Solution (Python):
import math
x1,y1,x2,y2 = map(float,input().split())
print(f'{math.hypot(x2-x1,y2-y1):.5f}')

Solution (Python):
a,b,c,d=map(float,input().split())
print('{:.5f}'.format((abs(a-c)**2+abs(b-d)**2)**0.5))

Solution (Python):
x = input()
list = x.split()
list_i = [float(s) for s in list]

p1x = list_i[0]
p1y = list_i[1]
p2x = list_i[2]
p2y = list_i[3]

kyori1 = p2x - p1x
kyori2 = p2y - p1y
kyori3 = kyori1 ** 2 + kyori2 ** 2


ans = kyori3 ** 0.5
ans = float(ans)

print(ans)

Solution (Python):
import math

x1, y1, x2, y2 = [float(i) for i in input().split()]




temp = ((x2 - x1) ** 2) + ((y2 - y1) ** 2)
shahen = math.sqrt(temp)

print(shahen)

Solution (Python):
import math

x1,y1,x2,y2 = map(float, input().split())

distance = math.sqrt( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) )

print("%.8f"%distance)

Solution (Python):
import math
nums = list(map(float, input().split()))
print(math.sqrt(((nums[0]-nums[2])**2 + (nums[1]-nums[3])**2)))

Solution (Python):

x1,y1,x2,y2 = map(float,input().split())
distance = ((x1-x2)**2 + (y1-y2)**2)**0.5
print(distance)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())

print(((x2-x1)**2 + (y2-y1)**2)**0.5)

Solution (Python):
class point():
    def __init__(self,arg_x,arg_y):
        self.x = arg_x
        self.y = arg_y
 
def calc_len(a,b):
    from math import sqrt
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))
 
x1,y1,x2,y2 = map(float,input().split())
 
p1 = point(x1,y1)
p2 = point(x2,y2)
 
print("%.10f"%calc_len(p1,p2))

Solution (Python):
x1, y1, x2, y2 = map(float,input().split())

distance = ((x1-x2)**2 + (y1-y2)**2)**0.5

print(distance)

Solution (Python):
import math

x1, y1, x2, y2 = map(float, input().split())

print(math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2))

Solution (Python):
x1,y1,x2,y2 = map(float, input().split())

print('{0:5f}'.format(((x2-x1)**2 + (y2-y1)**2)**(1/2)))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
print(math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2))

Solution (Python):
import math

x1, y1, x2, y2 = map(float, input().split())
r = math.sqrt((x1-x2)**2 + (y1-y2)**2)
print(f"{r:.6f}")

Solution (Python):
x1, y1, x2, y2 = list(map(float, input().split()))
x = pow((x2-x1), 2)
y = pow((y2-y1), 2)
r = pow((x+y), 1/2)
print(r)

Solution (Python):
import math

X1,Y1,X2,Y2=map(float,input().split())
print(math.sqrt((X2-X1)*(X2-X1)+(Y2-Y1)*(Y2-Y1)))

Solution (Python):
import math
x1, y1, x2, y2 = map(float, input().split())
print(math.sqrt( (x2-x1)**2 + (y2-y1)**2 ))

Solution (Python):
x1, x2, y1, y2 = map(float, input().split(' '))

a = x1-y1
b = x2-y2
d = a*a + b*b
dist = pow(d, 1/2)
print(dist)

Solution (Python):
x1,x2,y1,y2 = map(float,input().split())
print(((x1-y1)**2+(x2-y2)**2)**(1/2))

Solution (Python):
x1, y1, x2, y2 = [float(_) for _ in input().split()]
k = ((x2-x1)**2 + (y2-y1)**2)**(1/2)
print(k)

Solution (Python):
x1, y1, x2, y2 = map(float, input().split())
print(((x2 - x1) ** 2 + (y1 - y2) ** 2) ** 0.5)

Solution (Python):
import math

x1, y1, x2, y2 = map(float,input().split())

print("{:}".format(math.sqrt((x2-x1)**2+(y2-y1)**2)))

Solution (Python):
x1,y1,x2,y2=map(float,input().split())
l=((x1-x2)**2+(y1-y2)**2)**0.5
print(l)

Solution (Python):
x1,y1,x2,y2=map(float,input().split())
print(f'{((x2-x1)**2+(y2-y1)**2)**0.5:.6f}')