यहाँ एक और सरल है:

चुनौती

एन-डायमेंशनल स्पेस में दो बिंदुओं को देखते हुए, उनके बीच की दूरी को आउटपुट करें, जिसे यूक्लिडियन दूरी भी कहा जाता है।

निर्देशांक तर्कसंगत संख्या होंगे; केवल सीमाएँ आपकी भाषा के प्रतिबंध हैं।
निम्नतम आयाम 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

हैप्पी कोडिंग!

— Denker
स्रोत

16

मैं दिमाग लगाकर शॉट दूंगा। आइए देखें कि भयानक राक्षस क्या निकलता है।

— YoYoYonnY

मेरा मानना है कि आप यूक्लिडियन दूरी का मतलब है?

— दोष

3

@flawr हां, बिल्कुल। बस शीर्षक को सरल रखना चाहता था, क्योंकि हर कोई नहीं जानता कि पहली नज़र में क्या है। निश्चित रूप से लिख सकते हैं कि

— चालान में

@DenkerAffe "यदि आपकी प्रोग्रामिंग भाषा फ़्लोटिंग पॉइंट्स का समर्थन नहीं करती है" तो दूरी को वापस करना ठीक है? यह मेरे ब्रेनफैक प्रोग्राम को और अधिक सटीक बना देगा (अन्यथा मुझे किसी प्रकार के अनुमान एल्गोरिदम को लागू करना होगा)।

— योयोयोनी

2

@DenkerAffe मुझे लगता है कि यह कहना सुरक्षित है कि ब्रेनफक एक कोड गोल्फ कभी नहीं जीतेगा। लेकिन यह सिर्फ मजेदार

— रास्ते के

26

MATL , 2 बाइट्स

ZP

इसे ऑनलाइन आज़माएं !

ZPसमारोह (MATLAB के लिए इसी pdist2) अंक के दो सेट के बीच सभी जोड़ो दूरी की गणना करता है, डिफ़ॉल्ट रूप से इयूक्लिडियन दूरी का उपयोग कर। अंकों का प्रत्येक सेट एक मैट्रिक्स है, और प्रत्येक बिंदु एक पंक्ति है। इस मामले में यह एक एकल परिणाम उत्पन्न करता है, जो दो बिंदुओं के बीच की दूरी है।

— लुइस मेंडो
स्रोत

7

कोई भी तरीका यह वास्तविक नहीं है

— मार्टिज़न

6

मैं धैर्यपूर्वक सिंगल-बाइट MATL उत्तर की प्रतीक्षा कर रहा हूं;)

— डीक

2

कभी उन भाषाओं को सुना है जबकि भाषा का मुख्य बिंदु अस्पष्ट कोड गोल्फ समस्याओं को हल करना है? यह बिल्कुल ऐसा लगता है। मुझे आश्चर्य होता है कि क्या गूढ़ भाषाएं इसके लिए वास्तव में मौजूद हैं।

— वैध

1

यह निश्चित रूप से पैसा डालता है जहां मुंह है। अच्छा काम लुइस!

— रायरेंग - मोनिका

1

Pdist2 फंक्शन ने मेरे जीवन को सचमुच बदल दिया जब मैंने इसे पाया ...

— लुइ

15

MATL, 4.0 3 बाइट्स

-1 by @AndrasDeak के लिए धन्यवाद!

-Zn

दो वैक्टर पढ़ता है (अंतर्निहित इनपुट के माध्यम से जो अनुरोध किया जाता है -) फिर उन लोगों को प्रतिस्थापित करता है और उनके अंतर के मान की गणना करता है Zn।

इसे ऑनलाइन आज़माएं!

— flawr
स्रोत

10

कृपया कल को शुरू करें, मैंने पहले ही आज मोटरबोट कर दिया है।

— दोष

3

बहुत देर हो चुकी है ... आप फिर से मोटरबोट पर

— जाएँगे

1

मेरे लिए कुछ अपवित्रताएं बचाएं :-P

— लुइस मेंडो

1

@DenkerAffe एक बाउंटी शिकारी पर कभी भरोसा नहीं करता।

— एंड्रास डेक

1

बाउंटी हंटर्स ... हमें उस मैल की जरूरत नहीं है

— लुइस मेंडो

12

अजगर, 2 बाइट्स

.a

.a - A [0] और A [1] के वेक्टर अंतर का L2 मानदंड।

शाब्दिक रूप से एक फ़ंक्शन जो इस समस्या को करता है

इसे यहाँ आज़माएँ।

— नीला
स्रोत

10

जेली , 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.

— डेनिस
स्रोत

1

ओह। जेली के साथ सिर्फ 4 बाइट्स। मैं यह नहीं देख सकता कि कोई भी इससे बेहतर कैसे कर सकता है।

— लॉज नाइट

7

@CarpetPython जाहिरा तौर पर MATL कर सकते हैं ...

— Denker

1

@CarpetPython और Pyth

— isaacg

9

गणितज्ञ, 11 बाइट्स

Norm[#-#2]&

दो सूचियों के रूप में इनपुट, एक संख्या के रूप में आउटपुट। यदि इनपुट सटीक है (पूर्णांक, तर्कसंगत, आदि) तो आउटपुट भी सटीक होगा। यदि इनपुट में एक फ्लोटिंग-पॉइंट नंबर है, तो आउटपुट फ्लोट भी होगा।

— मार्टिन एंडर
स्रोत

6

EuclideanDistanceअच्छी तरह से भी काम करेगा ... अगर नाम इतना लंबा नहीं था! यदि केवल "मैटेलमैटिका के लिए MATL" होते हैं तो यह एक एकल बाइट =) होगा

— 2012rcampion

1

मैं एक गोल्फ Mathematica- आधारित भाषा पर काम कर रहा हूँ :) :)

— ग्रेग मार्टिन

6

ऑक्टेव, 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

— alephalpha
स्रोत

6

सीजेएम, 11 8 बाइट्स

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काम करता है के लिए देखें ।

— मार्टिन एंडर
स्रोत

यह चाल :mhवास्तव में बहुत अच्छी है

— लुइस मेंडो

6

हास्केल, 46 बाइट्स

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

हास्केल, 35 बाइट्स (@nimi द्वारा)

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

हास्केल, 31 बाइट्स

जैसा इस स्काला जवाब , tuples के एक दृश्य के रूप में इनपुट लेता है

<हैक>

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

</ हैक>

उदाहरण:

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

— YoYoYonnY
स्रोत

13

uncurry ಠ_ಠ जब खाना पकाने मैं कभी कभी एक नहीं रखना चाहती unsalt कार्य करते हैं।

— दोष

@flawr en.wikipedia.org/wiki/Salt_(cryptography) ?

— योयोयोनी

2

map+ uncurry+ zipशायद ही कभी भुगतान करता है, उपयोग zipWithकरें d a=sqrt.sum.zipWith(((^2).).(-))a:।

— निकमी

1

क्या आप एटा कटौती करके बाइट्स के एक और जोड़े को नहीं बचा सकते हैं?

— जे.के.

@jk। निश्चित नहीं ... मुझे ऐसा नहीं लगता, क्योंकि (.)हमेशा एक ऐसा फ़ंक्शन देता है जो केवल एक तर्क देता है ... मुझे लगता है कि आप ऐसा कुछ कर सकते हैं (;););), लेकिन यह वास्तव में इसके लायक नहीं है।

— YoYoYonnY

5

एपीएल, 14 11 बाइट्स

.5*⍨(+/-×-)

यह डाइएडिक फंक्शन ट्रेन है जो वैक्टर को बाईं और दाईं ओर ले जाती है और उनके अंतर का यूक्लिडियन मानदंड लौटाती है।

स्पष्टीकरण:

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

इसे यहाँ आज़माएँ

डेनिस के लिए 3 बाइट्स बचाए गए!

— एलेक्स ए।
स्रोत

.5*⍨(+/-×-)कुछ बाइट्स बचाता है।

— डेनिस

3

क्या यह पहली बार हो सकता है जब मैंने एपीएल कोड पर टिप्पणी की है? वह प्रतीक! मैंने हमेशा एपीएल चरित्र को अजीब पाया है, लेकिन मुझे महसूस नहीं हुआ कि एक खंडित ज़ोंबी उंगली टिप्पणी मार्कर थी। ;-)

— लेवल रिवर सेंट

@steveverrill I <s> टिप्पणी </ s> यहाँ मेरे सभी एपीएल प्रस्तुतियाँ के बारे में ज़ोंबी उंगलियाँ डालें। ¯ \ _ (ツ) _ / ¯

— एलेक्स ए।

@AlexA। खराब संरेखण (गैर-मोनोप्लेस्ड एपीएल वर्णों के कारण) इस बार विशेष रूप से हाथ जैसी उपस्थिति देने के लिए हुआ। आपने इसे 4 लाइनों से घटाकर 3 कर दिया है, और प्रभाव को बर्बाद कर दिया है: -एस आपके इस उत्तर में 4 लाइनें हैं, लेकिन हाथ की तरह उपस्थिति कोडगॉल्फ.स्टैकएक्सचेंज.com/a/70595/15599 वैसे भी नहीं है, मुझे पसंद है कि आपके पास अभी भी आपके कोड में एक ही चरित्र स्माइली है।

— लेवल रिवर सेंट

4

जे, 9 बाइट्स

+&.*:/-/>

यह एक फ़ंक्शन है जो दूसरे से निर्देशांक का एक सेट लेता है ( -/>), और फिर वर्ग के +तहत एक योग करता है ।&.*:

इनपुट उस प्रारूप में होना चाहिए x y z;a b cजहां x y zआपका को-ऑर्डिनेट्स का पहला सेट a b cहै और दूसरा है।

— गैरेथ
स्रोत

चूंकि इनपुट हमेशा एक ही लंबाई के होते हैं, आप ड्रॉप कर सकते हैं >और निर्दिष्ट कर सकते हैं कि इनपुट के रूप में दिया जाना चाहिए x y z,:a b c।

— Bolce Bussiere

4

जावा, 130 117 114 107 105 बाइट्स

यह स्पष्ट समाधान है। मैं आमतौर पर जावा में गोल्फ नहीं करता हूं, लेकिन मैं यह देखने के लिए उत्सुक था कि क्या जावा ब्रेनफैक संस्करण को हरा सकता है। ऐसा लगता नहीं है कि मैंने तब एक अच्छा काम किया है .. शायद कुछ बाइट्स को बचाने के लिए जावा 8 से नए मैप / रिड्यूस का उपयोग किया जा सकता है।

@Flawr (13 बाइट्स), @KevinCruijssen (9 बाइट्स) और @DarrelHoffman (3 बाइट्स) की बदौलत!

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

— ბიმო
स्रोत

2

आप निश्चित रूप से फ़ंक्शन नाम को एक वर्ण में छोटा कर सकते हैं। forपाश को संकुचित होdouble x=0,s;for(int i=0;++i<a.length;s=a[i]-b[i],x+=s*s);

— flawr

1

इस तरह से देखरेख की जाती है। लूप के लिए त्रुटिपूर्ण सुझाव देखें। जावा 8 लैम्ब्डा का उपयोग करते हुए, इसे घटाया जा सकता है: double[]a,b->{double x=0,s;for(int i=0;++i<a.length;s=a[i]-b[i],x+=s*s);return Math.sqrt(x);}कुल 93 बाइट्स के लिए।

— Addison Crump

1

आप public 7 बाइट को बचाने के लिए विधि के सामने हटा सकते हैं , और आप x+=s*sबाहर के लूप को भी रख सकते हैं ताकि आपको for(int i=-1;++i<a.length;s=a[i]-b[i])x+=s*s;-1 बाइट के लिए अल्पविराम (यानी ) की आवश्यकता न हो ।

— केविन क्रूजसेन

1

@Bruce_Forte आह, मैं देख रहा हूँ .. उस मामले में आप इस इस्तेमाल कर सकते हैं: for(int i=0;i<a.length;x+=s*s)s=a[i]-b[i++];(और मैं भी बदल -1करने के लिए 0एक अतिरिक्त बाइट के लिए)

— केविन Cruijssen

1

@ केविनक्रूजसेन ट्रू। मुझे 0ऑपरेटर पूर्ववर्ती नियमों का उपयोग करके परिवर्तन पसंद है! मुझे बाइट्स की एक पूरी बचत करने के लिए धन्यवाद।

— ბიმო

3

जूलिया, 16 बाइट्स

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

यह एक फ़ंक्शन है जो दो सरणियों को स्वीकार करता है और फ्लोट के रूप में उनके अंतर के यूक्लिडियन मानदंड को वापस करता है।

आप एक बार ऑनलाइन यहां सभी परीक्षण मामलों को सत्यापित कर सकते हैं ।

— एलेक्स ए।
स्रोत

आप फ़ंक्शन नाम के रूप में ऑपरेटर का उपयोग करके 3 बाइट्स बचा सकते हैं: इसे ऑनलाइन आज़माएं!

— सूंदर -

3

गोल्फलुआ , ४३ चरस

\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

— काइल कानोस
स्रोत

3

गंभीरता से, 12 बाइट्स

,iZ`i-ª`MΣ√A

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

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

— मै जाऊं
स्रोत

2

रूबी, ५२

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

— स्तर नदी सेंट
स्रोत

2

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

यह उसी एल्गोरिदम का उपयोग करता है जैसे कि अन्य कार्यक्रमों में से अधिकांश।

— एडिसन क्रम्प
स्रोत

2

पर्ल 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

— हॉटकी
स्रोत

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

— ब्रैड गिल्बर्ट 2

2

जावास्क्रिप्ट ईएस 7, 45 ईएस 6, 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]))

दो एन-वैक्टर वैक्टर के अनुरूप समान लंबाई के दो सरणियों की अपेक्षा करता है, जैसे [1, 2, 3, 4], [5, 6, 7, 8]। संपादित करें: @ l4m2 के लिए 3 बाइट्स सहेजे गए। (इसके अलावा, किसी ने भी मेरे टाइपो को नोटिस नहीं किया?)

— नील
स्रोत

इनपुट प्रारूप के विनिर्देश सहित इस फ़ंक्शन को कैसे लागू करें, इस पर एक उदाहरण जोड़ें, क्योंकि यह पहली नज़र में स्पष्ट नहीं है।

— डेनकर

@DenkerAffe क्षमा करें, उस क्लॉज़ को अनदेखा करने के बाद, मैंने उदाहरण के रूप में उसी प्रारूप का उपयोग किया था और उस समय वास्तव में सभी मेरे लिए थे।

— नील

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

— l4m2

2

पायथन 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

— तर्क नाइट
स्रोत

Python3.6 में काम करता है, लेकिन इष्टतम नहीं हो सकता है।

— SIGSTACKFAULT

1

S, 6 चार्ट / 13 बाइट्स

МŰМŷ…ï

Try it here (Firefox only).

इनपुट सरणियों के अंतर के मानदंड की गणना करता है।

— मामा फन रोल
स्रोत

1

स्काला, 67 62 बाइट्स

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

वर-आर्ग ट्यूपल्स के ~~अनुक्रम / वेक्टर के~~ रूप में इनपुट की आवश्यकता है
उदाहरण:

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

— corvus_192
स्रोत

1

सी #, 72 बाइट्स

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

Linq का उपयोग कर एक सरल समाधान।

— ओलिविया ट्रेविन
स्रोत

1

ऋषि, 35 बाइट्स

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

यह फ़ंक्शन इनपुट के रूप में 2 सूची लेता है और एक प्रतीकात्मक अभिव्यक्ति देता है। इस दूरी की गणना सूचियों पर वेक्टर घटाव का प्रदर्शन करके की जाती है और परिणामी वेक्टर के यूक्लिडियन मान की गणना की जाती है।

इसे ऑनलाइन आज़माएं

— मै जाऊं
स्रोत

1

टीआई-बेसिक (TI-84 Plus CE), 15 बाइट्स

Prompt A,B
√(sum((_LA-_LB)²

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)² # 10 bytes, Euclidian distance between points
           #(square root of (sum of (squares of (differences of coordinates))))

— pizzapants184
स्रोत

1

आर, 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"))

यह एक अनाम फ़ंक्शन है जो इनपुट के रूप में दो वैक्टर लेता है।

— rturnbull
स्रोत

function(x,y)norm(x-y,"F")आपके दूसरे संस्करण से छोटा है।

— ग्यूसेप

1

हास्केल, 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

— रोड्रिगो डी अजेवेडो
स्रोत

2

32 बाइट्स

— Angs

@Angs सुधार के लिए धन्यवाद। कुछ छेड़छाड़ के बाद, मुझे 6 और बाइट्स (हटाने mapऔर कोष्ठक द्वारा ) को हटाने का एक तरीका मिला ।

— रोड्रिगो डे अजेवेदो

मुझे फिर से हस्तक्षेप करने का खेद है, लेकिन sqrt$sum$(^2)<$>zipWith(-)एक वैध अनाम फ़ंक्शन नहीं है। अंतर्निहित नियम वास्तव में काफी सरल है: यदि आप लिख सकते हैं f = <mycode>और fबाद में आवश्यक कार्य करते हैं, तो <mycode>एक वैध अनाम फ़ंक्शन है। आपके मामले में आपको जोड़ने की आवश्यकता है f p q = <mycode> p q, इसलिए <mycode>यह स्वयं मान्य नहीं है।

— लकोनी

1

@ लायकोनी आप सही कह रहे हैं। मैंने अपना उत्तर संपादित किया और एंगस के सुझाव का उपयोग किया। यदि आपको इसे छोटा करने का कोई तरीका मिल जाए, तो कृपया मुझे बताएं।

— रॉड्रिगो डे अजेवेडो

0

पायथन 3, 70 चार्ट

लूप्स के माध्यम से, अंतर के वर्ग का पता लगाना और फिर योग की जड़:

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

— टिम
स्रोत

2

कुछ और छोड़ें:sum([(x-y)**2 for x,y in zip(a,b)])**.5

— बेंजामिन

0

मठकाद, बाइट्स

दो बिंदुओं (वैक्टर के रूप में व्यक्त) के बीच अंतर के आकार की गणना करने के लिए अंतर्निहित वेक्टर परिमाण (निरपेक्ष मूल्य) ऑपरेटर का उपयोग करता है।

जब तक मुझे (या किसी और को) मिलता है तब तक मठकद गोल्फ आकार मेटा पर चर्चा को खोलने के लिए गोल होता है। हालांकि, सबसे छोटा तरीका (यह मानते हुए कि बिंदु वैक्टर का इनपुट स्कोर में योगदान नहीं करता है) कार्यात्मक संस्करण के लिए 14 बाइट्स के साथ 3 "बाइट्स" है।

— स्टुअर्ट ब्रुफ़
स्रोत

0

Pyke, 7 बाइट्स

,A-MXs,

यहाँ कोशिश करो!

स्थानांतरण, घटाव लागू करें, नक्शा वर्ग, योग, sqrt।

— नीला
स्रोत

0

रूबी, 50 बाइट्स

जिप, फिर नक्शा / कम करें। 2 बाइट्स से @LevelRiverSt से अन्य रूबी उत्तर को बाहर निकाल दें ...

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

इसे ऑनलाइन आज़माएं

— मूल्य स्याही
स्रोत

एन-आयामी अंतरिक्ष में दो बिंदुओं के बीच की दूरी

चुनौती

नियम

परीक्षण के मामलों

MATL , 2 बाइट्स

MATL, 4.0 3 बाइट्स

अजगर, 2 बाइट्स

जेली , 4 बाइट्स

यह काम किस प्रकार करता है

गणितज्ञ, 11 बाइट्स

ऑक्टेव, 15 बाइट्स

सीजेएम, 11 8 बाइट्स

व्याख्या

हास्केल, 46 बाइट्स

हास्केल, 35 बाइट्स (@nimi द्वारा)

हास्केल, 31 बाइट्स

उदाहरण:

एपीएल, 14 11 बाइट्स

जे, 9 बाइट्स

जावा, 130 117 114 107 105 बाइट्स

जूलिया, 16 बाइट्स

गोल्फलुआ , ४३ चरस

गंभीरता से, 12 बाइट्स

रूबी, ५२

AppleScript, 241 239 बाइट्स

पर्ल 6, 30 29 26 24 बाइट्स

जावास्क्रिप्ट ईएस 7, 45 ईएस 6, 37 बाइट्स

पायथन 2, 47 बाइट्स

S, 6 चार्ट / 13 बाइट्स

स्काला, 67 62 बाइट्स

सी #, 72 बाइट्स

ऋषि, 35 बाइट्स

टीआई-बेसिक (TI-84 Plus CE), 15 बाइट्स

आर, 4 बाइट्स

हास्केल, 32 बाइट्स

पायथन 3, 70 चार्ट

मठकाद, बाइट्स

Pyke, 7 बाइट्स

रूबी, 50 बाइट्स