여기 또 다른 간단한 것이 있습니다.

도전

n 차원 공간에 두 점이 주어지면 그 사이의 거리를 유클리드 거리라고도합니다.

• 좌표는 유리수입니다. 유일한 제한은 언어의 제한입니다.
• 가장 낮은 차원은 1이고, 가장 높은 것은 언어가 처리 할 수있는 모든 것입니다
• 두 점의 치수가 같고 빈 입력이 없다고 가정 할 수 있습니다.
• 거리는 소수점 3 자리 이상이어야합니다. 언어가 부동 소수점 숫자를 지원하지 않으면 가장 가까운 정수를 출력하십시오.

규칙

• 평소처럼 기능 또는 전체 프로그램이 허용됩니다.
• STDIN, 명령 행 또는 함수 인수에서 입력을 가져올 수 있습니다.
• 입력 형식은 사용자에게 달려 있습니다. 답변에 사용한 형식을 지정하십시오.
• stdout 또는 반환 값으로 인쇄하여 출력 할 수 있습니다.
• 이것은 코드 골프 이므로 바이트 수가 가장 적습니다! 동점 인 경우, 빠른 답변이 우선합니다.

테스트 사례

각 점은 길이 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

행복한 코딩!

MATL , 2 바이트

ZP

온라인으로 사용해보십시오 !

이 ZP함수 (MATLAB에 해당 pdist2)는 기본적으로 유클리드 거리를 사용하여 두 점 세트 사이의 모든 쌍 거리를 계산합니다. 각 점 집합은 행렬이고 각 점은 행입니다. 이 경우 두 결과 사이의 거리 인 단일 결과가 생성됩니다.

MATL, 4.0 3 바이트

@AndrasDeak의 -1에 감사드립니다!

-Zn

에서 요청한 암시 적 입력을 통해 두 개의 벡터를 읽은 -다음 해당 벡터 를 빼고와의 차이의 표준을 계산합니다 Zn.

온라인으로 사용해보십시오!

Pyth, 2 바이트

.a

.a -A [0] 및 A [1]의 벡터 차이의 L2 규범.

말 그대로이 문제를 해결하는 기능

여기에서 시도하십시오.

젤리 , 4 바이트

_²S½

온라인으로 사용해보십시오!

작동 원리

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

수학, 11 바이트

Norm[#-#2]&

두 개의 목록으로 입력하고 숫자로 출력합니다. 입력이 정확하면 (정수, 합리적 등) 출력도 정확합니다. 입력에 부동 소수점 숫자가 포함 된 경우 출력도 부동 소수점이됩니다.

옥타브, 15 바이트

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

예:

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 바이트

3 바이트를 절약 해 준 Dennis에게 감사합니다.

q~.-:mhz

모든 테스트 사례를 실행하십시오.

설명

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.

:mh작동 하는 이유 는 이 팁을 참조하십시오 .

하스켈, 46 바이트

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

Haskell, 35 바이트 (By @nimi)

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

하스켈, 31 바이트

이 Scala answer 와 같이 튜플 시퀀스로 입력을받습니다.

<해킹>

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

</ hack>

예 :

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 바이트

.5*⍨(+/-×-)

이것은 왼쪽과 오른쪽의 벡터를 가져 와서 그 차이의 유클리드 표준을 반환하는 2 차원 함수 트레인입니다.

설명:

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

여기 사용해보십시오

Dennis 덕분에 3 바이트를 절약했습니다!

J, 9 바이트

+&.*:/-/>

하나의 좌표를 다른 좌표에서 가져 와서 square under -/>sum을 수행하는 함수 입니다.+&.*:

입력은 형식이어야 좌표의 첫 번째 세트이고 다른 하나입니다.x y z;a b cx y za b c

자바 130 117 114 107 105 바이트

이것이 확실한 해결책입니다. 나는 보통 자바로 골프를 치지 않지만 Java가 Brainfuck 버전을 이길 수 있는지 궁금합니다. 내가 좋은 일을 한 것처럼 보이지는 않습니다. 아마도 Java 8의 새로운 Map / Reduce를 사용하여 바이트를 절약 할 수 있습니다.

@flawr (13 바이트), @KevinCruijssen (9 바이트) 및 @DarrelHoffman (3 바이트) 덕분에!

골프 :

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

언 골프 드 :

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

줄리아, 16 바이트

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

이것은 두 개의 배열을 받아들이고 그 차이의 유클리드 표준을 부동 소수점으로 반환하는 함수입니다.

여기 에서 온라인으로 모든 테스트 사례를 한 번에 확인할 수 있습니다 .

golflua , 43 자

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

그것을 호출하여 작동

> 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

루아에 해당하는 것은

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

정말 12 바이트

,iZ`i-ª`MΣ√A

온라인으로 사용해보십시오!

설명:

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

루비, 52

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

테스트 프로그램에서

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 바이트

이것은 골프 코드이지만 양식에 주석을 넣었습니다 --.

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

여기서 다른 대부분의 프로그램과 동일한 알고리즘을 사용합니다.

Perl 6, 30 29 26 24 바이트

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

(2 바이트를 더 잃어버린 것에 대해 @ b2gills에게 감사합니다)

용법

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

자바 스크립트 ES7, 45 ES6, 37 바이트

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

각 벡터에서 하나씩 좌표 쌍의 배열을 예상합니다 (예 :) [[1, 5], [2, 6], [3, 7], [4, 8]]. 허용되지 않는 경우 42 바이트 :

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

예를 들어, 2 개의 N- 차원 벡터에 대응하는 동일한 길이의 2 개의 어레이를 예상한다 [1, 2, 3, 4], [5, 6, 7, 8]. 편집 : @ l4m2 덕분에 3 바이트가 절약되었습니다. (아무도 내 오타를 눈치 채지 못했습니까?)

파이썬 2, 47 바이트

간단한 해결책. 이 함수는 2 개의 포인트를 일련의 숫자로 예상하고 그 사이의 거리를 반환합니다.

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

예:

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

𝔼𝕊𝕄𝕚𝕟, 6 자 / 13 바이트

МŰМŷ…ï

Try it here (Firefox only).

입력 배열 차이의 표준을 계산합니다.

스칼라, 67 62 바이트

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

var-arg 튜플 의 시퀀스 / 벡터 로 입력이 필요합니다
. 예 :

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

C #, 72 바이트

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

Linq를 사용하는 간단한 솔루션.

세이지, 35 바이트

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

이 함수는 2 개의 목록을 입력으로 사용하여 기호 표현식을 리턴합니다. 거리는 목록에서 벡터 빼기를 수행하고 결과 벡터의 유클리드 표준을 계산하여 계산됩니다.

온라인으로 사용해보십시오

TI 기본 (TI-84 Plus CE), 15 바이트

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

TI-Basic은 토큰 화 된 언어입니다 입니다.

두 개의 목록으로 입력하라는 프롬프트를 표시하고 유클리드 거리를 반환합니다. Ans

설명:

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 바이트

dist

입력 매트릭스의 거리 매트릭스를 계산하는 내장 함수입니다. 기본값은 유클리드 거리입니다.

사용법 예 :

> 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

그것은 내장, 다음 여기 때문에 당신이 경우에있는 거 느낌은 실망 (이 나 적어도 비 내장 적은 내장 ...) 버전을 22 바이트 (감사와 주세페 ) :

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

이것은 두 벡터를 입력으로 사용하는 익명 함수입니다.

하스켈, 32 바이트

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

파이썬 3, 70 자

반복하여 차이의 제곱을 찾은 다음 합계의 근을 찾습니다.

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

Mathcad, 바이트

내장 벡터 크기 (절대 값) 연산자를 사용하여 두 점 사이의 차이 크기를 계산합니다 (벡터로 표시).

메타에 대한 토론을 시작하기 전까지 Mathcad 골프 크기는 그대로 유지됩니다. 그러나 가장 짧은 방법 (점 벡터의 입력이 점수에 영향을 미치지 않는다고 가정)은 3 "bytes"이며 기능 버전은 14 바이트입니다.

파이크, 7 바이트

,A-MXs,

여기 사용해보십시오!

전치, 빼기, 맵 스퀘어, 합계, sqrt를 적용합니다.

루비, 50 바이트

우편 번호를 입력 한 다음지도 / 축소합니다. @LevelRiverSt의 다른 Ruby 답변을 2 바이트만큼 간신히 제거합니다 ...

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

온라인으로 사용해보십시오