Eccone un altro semplice:

La sfida

Dati due punti in uno spazio n-dimensionale, genera la distanza tra loro, chiamata anche distanza euclidea.

• Le coordinate saranno numeri razionali; gli unici limiti sono le restrizioni della tua lingua.
• La dimensione più bassa è 1, la più alta è qualunque cosa la tua lingua possa gestire
• Si può presumere che i due punti abbiano la stessa dimensione e che non vi siano input vuoti.
• La distanza deve essere corretta con almeno 3 cifre decimali. Se la tua lingua non supporta i numeri in virgola mobile, genera il numero intero più vicino.

Regole

• Come al solito, è consentita la funzione o il programma completo.
• L'input può essere preso da STDIN, dalla riga di comando o dagli argomenti della funzione.
• Il formato di input dipende da te, specifica quale hai usato nella tua risposta.
• L'output può essere fornito stampando su stdout o restituendo un valore.
• Questo è code-golf, quindi vince il conteggio di byte più basso! In caso di pareggio, vince la risposta precedente.

Casi test

Ogni punto è rappresentato da un elenco di lunghezza 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

Buona programmazione!

MATL , 2 byte

ZP

Provalo online !

La ZPfunzione (corrispondente a MATLAB pdist2) calcola tutte le distanze a coppie tra due serie di punti, usando la distanza euclidea per impostazione predefinita. Ogni set di punti è una matrice e ogni punto è una riga. In questo caso produce un singolo risultato, che è la distanza tra i due punti.

MATL, 4.0 3 byte

Grazie per -1 di @AndrasDeak!

-Zn

Legge due vettori (tramite input implicito richiesto da -) quindi sottrae quelli e calcola la norma della loro differenza Zn.

Provalo online!

Pyth, 2 byte

.a

.a - Norma L2 della differenza vettoriale di A [0] e A [1].

Letteralmente una funzione che fa questo problema

Provalo qui.

Gelatina , 4 byte

_²S½

Provalo online!

Come funziona

_²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 byte

Norm[#-#2]&

Inserire come due elenchi, produrre come numero. Se l'input è esatto (numeri interi, razionali, ecc.) Anche l'output sarà esatto. Se l'input contiene un numero in virgola mobile, anche l'output sarà float.

Ottava, 15 byte

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

Esempio:

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 byte

Grazie a Dennis per aver salvato 3 byte.

q~.-:mhz

Esegui tutti i casi di test.

Spiegazione

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.

Vedi questo consiglio per perché :mhfunziona.

Haskell, 46 byte

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

Haskell, 35 byte (di @nimi)

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

Haskell, 31 byte

Come questa risposta alla Scala , accetta input come una sequenza di tuple

<Mod>

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

</ Mod>

Esempi:

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 byte

.5*⍨(+/-×-)

Questo è un treno di funzioni diadico che prende i vettori a sinistra ea destra e restituisce la norma euclidea della loro differenza.

Spiegazione:

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

Provalo qui

Salvato 3 byte grazie a Dennis!

J, 9 byte

+&.*:/-/>

Questa è una funzione che prende un insieme di coordinate dall'altro ( -/>) e quindi esegue una somma +sotto il &.quadrato *:.

L'input dovrebbe essere nel formato in x y z;a b ccui x y zè il tuo primo set di coordinate ed a b cè l'altro.

Java, 130 117 114 107 105 byte

Questa è la soluzione ovvia. Di solito non gioco a golf a Java, ma ero curioso di vedere se Java poteva battere la versione Brainfuck. Non mi sembra di aver fatto un buon lavoro allora .. Forse si potrebbe usare la nuova mappa / riduzione da Java 8 per salvare alcuni byte.

Grazie a @flawr (13 byte), @KevinCruijssen (9 byte) e @DarrelHoffman (3 byte)!

golfed:

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);}

Ungolfed:

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 byte

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

Questa è una funzione che accetta due matrici e restituisce la norma euclidea della loro differenza come galleggiante.

Puoi verificare tutti i casi di test contemporaneamente online qui .

golflua , 43 caratteri

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

Funziona chiamandolo come

> 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 di Lua sarebbe

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

Scherzi a parte, 12 byte

,iZ`i-ª`MΣ√A

Provalo online!

Spiegazione:

,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}

Nel programma di test

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 byte

Questo è un codice golf, ma ho inserito dei commenti nel modulo --.

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

Questo utilizza lo stesso algoritmo della maggior parte degli altri programmi qui.

Perl 6, 30 29 26 24 byte

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

(Grazie @ b2gills per altri 2 byte persi)

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 byte

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

Si aspetta una matrice di coppie di coordinate, una per ciascun vettore, ad es [[1, 5], [2, 6], [3, 7], [4, 8]]. Se ciò è inaccettabile, quindi per 42 byte:

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

Prevede due matrici di uguale lunghezza corrispondenti ai due vettori N-dimensionali, ad es [1, 2, 3, 4], [5, 6, 7, 8]. Modifica: salvato 3 byte grazie a @ l4m2. (Inoltre, nessuno ha notato il mio errore di battitura?)

Python 2, 47 byte

Una soluzione semplice. La funzione prevede 2 punti come sequenze di numeri e restituisce la distanza tra di essi.

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

Esempio:

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

𝔼𝕊𝕄𝕚𝕟, 6 caratteri / 13 byte

МŰМŷ…ï

Try it here (Firefox only).

Calcola la norma della differenza degli array di input.

Scala, 67 62 byte

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

Richiede input come sequenza / vettore di tuple var-arg
Esempio:

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

C #, 72 byte

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

Una soluzione semplice che utilizza Linq.

Salvia, 35 byte

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

Questa funzione accetta 2 elenchi come input e restituisce un'espressione simbolica. La distanza viene calcolata eseguendo la sottrazione vettoriale negli elenchi e calcolando la norma euclidea del vettore risultante.

Provalo online

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

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

TI-Basic è un linguaggio tokenizzato .

Richiede l'inserimento come due elenchi e restituisce la distanza euclidea tra loro Ans

Spiegazione:

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 byte

dist

Questa è una funzione integrata per calcolare la matrice di distanza di qualsiasi matrice di input. Il valore predefinito è la distanza euclidea.

Esempio di utilizzo:

> 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

Se ti senti deluso perché è un built-in, allora ecco una versione non-built-in (o almeno, è meno built-in ...) per 22 byte (grazie a Giuseppe ):

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

Questa è una funzione anonima che accetta due vettori come input.

Haskell, 32 byte

((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 caratteri

Passa attraverso, trovando il quadrato della differenza e quindi la radice della somma:

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

Mathcad, byte

Utilizza l'operatore di magnitudine vettoriale (valore assoluto) incorporato per calcolare la dimensione della differenza tra i due punti (espressa in vettori).

Le dimensioni del golf di Mathcad sono in attesa fino a quando non riesco (o qualcun altro a ottenere) il giro per aprire la discussione su meta. Tuttavia, il modo più breve (supponendo che l'input dei vettori punti non contribuisca al punteggio) è 3 "byte", con 14 byte per la versione funzionale.

Pyke, 7 byte

,A-MXs,

Provalo qui!

Trasponi, applica sottrazione, mappa quadrata, somma, sqrt.

Rubino, 50 byte

Comprimi, quindi mappa / riduci. Elimina a malapena l'altra risposta di Ruby da @LevelRiverSt di 2 byte ...

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

Provalo online