Aquí hay otro simple:

El reto

Dados dos puntos en un espacio n-dimensional, genera la distancia entre ellos, también llamada distancia euclidiana.

• Las coordenadas serán números racionales; Los únicos límites son las restricciones de su idioma.
• La dimensión más baja es 1, la más alta es lo que su idioma pueda manejar
• Puede suponer que los dos puntos son de la misma dimensión y que no habrá una entrada vacía.
• La distancia debe ser correcta al menos con 3 decimales. Si su idioma no admite números de coma flotante, envíe el número entero más cercano.

Reglas

• Como de costumbre, se permite la función o el programa completo.
• La entrada puede tomarse de STDIN, línea de comando o argumentos de función.
• El formato de entrada depende de usted, especifique cuál utilizó en su respuesta.
• La salida puede proporcionarse imprimiendo en stdout o valor de retorno.
• Este es el código de golf, ¡ así que el conteo de bytes más bajo gana! En caso de empate, gana la respuesta anterior.

Casos de prueba

Cada punto está representado por una lista de longitud n.

[1], [3] -> 2
[1,1], [1,1] -> 0
[1,2], [3,4] -> 2.82842712475
[1,2,3,4], [5,6,7,8] -> 8
[1.5,2,-5], [-3.45,-13,145] -> 150.829382085
[13.37,2,6,-7], [1.2,3.4,-5.6,7.89] -> 22.5020221314

¡Feliz codificación!

MATL , 2 bytes

ZP

Pruébalo en línea !

La ZPfunción (correspondiente a MATLAB pdist2) calcula todas las distancias por pares entre dos conjuntos de puntos, utilizando la distancia euclidiana por defecto. Cada conjunto de puntos es una matriz, y cada punto es una fila. En este caso, produce un único resultado, que es la distancia entre los dos puntos.

MATL, 4.0 3 bytes

Gracias por -1 por @AndrasDeak!

-Zn

Lee dos vectores (a través de una entrada implícita solicitada por -) luego los resta y calcula la norma de su diferencia con Zn.

Pruébalo en línea!

Pyth, 2 bytes

.a

.a - Norma L2 de diferencia vectorial de A [0] y A [1].

Literalmente una función que hace este problema

Pruébalo aquí

Jalea , 4 bytes

_²S½

Pruébalo en línea!

Cómo funciona

_²S½    Main link. Left input: A (list). Right input: B (list).

_       Subtract B from A, element by element.
 ²      Square all differences.
  S     Add all squares.
   ½    Take the square root of the sum.

Mathematica, 11 bytes

Norm[#-#2]&

Entrada como dos listas, salida como un número. Si la entrada es exacta (enteros, racionales, etc.), la salida también será exacta. Si la entrada contiene un número de punto flotante, la salida también será flotante.

Octava, 15 bytes

@(x,y)norm(x-y)

Ejemplo:

octave:1> d=@(x,y)norm(x-y);
octave:2> d([13.37,2,6,-7], [1.2,3.4,-5.6,7.89])
ans =  22.502

CJam, 11 8 bytes

Gracias a Dennis por guardar 3 bytes.

q~.-:mhz

Ejecute todos los casos de prueba.

Explicación

q~   e# Read and evaluate input.
.-   e# Vectorised difference.
:mh  e# Reduce √(x²+y²) over the list.
z    e# Take abs() to handle 1D input.

Vea este consejo para saber por qué :mhfunciona.

Haskell, 46 bytes

d :: Floating c => [c] -> [c] -> c
d a=sqrt.sum.map((^2).uncurry(flip(-))).zip a

Haskell, 35 bytes (por @nimi)

d :: Float c => [c] -> [c] -> c
d a=sqrt.sum.zipWith(((^2).).(-))a

Haskell, 31 bytes

Al igual que esta respuesta de Scala , toma la entrada como una secuencia de tuplas

<hack>

d :: Float c => [(c,c)] -> c
d=sqrt.sum.map$(^2).uncurry(-)

</hack>

Ejemplos:

Prelude> d [1] [3]
2.0
Prelude> d [1,1] [1,1]
0.0
Prelude> d [1,2,3,4] [5,6,7,8]
8.0
Prelude> d [1.5,2,-5] [-3.45,-13,145]
150.82938208452623
Prelude> d [13.37,2,6,-7] [1.2,3.4,-5.6,7.89]
22.50202213135522

APL, 14 11 bytes

.5*⍨(+/-×-)

Este es un tren de función diádica que toma los vectores a la izquierda y a la derecha y devuelve la norma euclidiana de su diferencia.

Explicación:

       -×-)  ⍝ Squared differences
    (+/      ⍝ Sum them
.5*⍨         ⍝ Take the square root

Pruébalo aquí

¡Guardado 3 bytes gracias a Dennis!

J, 9 bytes

+&.*:/-/>

Esta es una función que toma un conjunto de coordenadas del otro ( -/>), y luego realiza una suma +debajo del &.cuadrado *:.

La entrada debe estar en el formato x y z;a b cdonde x y zestá su primer conjunto de coordenadas y a b ces el otro.

Java, 130 117 114 107 105 bytes

Esta es la solución obvia. No suelo jugar al golf en Java, pero tenía curiosidad por ver si Java podría vencer a la versión Brainfuck. Parece que no hice un buen trabajo entonces ... Tal vez uno podría usar el nuevo Mapa / Reducir de Java 8 para guardar algunos bytes.

¡Gracias a @flawr (13 bytes), @KevinCruijssen (9 bytes) y @DarrelHoffman (3 bytes)!

Golfizado:

double d(float[]a,float[]b){float x=0,s;for(int i=0;i<a.length;x+=s*s)s=a[i]-b[i++];return Math.sqrt(x);}

Sin golf:

double d(float[] a, float[] b) {
  float x=0,s;

  for(int i=0; i<a.length; x+=s*s)
    s = a[i] - b[i++];

  return Math.sqrt(x);
}

Julia, 16 bytes

N(x,y)=norm(x-y)

Esta es una función que acepta dos matrices y devuelve la norma euclidiana de su diferencia como flotante.

Puede verificar todos los casos de prueba a la vez en línea aquí .

golflua , 43 caracteres

\d(x,y)s=0~@i,v i(x)s=s+(v-y[i])^2$~M.q(s)$

Funciona llamándolo como

> w(d({1,1},{1,1}))
0
> w(d({1,2},{3,4}))
2.82842712475
> w (d({1,2,3,4},{5,6,7,8}))
8

Un equivalente de Lua sería

function dist(x, y)
    s = 0
    for index,value in ipairs(x)
       s = s + (value - y[index])^2
    end
    return math.sqrt(s)
end

En serio, 12 bytes

,iZ`i-ª`MΣ√A

Pruébalo en línea!

Explicación:

,iZ`i-ª`MΣ√A
,iZ           get input, flatten, zip
   `   `M     map:
    i-ª         flatten, subtract, square
         Σ√A  sum, sqrt, abs

Ruby, 52

->p,q{t=0;p.size.times{|i|t+=(p[i]-q[i])**2}
t**0.5}

En programa de prueba

f=->p,q{t=0;p.size.times{|i|t+=(p[i]-q[i])**2}
t**0.5}

p f[[1], [3]] # 2
p f[[1,1], [1,1]] # 0
p f[[1,2], [3,4]] # 2.82842712475
p f[[1,2,3,4], [5,6,7,8]] # 8
p f[[1.5,2,-5], [-3.45,-13,145]] # 150.829382085
p f[[13.37,2,6,-7], [1.2,3.4,-5.6,7.89]] # 22.5020221314

AppleScript, 241 239 bytes

Este es un código de golf, pero he puesto comentarios en el formulario --.

on a()    -- Calling for getting input
set v to{1}          -- Arbitrary placeholder
repeat until v's item-1=""       -- Repeat until no input is gathered
set v to v&(display dialog""default answer"")'s text returned   -- Add input to list
end      -- End the repeat
end      -- End the method
set x to a()   -- Set the array inputs
set y to a()
set z to 0     -- Sum placeholder
set r to 2     -- 2 is the first significant array index
repeat(count of items in x)-2     -- Loop through all but first and last of the array
set z to z+(x's item r-y's item r)^2    -- Add the square of the difference
end   -- End the repeat
z^.5  -- Return the square root of the sum

Esto usa el mismo algoritmo que la mayoría de los otros programas aquí.

Perl 6, 30 29 26 24 bytes

{sqrt [+] ([Z-] $_)»²}

(Gracias @ b2gills por 2 bytes más perdidos)

uso

my &f = {sqrt [+] (@^a Z-@^b)»²};

say f([1], [3]); # 2
say f([1,1], [1,1]); # 0
say f([1,2], [3,4]); # 2.82842712474619
say f([1,2,3,4], [5,6,7,8]); # 8
say f([1.5,2,-5], [-3.45,-13,145]); # 150.829382084526
say f([13.37,2,6,-7], [1.2,3.4,-5.6,7.89]); # 22.5020221313552

JavaScript ES7, 45 ES6, 37 bytes

a=>Math.hypot(...a.map(([b,c])=>b-c))

Espera una matriz de pares de coordenadas, una de cada vector, por ejemplo [[1, 5], [2, 6], [3, 7], [4, 8]]. Si eso es inaceptable, entonces para 42 bytes:

(a,b)=>Math.hypot(...a.map((e,i)=>e-b[i]))

Espera dos matrices de igual longitud correspondientes a los dos vectores N-dimensionales, por ejemplo [1, 2, 3, 4], [5, 6, 7, 8]. Editar: Guardado 3 bytes gracias a @ l4m2. (Además, ¿nadie notó mi error tipográfico?)

Python 2, 47 bytes

Una solución directa. La función espera 2 puntos como secuencias de números y devuelve la distancia entre ellos.

lambda a,b:sum((d-e)**2for d,e in zip(a,b))**.5

Ejemplo:

>>> f([13.37, 2, 6, -7], [1.2, 3.4, -5.6, 7.89])
22.50202213135522

𝔼𝕊𝕄𝕚𝕟, 6 caracteres / 13 bytes

МŰМŷ…ï

Try it here (Firefox only).

Calcula la norma de diferencia de las matrices de entrada.

Scala, 67 62 bytes

def e(a:(Int,Int)*)=math.sqrt(a map(x=>x._2-x._1)map(x=>x*x)sum)

Requiere entrada como una secuencia / vector de tuplas var-arg
Ejemplo:

scala> e((1, 5), (2, 6), (3, 7), (4, 8))
res1: Double = 8.0

C #, 72 bytes

(float[]i,float[]n)=>System.Math.Sqrt(i.Zip(n,(x,y)=>(x-y)*(x-y)).Sum())

Una solución simple usando Linq.

Sabio, 35 bytes

lambda a,b,v=vector:norm(v(a)-v(b))

Esta función toma 2 listas como entrada y devuelve una expresión simbólica. La distancia se calcula realizando la resta del vector en las listas y calculando la norma euclidiana del vector resultante.

Pruébalo en línea

TI-Basic (TI-84 Plus CE), 15 bytes

Prompt A,B
√(sum((LA-LB)2

TI-Basic es un lenguaje tokenizado .

Solicita la entrada como dos listas y devuelve la distancia euclidiana entre ellos en Ans

Explicación:

Prompt A,B    # 5 bytes, Prompts for two inputs; if the user inputs lists:
           # they are stored in LA and LB
√(sum((LA-LB)2 # 10 bytes, Euclidian distance between points
           #(square root of (sum of (squares of (differences of coordinates))))

R, 4 bytes

dist

Esta es una función incorporada para calcular la matriz de distancia de cualquier matriz de entrada. El valor predeterminado es la distancia euclidiana.

Ejemplo de uso:

> x=matrix(c(1.5,-3.45,2,-13,-5,145),2)
> x
      [,1] [,2] [,3]
[1,]  1.50    2   -5
[2,] -3.45  -13  145
> dist(x)
         1
2 150.8294

Si te sientes decepcionado porque es una versión incorporada, aquí hay una versión no incorporada (o al menos, menos incorporada ...) para 22 bytes (gracias a Giuseppe ):

pryr::f(norm(x-y,"F"))

Esta es una función anónima que toma dos vectores como entrada.

Haskell, 32 bytes

((sqrt.sum.map(^2)).).zipWith(-)

λ> let d = ((sqrt.sum.map(^2)).).zipWith(-)
λ> d [1] [3]
2.0
λ> d [1,1] [1,1]
0.0
λ> d [1,2] [3,4]
2.8284271247461903
λ> d [1..4] [5..8]
8.0
λ> d [1.5,2,-5] [-3.45,-13,145]
150.82938208452623
λ> d [13.37,2,6,-7] [1.2,3.4,-5.6,7.89]
22.50202213135522

Python 3, 70 caracteres

Recorre, encuentra el cuadrado de la diferencia y luego la raíz de la suma:

a=input()
b=input()
x=sum([(a[i]-b[i])**2 for i in range(len(a))])**.5

Mathcad, bytes

Utiliza el operador de magnitud de vector incorporado (valor absoluto) para calcular el tamaño de la diferencia entre los dos puntos (expresado como vectores).

El tamaño del campo de golf de Mathcad está en espera hasta que llegue (o alguien más lo haga) para abrir la discusión sobre meta. Sin embargo, la forma más corta (suponiendo que la entrada de los vectores de puntos no contribuya a la puntuación) es de 3 "bytes", con 14 bytes para la versión funcional.

Pyke, 7 bytes

,A-MXs,

Pruébalo aquí!

Transponer, aplicar restar, cuadrado del mapa, suma, sqrt.

Ruby, 50 bytes.

Zip, luego mapa / reducir. Apenas supera la otra respuesta de Ruby de @LevelRiverSt en 2 bytes ...

->p,q{p.zip(q).map{|a,b|(a-b)**2}.reduce(:+)**0.5}

Pruébalo en línea