Hier ist ein weiteres einfaches:

Die Herausforderung

Geben Sie bei zwei Punkten in einem n-dimensionalen Raum den Abstand zwischen ihnen aus, der auch als euklidischer Abstand bezeichnet wird.

• Die Koordinaten sind rationale Zahlen; Die einzigen Grenzen sind die Einschränkungen Ihrer Sprache.
• Die niedrigste Dimension ist 1, die höchste ist diejenige, mit der Ihre Sprache umgehen kann
• Sie können davon ausgehen, dass die beiden Punkte dieselbe Dimension haben und keine leere Eingabe erfolgt.
• Der Abstand muss mindestens 3 Dezimalstellen betragen. Wenn Ihre Sprache keine Gleitkommazahlen unterstützt, geben Sie die nächste ganze Zahl aus.

Regeln

• Funktion oder Vollprogramm wie gewohnt erlaubt.
• Die Eingabe kann über STDIN, Kommandozeilen- oder Funktionsargumente erfolgen.
• Das Eingabeformat liegt bei Ihnen. Geben Sie an, welches Sie in Ihrer Antwort verwendet haben.
• Die Ausgabe kann durch Drucken auf Standardausgabe oder Rückgabewert erfolgen.
• Dies ist Code-Golf, also gewinnt die niedrigste Anzahl an Bytes! Bei einem Gleichstand gewinnt die frühere Antwort.

Testfälle

Jeder Punkt wird durch eine Liste der Länge n dargestellt.

[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

Viel Spaß beim Codieren!

MATL , 2 Bytes

ZP

Probieren Sie es online !

Die ZPFunktion (entspricht MATLABs pdist2) berechnet alle paarweisen Abstände zwischen zwei Punktmengen, wobei standardmäßig der euklidische Abstand verwendet wird. Jede Menge von Punkten ist eine Matrix und jeder Punkt ist eine Reihe. In diesem Fall wird ein einzelnes Ergebnis erzeugt, nämlich der Abstand zwischen den beiden Punkten.

MATL, 4.0 3 Bytes

Danke für -1 von @AndrasDeak!

-Zn

Liest zwei Vektoren (über die implizite Eingabe, die von angefordert wird -), subtrahiert diese und berechnet die Norm ihrer Differenz mit Zn.

Probieren Sie es online!

Pyth, 2 Bytes

.a

.a - L2-Norm der Vektordifferenz von A [0] und A [1].

Buchstäblich eine Funktion, die dieses Problem löst

Probieren Sie es hier aus.

Gelee , 4 Bytes

_²S½

Probieren Sie es online!

Wie es funktioniert

_²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]&

Eingabe als zwei Listen, Ausgabe als Zahl. Wenn die Eingabe exakt ist (Ganzzahlen, Rationalen usw.), ist auch die Ausgabe exakt. Wenn die Eingabe eine Gleitkommazahl enthält, ist die Ausgabe ebenfalls eine Gleitkommazahl.

Oktave, 15 Bytes

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

Beispiel:

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

Vielen Dank an Dennis für das Speichern von 3 Bytes.

q~.-:mhz

Führen Sie alle Testfälle aus.

Erläuterung

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.

In diesem Tipp erfahren Sie, warum dies :mhfunktioniert.

Haskell, 46 Bytes

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

Haskell, 35 Bytes (von @nimi)

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

Haskell, 31 Bytes

Nimmt wie diese Antwort von Scala Eingaben als Folge von Tupeln

<Hack>

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

</ hack>

Beispiele:

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*⍨(+/-×-)

Dies ist ein dyadischer Funktionszug, der die Vektoren links und rechts nimmt und die euklidische Norm ihrer Differenz zurückgibt.

Erläuterung:

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

Probieren Sie es hier aus

3 Bytes gespart dank Dennis!

J 9 Bytes

+&.*:/-/>

Dies ist eine Funktion, die einen Satz von Koordinaten von dem anderen ( -/>) nimmt und dann eine Summe +unter dem &.Quadrat ausführt *:.

Die Eingabe muss im Format sein , x y z;a b cwo x y zIhr erster Satz von Koordinaten und a b cist die andere.

Java, 130 117 114 107 105 Bytes

Dies ist die naheliegende Lösung. Ich spiele normalerweise nicht in Java, aber ich war gespannt, ob Java die Brainfuck-Version schlagen kann. Scheint nicht so, als hätte ich gute Arbeit geleistet. Vielleicht könnte man die neue Map / Reduce von Java 8 verwenden, um ein paar Bytes zu sparen.

Vielen Dank an @flawr (13 Bytes), @KevinCruijssen (9 Bytes) und @DarrelHoffman (3 Bytes)!

Golf gespielt:

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 Bytes

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

Dies ist eine Funktion, die zwei Arrays akzeptiert und die euklidische Norm ihrer Differenz als Float zurückgibt.

Sie können alle Testfälle sofort Online überprüfen hier .

Golflua , 43 Zeichen

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

Funktioniert mit dem Namen

> 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

Ein Lua-Äquivalent wäre

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

Im Ernst, 12 Bytes

,iZ`i-ª`MΣ√A

Probieren Sie es online!

Erläuterung:

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

Rubin, 52

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

Im Testprogramm

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

Dies ist Golf-Code, aber ich habe Kommentare in das Formular eingefügt --.

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

Dies verwendet den gleichen Algorithmus wie die meisten anderen Programme hier.

Perl 6, 30 29 26 24 Bytes

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

(Danke @ b2gills für 2 weitere verlorene Bytes)

Verwendung

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

Erwartet ein Array von Koordinatenpaaren, eines von jedem Vektor, z [[1, 5], [2, 6], [3, 7], [4, 8]]. Wenn das nicht akzeptabel ist, dann für 42 Bytes:

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

Erwartet zwei Arrays gleicher Länge entsprechend den beiden N-dimensionalen Vektoren, z [1, 2, 3, 4], [5, 6, 7, 8]. Bearbeiten: 3 Bytes dank @ l4m2 gespeichert. (Hat auch niemand meinen Tippfehler bemerkt?)

Python 2, 47 Bytes

Eine einfache Lösung. Die Funktion erwartet 2 Punkte als Folgen von Zahlen und gibt den Abstand zwischen ihnen zurück.

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

Beispiel:

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

6 Zeichen / 13 Bytes

МŰМŷ…ï

Try it here (Firefox only).

Berechnet die Norm der Differenz von Eingabearrays.

Scala, 67 62 Bytes

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

Benötigt Eingabe als Folge / Vektor von var-arg-Tupeln
Beispiel:

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

Eine einfache Lösung mit Linq.

Salbei, 35 Bytes

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

Diese Funktion verwendet 2 Listen als Eingabe und gibt einen symbolischen Ausdruck zurück. Die Entfernung wird berechnet, indem eine Vektorsubtraktion für die Listen durchgeführt und die euklidische Norm des resultierenden Vektors berechnet wird.

Probieren Sie es online aus

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

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

TI-Basic ist eine Token-Sprache .

Fordert zur Eingabe als zwei Listen auf und gibt die euklidische Entfernung zurück, in der sie eingegeben wurden Ans

Erläuterung:

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

Dies ist eine integrierte Funktion zum Berechnen der Distanzmatrix einer beliebigen Eingabematrix. Der Standardwert ist euklidischer Abstand.

Anwendungsbeispiel:

> 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

Wenn Sie sich enttäuscht fühlen, weil es eine integrierte Version ist , dann ist hier eine nicht integrierte (oder zumindest weniger integrierte ...) Version für 22 Bytes (mit Dank an Giuseppe ):

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

Dies ist eine anonyme Funktion, die zwei Vektoren als Eingabe verwendet.

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 Zeichen

Durchlaufen, das Quadrat der Differenz und dann die Wurzel der Summe finden:

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

Mathcad, Bytes

Verwendet den integrierten Vektorgrößenoperator (Absolutwert), um die Größe der Differenz zwischen den beiden Punkten (ausgedrückt als Vektoren) zu berechnen.

Mathcad Golf Größe auf Eis gelegt, bis ich (oder jemand anderes) die Diskussion über Meta eröffnet habe. Der kürzeste Weg (unter der Annahme, dass die Eingabe der Punktvektoren nicht zur Bewertung beiträgt) sind jedoch 3 "Bytes" mit 14 Bytes für die Funktionsversion.

Pyke, 7 Bytes

,A-MXs,

Probieren Sie es hier aus!

Transponieren, Subtrahieren anwenden, Quadrat, Summe, Quadrat.

Ruby, 50 Bytes

Zip, dann map / verkleinern. Verdrängt kaum die andere Ruby-Antwort von @LevelRiverSt um 2 Bytes ...

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

Probieren Sie es online aus