这是另一个简单的例子：

挑战

给定n维空间中的两个点，输出它们之间的距离，也称为欧几里得距离。

• 坐标将是有理数；唯一的限制就是您的语言限制。
• 最小尺寸为1，最大尺寸取决于您的语言
• 您可以假设两个点的尺寸相同，并且没有空输入。
• 距离必须正确至少为小数点后3位。如果您的语言不支持浮点数，请输出最接近的整数。

规则

• 与往常一样，允许使用功能或完整程序。
• 输入可以从STDIN，命令行或函数参数中获取。
• 输入格式取决于您，指定您在答案中使用的格式。
• 可以通过打印到标准输出或返回值来提供输出。
• 这是代码高尔夫球，因此最低字节数获胜！如果是平局，则较早的答案为准。

测试用例

每个点由长度为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.

Mathematica，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字节

感谢Dennis节省了3个字节。

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工作原理，请参见此提示。

Haskell，46个字节

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

Haskell，35个字节（通过@nimi）

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

Haskell，31个字节

像这个Scala答案一样，将输入作为一个元组序列

<hack>

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

这是二元函数列，它接受左右向量，并返回它们差的欧几里得范数。

说明：

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

在这里尝试

感谢Dennis，节省了3个字节！

J，9个字节

+&.*:/-/>

此函数从另一个（-/>）获取一组坐标，然后+在&.square 下执行求和*:。

输入的格式应为x y z;a b cwhere x y z是您的第一组坐标，a b c另一组是。

Java中，130个 117 114 107 105字节

这是显而易见的解决方案。我通常不喜欢Java，但我很好奇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

相当于Lua

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-] $_)»²}

（感谢@ b2gills再损失了2个字节）

用法

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个字节

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

期望两个相等长度的数组对应于两个N维向量，例如[1, 2, 3, 4], [5, 6, 7, 8]。编辑：由于@ l4m2，节省了3个字节。（此外，没人注意到我的错字吗？）

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

计算输入数组之差的范数。

Scala，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的简单解决方案。

Sage，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字节的非内置（或至少是内置较少的）版本（感谢Giuseppe）：

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

这是一个匿名函数，需要两个向量作为输入。

Haskell，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

Python 3，70个字符

遍历，找到差的平方，然后求和的根：

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

Mathcad，字节

使用内置的矢量幅度（绝对值）运算符来计算两个点（表示为矢量）之间的差异的大小。

在我（或其他人）开始讨论有关meta的讨论之前，请保持Mathcad的高尔夫规模。但是，最短的方法（假设点向量的输入对得分没有贡献）是3个“字节”，其中14个字节用于功能版本。

Pyke，7个字节

,A-MXs,

在这里尝试！

转置，应用减，映射平方，求和，平方根。

Ruby，50个字节

压缩，然后映射/缩小。勉强地将@LevelRiverSt的其他Ruby答案减少了2个字节...

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

在线尝试