İşte basit bir tane daha:

Meydan okuma

N boyutlu bir uzayda iki nokta verildiğinde, aralarındaki mesafeyi, Öklid mesafesi olarak da adlandırılır.

• Koordinatlar rasyonel sayılar olacaktır; tek sınırlar dilinizin kısıtlamalarıdır.
• En düşük boyut 1, en yüksek dil ne kaldırabilirse
• İki noktanın aynı boyutta olduğunu ve boş girdi olmayacağını varsayabilirsiniz.
• Mesafe en az 3 ondalık basamağa kadar doğru olmalıdır. Diliniz kayan nokta sayılarını desteklemiyorsa, en yakın tam sayıyı verin.

kurallar

• Her zamanki gibi, işlev veya tam programa izin verilir.
• Giriş, STDIN, komut satırı veya işlev argümanlarından alınabilir.
• Giriş biçimi size bağlıdır, cevabınızda hangisini kullandığınızı belirtin.
• Çıktı stdout'a veya geri dönüş değerine yazdırılarak sağlanabilir.
• Bu kod-golf yani en düşük bayt sayma kazanır! Beraberlik durumunda, önceki cevap kazanır.

Test durumları

Her nokta, bir uzunluk listesi ile temsil edilir.

[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

Mutlu Kodlama!

MATL , 2 bayt

ZP

Çevrimiçi deneyin !

ZP(MATLAB en tekabül fonksiyonu pdist2) varsayılan olarak Öklid mesafe kullanarak, nokta iki takım arasındaki tüm ikili mesafeler hesaplar. Her nokta kümesi bir matristir ve her nokta bir satırdır. Bu durumda, iki nokta arasındaki mesafe olan tek bir sonuç üretir.

MATL, 4.0 3 bayt

@AndrasDeak tarafından -1 için teşekkürler!

-Zn

İki vektör okur (bunun istediği örtük girdiyle -) daha sonra bunları çıkarır ve farklarının normunu hesaplar Zn.

Çevrimiçi Deneyin!

Pyth, 2 bayt

.a

.a - A [0] ve A [1] vektör farklarının L2 normu.

Kelimenin tam anlamıyla bu sorunu yapan bir işlev

Burada dene.

Jöle , 4 bayt

_²S½

Çevrimiçi deneyin!

Nasıl çalışır

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

Norm[#-#2]&

İki liste halinde giriş yapın, sayı olarak çıktı alın. Girdi kesin ise (tamsayılar, rasyoneller vb.) Çıktı da kesin olacaktır. Giriş bir kayan noktalı sayı içeriyorsa, çıktı aynı zamanda bir kayan nokta olacaktır.

Oktav, 15 bayt

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

Örnek:

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 bayt

Dennis'e 3 byte kaydettiğin için teşekkürler.

q~.-:mhz

Tüm test durumlarını çalıştırın.

açıklama

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.

Neden :mhişe yaradığını öğrenmek için bu ipucuna bakın .

Haskell, 46 bayt

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

Haskell, 35 bayt (Yazan: @ nimi)

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

Haskell, 31 bayt

Gibi bu Scala cevap , dizilerini bir dizi olarak girdi alır

<Hack>

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

</ Hack>

Örnekler:

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 bayt

.5*⍨(+/-×-)

Bu, vektörleri sola ve sağa alan ve farklılıklarının Öklid normunu döndüren ikili fonksiyon trenidir.

Açıklama:

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

Burada dene

Dennis sayesinde 3 bayt kurtarıldı!

J, 9 bayt

+&.*:/-/>

Bu, bir koordinat kümesini diğerinden ( -/>) alan ve karenin +altında bir toplama yapan bir fonksiyondur .&.*:

Giriş , ilk koordinat grubunuzun ve diğerinin x y z;a b colduğu formatta olmalıdır .x y za b c

Java, 130 117 114 107 105 bayt

Bu açık bir çözümdür. Genellikle Java'da golf oynamam, ancak Java'nın Brainfuck sürümünü geçip geçemeyeceğini görmek merak ettim. O zaman iyi bir iş çıkarmışım gibi görünmüyor .. Belki birileri baytları kurtarmak için Java 8'den yeni Harita / Reduce kullanabilir.

@Flawr (13 bayt), @KevinCruijssen (9 bayt) ve @DarrelHoffman (3 bayt) sayesinde!

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 bayt

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

Bu, iki diziyi kabul eden ve öklid normunu bir şamandıra olarak döndüren bir fonksiyondur.

Bir keresinde çevrimiçi tüm test durumları kontrol edebilirsiniz burada .

golflua , 43 karakter

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

Arayarak çalışır

> 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

Bir Lua eşdeğeri olacaktır

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

Cidden, 12 bayt

,iZ`i-ª`MΣ√A

Çevrimiçi deneyin!

Açıklama:

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

Test programında

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 bayt

Bu kodlanmış bir kod, ancak forma yorum yaptım --.

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

Bu, buradaki diğer programların çoğu ile aynı algoritmayı kullanır.

Perl 6, 30 29 26 24 bayt

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

(Teşekkürler @ b2gills 2 kayıp daha bayt için)

kullanım

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 bayt

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

Örneğin her vektörden bir dizi koordinat çifti bekler [[1, 5], [2, 6], [3, 7], [4, 8]]. Bu kabul edilemezse, 42 bayt için:

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

İki N-boyutlu vektöre karşılık gelen eşit uzunlukta iki dizi bekler, örn [1, 2, 3, 4], [5, 6, 7, 8]. Düzenleme: @ l4m2 sayesinde 3 bayt kaydedildi. (Ayrıca, kimse yazım hatası fark etmedi mi?)

Python 2, 47 bayt

Basit bir çözüm. İşlev, sayı dizisi olarak 2 nokta bekler ve aralarındaki mesafeyi döndürür.

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

Örnek:

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

𝔼𝕊𝕄𝕚𝕟, 6 karakter / 13 bayt

МŰМŷ…ï

Try it here (Firefox only).

Giriş dizileri arasındaki fark normunu hesaplar.

Scala, 67 62 bayt

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

Var-arg tuples dizisi / vektörü olarak giriş yapılmasını gerektirir.
Örnek:

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

C #, 72 bayt

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

Linq kullanarak basit bir çözüm.

Adaçayı, 35 bayt

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

Bu işlev giriş olarak 2 liste alır ve sembolik bir ifade döndürür. Mesafe listelerde vektör çıkarma yapılarak ve elde edilen vektörün Öklid normunun hesaplanmasıyla hesaplanır.

Çevrimiçi deneyin

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

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

TI-Basic belirtilmiş bir dildir .

İki liste olarak giriş yapılmasını ister ve bunları girilen Öklid mesafesini döndürür Ans

Açıklama:

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 bayt

dist

Bu, herhangi bir giriş matrisinin uzaklık matrisini hesaplamak için yerleşik bir fonksiyondur. Varsayılan olarak öklid mesafesine.

Örnek kullanım:

> 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

Yerleşik olduğu için hayal kırıklığına uğramış hissediyorsanız, burada yerleşik olmayan (veya en azından, daha az yerleşik ...) 22 baytlık bir sürüm ( Giuseppe ile ):

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

Bu, giriş olarak iki vektör alan anonim bir işlevdir.

Haskell, 32 bayt

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

Farkın karesini ve ardından toplamın kökünü bulmak için döngüler

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

Mathcad, bayt

İki nokta arasındaki farkın boyutunu (vektörler olarak ifade edilir) hesaplamak için yerleşik vektör büyüklüğü (mutlak değer) operatörünü kullanır.

Mathcad golf büyüklüğü, meta tartışmasını açana kadar (ya da başkası alırsa) dolana kadar beklemede kaldı. Bununla birlikte, en kısa yol (nokta vektörlerinin girişinin skora katkıda bulunmadığını varsayarsak) işlevsel sürüm için 14 bayt olan 3 "bayttır".

Pyke, 7 bayt

,A-MXs,

Burada dene!

Transpoze, çıkarma, harita kare, toplam, sqrt uygulayın.

Ruby, 50 bayt

Sıkıştır, sonra eşle / küçült. Yakında diğer Ruby cevabını @LevelRiverSt 'den 2 byte kadar çıkar ...

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

Çevrimiçi deneyin