एक 3 डी अंतरिक्ष में रैखिक दूरी से अंक सॉर्ट करें

Question

ऐनक

1. आपके पास x,y,zआकार Sपूर्णांक इकाइयों का घन 3 डी स्थान है , जैसे कि 0 <= x,y,z <= S।
2. आप डिफ़ॉल्ट इनपुट पद्धतियों से पूर्णांक निर्देशांक के Pरूप में प्रतिनिधित्व किए x,y,zगए किसी भी बिंदु , उदाहरण के लिए, किसी भी उचित प्रारूप में प्राप्त कर सकते हैं [x1,y1,z1],[x2,y2,z2],[x3,y3,z3] ... [xn,yn,zn]:।
3. सभी Pमान ऊपर दिए गए क्यूबिक 3 डी स्पेस में होंगे, जैसे कि 0 <= x,y,z <= S।
4. संभव कुल संख्या Pहोगी ।1 <= P <= S3
5. आपको आधार बिंदु और 3 डी क्यूब आकार के x,y,zपूर्णांक निर्देशांक इनपुट के रूप में भी मिलते हैं । BS

कार्य

आपका लक्ष्य आउटपुट के लिए है, आपके पसंदीदा प्रारूप में, बेस पॉइंटP से रैखिक (यूक्लिडियन) की दूरी के अनुसार अंक । B

नियम

1. यदि आपको एक से अधिक बिंदु मिलते Pहैं जो आपके लिए समान हैं, Bतो आपको Pअपने पसंदीदा क्रम में सभी समतुल्य का उत्पादन करना होगा ।
2. यह संभव है कि एक बिंदु Pके साथ मेल खाना B, ताकि उनकी दूरी हो 0, आपको उस बिंदु को आउटपुट करना होगा।
3. यह एक कोड-गोल्फ चुनौती है, इसलिए सबसे छोटा कोड जीतता है।
4. मानक खामियों को मना किया जाता है।
5. कोड स्पष्टीकरण की सराहना की जाती है।

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

Input:
S (size), [B (base point x,y,z)], [P1 (x,y,z)], [P2], [P3], [P4], [P5], [...], [Pn]
10, [5,5,5], [0,0,0], [10,10,10], [2,0,8], [10,3,1], [4,4,5], [5,5,5], [5,5,4]

Output:
[5,5,5], [5,5,4], [4,4,5], [2,0,8], [10,3,1], [0,0,0], [10,10,10]

- - -

Input:
5, [2, 3, 3], [3, 0, 4], [5, 0, 3], [0, 2, 4], [0, 3, 5], [4, 2, 1], [2, 2, 2], [3, 1, 2], [3, 1, 0], [1, 3, 2], [2, 3, 1], [3, 1, 5], [4, 0, 0], [4, 3, 1], [0, 5, 5], [1, 5, 1], [3, 1, 4], [2, 2, 2], [0, 2, 5], [3, 3, 5], [3, 3, 0], [5, 4, 5], [4, 1, 3], [5, 1, 1], [3, 5, 3], [1, 5, 3], [0, 5, 2], [4, 3, 3], [2, 1, 1], [3, 3, 0], [5, 0, 4], [1, 5, 2], [4, 2, 3], [4, 2, 1], [2, 5, 5], [3, 4, 0], [3, 0, 2], [2, 3, 2], [3, 5, 1], [5, 1, 0], [2, 4, 3], [1, 0, 5], [0, 2, 5], [3, 4, 4], [2, 4, 0], [0, 1, 5], [0, 5, 4], [1, 5, 1], [2, 1, 0], [1, 3, 4], [2, 2, 2], [4, 2, 4], [5, 5, 4], [4, 4, 0], [0, 4, 1], [2, 0, 3], [3, 1, 5], [4, 4, 0], [2, 5, 1], [1, 2, 4], [4, 3, 1], [0, 2, 4], [4, 5, 2], [2, 0, 1], [0, 0, 2], [4, 1, 0], [5, 4, 3], [2, 5, 2], [5, 4, 4], [4, 4, 3], [5, 5, 1], [4, 0, 2], [1, 3, 5], [4, 2, 0], [0, 3, 1], [2, 2, 0], [0, 4, 5], [3, 2, 0], [0, 2, 1], [1, 2, 2], [2, 5, 3], [5, 5, 2], [5, 2, 4], [4, 5, 5], [2, 1, 2], [5, 4, 3], [4, 5, 4], [2, 3, 1], [4, 4, 4], [3, 0, 0], [2, 4, 5], [4, 3, 3], [3, 5, 3], [4, 0, 0], [1, 1, 1], [3, 1, 3], [2, 5, 5], [0, 0, 5], [2, 0, 2], [1, 0, 3], [3, 1, 4], [1, 2, 5], [4, 1, 3], [1, 4, 5], [3, 1, 4], [3, 5, 1], [5, 1, 4], [1, 0, 4], [2, 2, 0], [5, 2, 1], [0, 5, 3], [2, 1, 1], [0, 3, 0], [4, 5, 5], [3, 4, 2], [5, 3, 3], [3, 1, 1], [4, 0, 1], [5, 0, 5], [5, 0, 4], [1, 4, 3], [5, 4, 2], [5, 4, 0], [5, 1, 0], [0, 0, 1], [5, 3, 0]

Output:
[2, 4, 3], [2, 3, 2], [1, 3, 4], [1, 3, 2], [2, 2, 2], [1, 4, 3], [2, 2, 2], [2, 2, 2], [1, 2, 2], [3, 4, 2], [1, 2, 4], [3, 4, 4], [2, 5, 3], [4, 3, 3], [2, 3, 1], [4, 3, 3], [2, 3, 1], [1, 3, 5], [4, 4, 3], [2, 5, 2], [3, 1, 3], [1, 5, 3], [4, 2, 3], [2, 1, 2], [3, 5, 3], [2, 4, 5], [3, 3, 5], [3, 5, 3], [3, 1, 4], [0, 2, 4], [0, 2, 4], [1, 2, 5], [3, 1, 2], [3, 1, 4], [3, 1, 4], [4, 2, 4], [1, 4, 5], [4, 4, 4], [1, 5, 2], [4, 3, 1], [0, 5, 3], [2, 1, 1], [4, 1, 3], [4, 3, 1], [2, 5, 5], [0, 3, 5], [4, 1, 3], [2, 5, 1], [2, 1, 1], [0, 3, 1], [2, 5, 5], [1, 1, 1], [0, 4, 5], [4, 5, 4], [4, 5, 2], [0, 2, 1], [1, 5, 1], [5, 3, 3], [0, 5, 2], [3, 5, 1], [3, 5, 1], [0, 2, 5], [1, 5, 1], [4, 2, 1], [3, 1, 5], [3, 1, 1], [0, 2, 5], [4, 2, 1], [0, 5, 4], [0, 4, 1], [2, 0, 3], [3, 1, 5], [2, 4, 0], [2, 2, 0], [2, 0, 2], [3, 3, 0], [3, 3, 0], [5, 4, 3], [1, 0, 3], [5, 4, 3], [2, 2, 0], [3, 0, 2], [5, 4, 4], [5, 4, 2], [1, 0, 4], [3, 0, 4], [5, 2, 4], [3, 2, 0], [3, 4, 0], [0, 1, 5], [0, 5, 5], [4, 5, 5], [4, 5, 5], [0, 3, 0], [2, 0, 1], [2, 1, 0], [4, 4, 0], [5, 1, 4], [5, 5, 4], [5, 2, 1], [3, 1, 0], [5, 4, 5], [4, 4, 0], [1, 0, 5], [4, 2, 0], [0, 0, 2], [4, 0, 2], [5, 5, 2], [4, 1, 0], [5, 5, 1], [0, 0, 1], [5, 1, 1], [4, 0, 1], [0, 0, 5], [5, 0, 3], [5, 3, 0], [5, 4, 0], [3, 0, 0], [5, 0, 4], [5, 0, 4], [5, 1, 0], [4, 0, 0], [4, 0, 0], [5, 0, 5], [5, 1, 0]

- - -

Input:
10, [1, 9, 4], [4, 6, 2], [7, 5, 3], [10, 5, 2], [9, 8, 9], [10, 5, 10], [1, 5, 4], [8, 1, 1], [8, 6, 9], [10, 4, 1], [3, 4, 10], [4, 7, 0], [7, 10, 9], [5, 7, 3], [6, 7, 9], [5, 1, 4], [4, 3, 8], [4, 4, 9], [6, 9, 3], [8, 2, 6], [3, 5, 1], [0, 9, 0], [8, 4, 3], [0, 1, 1], [6, 7, 6], [4, 6, 10], [3, 9, 10], [8, 3, 1], [10, 1, 1], [9, 10, 6], [2, 3, 9], [10, 5, 0], [3, 2, 1], [10, 2, 7], [8, 4, 9], [5, 2, 4], [0, 8, 9], [10, 1, 6], [0, 8, 10], [5, 10, 1], [7, 4, 5], [4, 5, 2], [0, 2, 0], [8, 3, 3], [6, 6, 6], [3, 0, 2], [0, 1, 1], [10, 10, 8], [6, 2, 8], [8, 8, 6], [5, 4, 7], [10, 7, 4], [0, 9, 2], [1, 6, 6], [8, 5, 9], [3, 7, 4], [5, 6, 6], [3, 1, 1], [10, 4, 5], [1, 5, 7], [8, 6, 6], [4, 3, 7], [2, 1, 0], [6, 4, 2], [0, 7, 8], [8, 3, 6], [9, 2, 0], [1, 3, 8], [4, 4, 6], [5, 8, 9], [9, 4, 4], [0, 7, 3], [8, 3, 4], [6, 7, 9], [8, 7, 0], [0, 7, 7], [8, 10, 10], [10, 2, 5], [6, 9, 5], [6, 2, 7], [0, 9, 6], [1, 4, 1], [4, 3, 1], [5, 7, 3], [9, 6, 8], [4, 1, 7], [4, 0, 8], [3, 4, 7], [2, 3, 6], [0, 0, 7], [5, 3, 6], [7, 3, 4], [6, 7, 8], [3, 7, 9], [1, 9, 10], [2, 1, 2], [2, 8, 2], [0, 3, 0], [1, 1, 9], [3, 5, 2], [10, 5, 3], [5, 2, 9], [6, 9, 0], [9, 5, 0], [7, 1, 10], [3, 3, 8], [2, 5, 1], [3, 10, 10], [6, 2, 2], [10, 7, 2], [4, 3, 1], [4, 2, 1], [4, 2, 8], [6, 8, 5], [3, 10, 0], [1, 1, 7], [6, 9, 6], [6, 2, 4], [5, 5, 7], [5, 4, 5], [9, 8, 1], [9, 8, 1], [0, 10, 6], [1, 1, 9], [3, 8, 8], [3, 1, 5], [5, 7, 4], [4, 3, 6], [5, 4, 7], [6, 0, 8], [7, 8, 1], [9, 8, 4], [2, 10, 0], [3, 4, 5], [9, 3, 10], [7, 4, 1], [2, 1, 9], [10, 8, 1], [10, 3, 7], [2, 0, 6], [3, 8, 4], [10, 0, 2], [9, 9, 10], [8, 9, 5], [4, 10, 2], [8, 3, 4], [4, 2, 10], [9, 1, 6], [6, 1, 3], [4, 1, 3], [2, 9, 0], [5, 6, 5], [8, 8, 3], [5, 5, 0], [7, 6, 9], [1, 1, 5], [3, 0, 4], [1, 10, 6], [8, 0, 2], [0, 7, 3], [8, 9, 8], [2, 1, 8], [3, 1, 10], [4, 5, 9], [7, 6, 10], [3, 6, 10], [5, 9, 8], [9, 3, 3], [2, 2, 3], [9, 9, 0], [7, 2, 2], [0, 0, 9], [8, 7, 4], [9, 2, 9], [0, 6, 4], [9, 4, 3], [10, 1, 3], [5, 9, 10], [5, 10, 6], [6, 3, 10], 

Output: 
[1, 10, 6], [3, 8, 4], [0, 9, 6], [0, 9, 2], [2, 8, 2], [0, 7, 3], [0, 7, 3], [0, 10, 6], [3, 7, 4], [0, 6, 4], [1, 6, 6], [0, 7, 7], [4, 10, 2], [1, 5, 4], [0, 9, 0], [2, 9, 0], [2, 10, 0], [5, 7, 4], [5, 7, 3], [5, 10, 6], [5, 7, 3], [0, 7, 8], [3, 10, 0], [3, 8, 8], [4, 6, 2], [3, 5, 2], [1, 5, 7], [5, 10, 1], [6, 9, 3], [6, 9, 5], [5, 6, 5], [2, 5, 1], [0, 8, 9], [6, 8, 5], [5, 6, 6], [6, 9, 6], [4, 5, 2], [4, 7, 0], [3, 5, 1], [3, 4, 5], [5, 9, 8], [6, 7, 6], [3, 7, 9], [1, 4, 1], [1, 9, 10], [4, 4, 6], [0, 8, 10], [6, 6, 6], [3, 4, 7], [3, 9, 10], [5, 5, 7], [3, 10, 10], [2, 3, 6], [6, 9, 0], [5, 8, 9], [5, 4, 5], [6, 7, 8], [7, 8, 1], [5, 5, 0], [4, 3, 6], [3, 6, 10], [8, 9, 5], [5, 4, 7], [4, 5, 9], [5, 4, 7], [2, 2, 3], [8, 8, 3], [1, 3, 8], [5, 9, 10], [0, 3, 0], [7, 5, 3], [8, 7, 4], [4, 3, 1], [8, 8, 6], [6, 4, 2], [4, 3, 7], [6, 7, 9], [4, 6, 10], [4, 3, 1], [6, 7, 9], [3, 3, 8], [5, 3, 6], [4, 4, 9], [4, 3, 8], [8, 6, 6], [3, 2, 1], [7, 4, 5], [7, 10, 9], [2, 3, 9], [5, 2, 4], [1, 1, 5], [3, 4, 10], [8, 9, 8], [9, 8, 4], [0, 2, 0], [4, 2, 1], [3, 1, 5], [2, 1, 2], [8, 7, 0], [9, 10, 6], [7, 4, 1], [7, 6, 9], [7, 3, 4], [1, 1, 7], [0, 1, 1], [4, 2, 8], [9, 8, 1], [0, 1, 1], [4, 1, 3], [6, 2, 4], [9, 8, 1], [8, 4, 3], [3, 1, 1], [6, 2, 2], [5, 1, 4], [9, 9, 0], [7, 6, 10], [2, 1, 0], [2, 1, 8], [4, 1, 7], [8, 6, 9], [6, 2, 7], [8, 3, 4], [8, 3, 4], [10, 7, 4], [3, 0, 4], [8, 3, 3], [8, 10, 10], [2, 0, 6], [9, 6, 8], [10, 7, 2], [1, 1, 9], [8, 3, 6], [1, 1, 9], [7, 2, 2], [3, 0, 2], [9, 4, 4], [8, 5, 9], [2, 1, 9], [6, 1, 3], [6, 2, 8], [5, 2, 9], [9, 4, 3], [9, 8, 9], [0, 0, 7], [10, 8, 1], [4, 2, 10], [8, 3, 1], [9, 5, 0], [6, 3, 10], [10, 10, 8], [10, 5, 3], [8, 4, 9], [9, 9, 10], [10, 5, 2], [9, 3, 3], [8, 2, 6], [3, 1, 10], [4, 0, 8], [0, 0, 9], [10, 4, 5], [10, 5, 0], [10, 4, 1], [8, 1, 1], [6, 0, 8], [10, 3, 7], [9, 2, 0], [10, 2, 5], [9, 1, 6], [10, 5, 10], [8, 0, 2], [9, 3, 10], [7, 1, 10], [9, 2, 9], [10, 2, 7], [10, 1, 3], [10, 1, 6], [10, 1, 1], [10, 0, 2]

- - -

Input:
10000, [8452, 3160, 6109], [7172, 5052, 4795], [9789, 4033, 2952], [8242, 213, 3835], [177, 7083, 908], [3788, 3129, 3018], [9060, 464, 2701], [6537, 8698, 291], [9048, 3860, 6099], [4600, 2696, 4854], [2319, 3278, 9825]

Output:
[9048, 3860, 6099], [7172, 5052, 4795], [9789, 4033, 2952], [8242, 213, 3835], [4600, 2696, 4854], [9060, 464, 2701], [3788, 3129, 3018], [2319, 3278, 9825], [6537, 8698, 291], [177, 7083, 908]

Comments

क्या Sपैरामीटर के रूप में लेना वास्तव में आवश्यक है ?

— क्रिस्टियन लुपस्क्यू

@ गॉलवॉल्फ यदि आपको इसकी आवश्यकता नहीं है, तो इसे न लें।

— मारियो

मैं दृढ़ता से यह निर्दिष्ट करने की सलाह दूंगा कि आप किस प्रकार की मीट्रिक का उपयोग करना चाहते हैं। कुछ लोग यूक्लिडियन मीट्रिक (ρ = ([(x₂-x²) ² + (y₂-y²) ₂ + (z₁-z₂))] का उपयोग करते हैं, अन्य लोग मैनहट्टन मीट्रिक का उपयोग करते हैं (ρ =-x₁-x₂ | + +-y₁-y₂ | + | z₁-z₂ |) | मेरी राय में सभी को एक ही मीट्रिक का उपयोग करना चाहिए।

— रामलीज

@ रामलीला: चुनौती रैखिक दूरी को निर्दिष्ट करती है जो मेरे दिमाग में यूक्लिडियन है । मैं मैनहट्टन को रैखिक नहीं कहूंगा , लेकिन मैं मानता हूं कि विशेष रूप से निर्दिष्ट करने के लिए जो मीट्रिक का उपयोग करना है, उसे चुनौती को गलत समझना मुश्किल बना देना चाहिए।

— Emigna

रैखिक मत कहो, यूक्लिडियन कहो।

— लिंडन व्हाइट

Answer 1

05AB1E , 4 बाइट्स

ΣαnO

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

व्याख्या

Σ        # sort by
   O     # sum of
  n      # square of
 α       # absolute difference between current value and second input

Comments

आपको आवश्यकता क्यों है n?

— एरिक आउटगॉल्फ

@EriktheOutgolfer: हो सकता है कि यह छोटा उदाहरण स्क्वेरिंग और नहीं के बीच का अंतर दिखा सके।

— एमीना

तो, क्या हर कोई इसे गलत कर रहा है या हर कोई इसे सही कर रहा है?

— आउटगॉल्फ

@EriktheOutgolfer: मैंने सभी उत्तरों की जाँच नहीं की है, लेकिन अधिकांश सही प्रतीत होते हैं।

— एमिग्ना

कई उत्तर चौकोर नहीं होते, इसीलिए मैंने पूछा, क्योंकि वे ठीक उसी एल्गोरिथ्म का उपयोग कर रहे हैं।

— को आउटगॉल्फ

Answer 2

जावास्क्रिप्ट (ईएस 6), 71 बाइट्स

(b,a,g=a=>a.reduce((d,c,i)=>d+(c-=b[i])*c,0))=>a.sort((b,a)=>g(b)-g(a))

Comments

मुझे लगता है कि आप करी और gअंदर की परिभाषा का उपयोग करके एक बाइट को बचा सकते हैं sort।

@ ThePirateBay: नील करी नहीं करता है!

— शैगी

Answer 3

हास्केल , 54 52 बाइट्स

import Data.List
f o=sortOn(sum.map(^2).zipWith(-)o)

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

मुझे अंतरिक्ष के आकार की आवश्यकता नहीं है। sum.map(^2).zipWith(-)oकरने के लिए एक बिंदु से दूरी की गणना करता है o: (xo-xp)^2+(yo-yp)^2+(zo-zp)^2। की दूरी पर बिंदुओं को क्रमबद्ध किया जाता है o।

संपादित करें : "यदि आपको इसकी आवश्यकता नहीं है, तो इसे न लें" 2 बाइट्स बचाए।

Answer 4

पायथन 3 , 68 64 बाइट्स

-4 बाइट्स @Ramillies की बदौलत

def f(b,l):l.sort(key=lambda p:sum((a-b)**2for a,b in zip(b,p)))

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

Answer 5

आर , 56 40 बाइट्स

-16 बाइट्स एक अलग इनपुट प्रारूप का सुझाव देने के लिए flodel के लिए धन्यवाद

function(P,B)P[,order(colSums((P-B)^2))]

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

अंक के Pएक 3xnमैट्रिक्स के रूप में लेता है , अर्थात, प्रत्येक स्तंभ एक बिंदु है; आउटपुट एक ही प्रारूप में है।

परीक्षण मामलों से gबिंदुओं की सूची Pको उपयुक्त आर प्रारूप में बदलने के लिए सहायक फ़ंक्शन का उपयोग करें ।

Comments

शायद के sapply()साथ बदलें colSums((t(P)-B)^2), जहां इनपुट Pएक मैट्रिक्स होगा?

— फ्लोडेल

@flodel अगर मैं ऐसा करने जा रहा हूं, तो मैं Pएक 3xnमैट्रिक्स के रूप में भी ले सकता हूं और सिर्फ इसके colSums((P-B)^2)बजाय!

— Giuseppe

Answer 6

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

xN@Norm[#-x]&//SortBy

प्रारूप में इनपुट लेता है f[B][P]।

xनेस्टेड फ़ंक्शन बनाने के लिए हमें 4 बाइट्स का उपयोग करना होगा।  ( \[Function]और) की पूर्वता// अच्छी तरह से काम करती है ताकि अभिव्यक्ति इसके बराबर हो:

Function[x, SortBy[N@Norm[# - x]&] ]

हमें इसकी आवश्यकता है Nक्योंकि डिफ़ॉल्ट रूप से, मूल्य के बजाय अभिव्यक्ति संरचना के आधार पर गणितज्ञ प्रकार:

Sort[{1, Sqrt@2, 2}]
{1, 2, Sqrt[2]}

SortBy[N][{1, Sqrt@2, 2}]
{1, Sqrt[2], 2}

Answer 7

सी # (.NET कोर) , 68 57 53 + 23 18 बाइट्स

-11 बाइट्स एमिग्ना के लिए धन्यवाद

B=>P=>P.OrderBy(p=>p.Zip(B,(x,y)=>(x-y)*(x-y)).Sum())

बाइट काउंट में भी शामिल है

using System.Linq;

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

अंक को चींटियों के संग्रह के रूप में माना जाता है। स्पष्टीकरण:

B => P =>                          // Take the base point and a collection of points to sort
    P.OrderBy(p =>                 // Order the points by:
        p.Zip(B, (x, y) =>         //     Take each point and combine it with the base:
            (x - y) * (x - y)      //         Take each dimension and measure their distance squared
        ).Sum()                    //     Sum of the distances in each dimension together
    )

Answer 8

जावास्क्रिप्ट (ईएस 6), 72 71 बाइट्स

यह एक नील के उत्तर से कम नहीं है , लेकिन मुझे लगा कि मैं इसे वैसे भी उपयोग करने के लिए पोस्ट करूंगा Math.hypot(), जिसे ES6 में पेश किया गया था।

वाक्य रचना currying में इनपुट लेता है (p)(a), जहां पी = [एक्स, वाई, z] आधार बिंदु है और एक अन्य बिंदुओं की सरणी है।

p=>a=>a.sort((a,b)=>(g=a=>Math.hypot(...a.map((v,i)=>v-p[i])))(a)-g(b))

let f =

p=>a=>a.sort((a,b)=>(g=a=>Math.hypot(...a.map((v,i)=>v-p[i])))(a)-g(b))

console.log(JSON.stringify(f([5, 5, 5])([[0, 0, 0], [10, 10, 10], [2, 0, 8], [10, 3, 1], [4, 4, 5], [5, 5, 5], [5, 5, 4]])))

console.log(JSON.stringify(f([2, 3, 3])([[3, 0, 4], [5, 0, 3], [0, 2, 4], [0, 3, 5], [4, 2, 1], [2, 2, 2], [3, 1, 2], [3, 1, 0], [1, 3, 2], [2, 3, 1], [3, 1, 5], [4, 0, 0], [4, 3, 1], [0, 5, 5], [1, 5, 1], [3, 1, 4], [2, 2, 2], [0, 2, 5], [3, 3, 5], [3, 3, 0], [5, 4, 5], [4, 1, 3], [5, 1, 1], [3, 5, 3], [1, 5, 3], [0, 5, 2], [4, 3, 3], [2, 1, 1], [3, 3, 0], [5, 0, 4], [1, 5, 2], [4, 2, 3], [4, 2, 1], [2, 5, 5], [3, 4, 0], [3, 0, 2], [2, 3, 2], [3, 5, 1], [5, 1, 0], [2, 4, 3], [1, 0, 5], [0, 2, 5], [3, 4, 4], [2, 4, 0], [0, 1, 5], [0, 5, 4], [1, 5, 1], [2, 1, 0], [1, 3, 4], [2, 2, 2], [4, 2, 4], [5, 5, 4], [4, 4, 0], [0, 4, 1], [2, 0, 3], [3, 1, 5], [4, 4, 0], [2, 5, 1], [1, 2, 4], [4, 3, 1], [0, 2, 4], [4, 5, 2], [2, 0, 1], [0, 0, 2], [4, 1, 0], [5, 4, 3], [2, 5, 2], [5, 4, 4], [4, 4, 3], [5, 5, 1], [4, 0, 2], [1, 3, 5], [4, 2, 0], [0, 3, 1], [2, 2, 0], [0, 4, 5], [3, 2, 0], [0, 2, 1], [1, 2, 2], [2, 5, 3], [5, 5, 2], [5, 2, 4], [4, 5, 5], [2, 1, 2], [5, 4, 3], [4, 5, 4], [2, 3, 1], [4, 4, 4], [3, 0, 0], [2, 4, 5], [4, 3, 3], [3, 5, 3], [4, 0, 0], [1, 1, 1], [3, 1, 3], [2, 5, 5], [0, 0, 5], [2, 0, 2], [1, 0, 3], [3, 1, 4], [1, 2, 5], [4, 1, 3], [1, 4, 5], [3, 1, 4], [3, 5, 1], [5, 1, 4], [1, 0, 4], [2, 2, 0], [5, 2, 1], [0, 5, 3], [2, 1, 1], [0, 3, 0], [4, 5, 5], [3, 4, 2], [5, 3, 3], [3, 1, 1], [4, 0, 1], [5, 0, 5], [5, 0, 4], [1, 4, 3], [5, 4, 2], [5, 4, 0], [5, 1, 0], [0, 0, 1], [5, 3, 0]])))

console.log(JSON.stringify(f([1, 9, 4])([[4, 6, 2], [7, 5, 3], [10, 5, 2], [9, 8, 9], [10, 5, 10], [1, 5, 4], [8, 1, 1], [8, 6, 9], [10, 4, 1], [3, 4, 10], [4, 7, 0], [7, 10, 9], [5, 7, 3], [6, 7, 9], [5, 1, 4], [4, 3, 8], [4, 4, 9], [6, 9, 3], [8, 2, 6], [3, 5, 1], [0, 9, 0], [8, 4, 3], [0, 1, 1], [6, 7, 6], [4, 6, 10], [3, 9, 10], [8, 3, 1], [10, 1, 1], [9, 10, 6], [2, 3, 9], [10, 5, 0], [3, 2, 1], [10, 2, 7], [8, 4, 9], [5, 2, 4], [0, 8, 9], [10, 1, 6], [0, 8, 10], [5, 10, 1], [7, 4, 5], [4, 5, 2], [0, 2, 0], [8, 3, 3], [6, 6, 6], [3, 0, 2], [0, 1, 1], [10, 10, 8], [6, 2, 8], [8, 8, 6], [5, 4, 7], [10, 7, 4], [0, 9, 2], [1, 6, 6], [8, 5, 9], [3, 7, 4], [5, 6, 6], [3, 1, 1], [10, 4, 5], [1, 5, 7], [8, 6, 6], [4, 3, 7], [2, 1, 0], [6, 4, 2], [0, 7, 8], [8, 3, 6], [9, 2, 0], [1, 3, 8], [4, 4, 6], [5, 8, 9], [9, 4, 4], [0, 7, 3], [8, 3, 4], [6, 7, 9], [8, 7, 0], [0, 7, 7], [8, 10, 10], [10, 2, 5], [6, 9, 5], [6, 2, 7], [0, 9, 6], [1, 4, 1], [4, 3, 1], [5, 7, 3], [9, 6, 8], [4, 1, 7], [4, 0, 8], [3, 4, 7], [2, 3, 6], [0, 0, 7], [5, 3, 6], [7, 3, 4], [6, 7, 8], [3, 7, 9], [1, 9, 10], [2, 1, 2], [2, 8, 2], [0, 3, 0], [1, 1, 9], [3, 5, 2], [10, 5, 3], [5, 2, 9], [6, 9, 0], [9, 5, 0], [7, 1, 10], [3, 3, 8], [2, 5, 1], [3, 10, 10], [6, 2, 2], [10, 7, 2], [4, 3, 1], [4, 2, 1], [4, 2, 8], [6, 8, 5], [3, 10, 0], [1, 1, 7], [6, 9, 6], [6, 2, 4], [5, 5, 7], [5, 4, 5], [9, 8, 1], [9, 8, 1], [0, 10, 6], [1, 1, 9], [3, 8, 8], [3, 1, 5], [5, 7, 4], [4, 3, 6], [5, 4, 7], [6, 0, 8], [7, 8, 1], [9, 8, 4], [2, 10, 0], [3, 4, 5], [9, 3, 10], [7, 4, 1], [2, 1, 9], [10, 8, 1], [10, 3, 7], [2, 0, 6], [3, 8, 4], [10, 0, 2], [9, 9, 10], [8, 9, 5], [4, 10, 2], [8, 3, 4], [4, 2, 10], [9, 1, 6], [6, 1, 3], [4, 1, 3], [2, 9, 0], [5, 6, 5], [8, 8, 3], [5, 5, 0], [7, 6, 9], [1, 1, 5], [3, 0, 4], [1, 10, 6], [8, 0, 2], [0, 7, 3], [8, 9, 8], [2, 1, 8], [3, 1, 10], [4, 5, 9], [7, 6, 10], [3, 6, 10], [5, 9, 8], [9, 3, 3], [2, 2, 3], [9, 9, 0], [7, 2, 2], [0, 0, 9], [8, 7, 4], [9, 2, 9], [0, 6, 4], [9, 4, 3], [10, 1, 3], [5, 9, 10], [5, 10, 6], [6, 3, 10]])))

console.log(JSON.stringify(f([8452, 3160, 6109])([[7172, 5052, 4795], [9789, 4033, 2952], [8242, 213, 3835], [177, 7083, 908], [3788, 3129, 3018], [9060, 464, 2701], [6537, 8698, 291], [9048, 3860, 6099], [4600, 2696, 4854], [2319, 3278, 9825]])))

Answer 9

k , 14 बाइट्स

{y@<+/x*x-:+y}

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

{            } /function(x,y)
           +y  /transpose y
        x-:    /w[j,i] = x[j] - y[j,i]
      x*       /w[j,i]*w[j,i]
    +/         /v[i] = sum over all j: w[j,i]
   <           /indices to sort by
 y@            /rearrange list of points by indices

इसके अलावा, यह n आयामों के लिए काम करता है, और 3 तक सीमित नहीं है।

Answer 10

जाप , १० 9 बाइट्स

-1 बाइट @ शुगी को धन्यवाद

ñ_íaV m²x

उस क्रम में तीन-आइटम सरणियों के एक बिंदु के रूप में बिंदु और आधार एक एकल सरणी को इंगित करता है। आकार तर्क नहीं लेता है।

इसे ऑनलाइन आज़माएं! या एक उत्पादन के साथ बहुत बड़ा परीक्षण मामला चलाते हैं-Rx,y,z प्रति पंक्ति ।

व्याख्या

ñ_            Sort the input array as if each item were mapped through the function...
  í V         Pair the x,y,z in the current item with those in the base point, V
   a          Take the absolute different from each pair
      m²      Square each of the 3 differences
        x     Sum those squares
              Sorted array is implicitly returned

Comments

अच्छा :) मैं रास्ते में काम करने से पहले 11 बाइट्स से नीचे था !

— झबरा

की तरह दिखता है यह 9 बाइट्स के लिए काम करना चाहिए, लेकिन यह कुछ अधिक परीक्षण की जरूरत है। संपादित करें: दोनों संस्करण 2 और 3 के परीक्षण मामलों में विफल रहे।

— झबरा

@ शैगी मुझे कभी नहीं लगा íकि इसके विपरीत तर्क हो सकते हैं, यह बहुत अच्छा है। मुझे भी लगता है कि यह काम करना चाहिए; मैं कुछ अन्य परीक्षण मामलों को चलाऊंगा और जब मैं कंप्यूटर पर वापस आऊंगा तो संपादित करूंगा।

— जस्टिन मेरिनर

नोट: -या के nस्थान पर भी काम करेगा a।

— झबरा

Answer 11

MATL , 7 बाइट्स

yZP&SY)

इनपुट्स हैं: पंक्तियों के रूप में अंक के साथ 3-कॉलम मैट्रिक्स, और बेस पॉइंट के साथ 3-कॉलम वेक्टर।

MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

y   % Implicitly take two inputs: 3-column matrix and 3-row vector. Duplicate the first
    % STACK: input 1 (matrix), input 2 (vector), input 1 (matrix)
ZP  % Euclidean distance between rows of top two elements in stack
    % STACK: input 1 (matrix), distances (vector)
&S  % Sort and push the indices of the sorting (not the sorted values)
    % STACK: input 1 (matrix), indices (vector)
Y)  % Use as row indices. Implicitly display
    % STACK: final result (matrix)

Answer 12

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

बची हुई नन की बदौलत 1 बाइट बची ।

ạ²SðÞ

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

व्याख्या

ạ²SðÞ

    Key - कुंजी फ़ंक्शन द्वारा क्रमबद्ध करें।
e - दूसरी इनपुट सूची में तत्वों के साथ पूर्ण अंतर।
 ² - वर्ग। Vectorizes।
  एस - सुम।
   a - एक अलग रंग श्रृंखला शुरू करता है।
      - आउटपुट निहितार्थ।

Comments

के साथ एक बाइट सहेजें ạS¥Þ(मेरा पोस्ट करने से पहले अपना जवाब नहीं देखा)।

— आउटगॉल्फ

हम्म ... मुझे लगता है कि आपको 5 बाइट्स के लिए वापस जाना होगा क्योंकि मैंने पाया है कि आपको स्क्वायर करने की आवश्यकता है :ạ²SµÞ

— एरिक आउटगॉल्फ

@EriktheOutgolfer मुझे लगता है कि मैंने इसे अब ठीक कर दिया है। हालांकि यकीन नहीं है

— श्री Xcoder

आपको योग (वेक्टराइज़) से पहले वर्ग करने की आवश्यकता है, बाद में नहीं।

— को आउटगॉल्फ

@EriktheOutgolfer अब ठीक होना चाहिए

— मिस्टर एक्सकोडर

Answer 13

पर्ल 6 , 35 बाइट्स (33 अक्षर)

{@^b;@^p.sort:{[+] ($_ Z- @b)»²}}

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

स्पष्टीकरण: यह आधार बिंदु (कहा जाता है @b) के निर्देशांक के साथ एक सूची लेता है , फिर अन्य बिंदुओं के निर्देशांक के साथ सूचियों की एक सूची (कहा जाता है @p)। एक ब्लॉक में, आप उन्हें ^प्रतीक का उपयोग करके मक्खी पर उपयोग कर सकते हैं । प्रत्येक ^'डी चर' एक तर्क से मेल खाता है। (वे वर्णानुक्रम में क्रमबद्ध हैं, इसलिए @^b1 तर्क है और@^p 2 है।) इस प्रतीक के एक उपयोग के बाद, आप सामान्य रूप से चर का उपयोग कर सकते हैं।

बयान @^b केवल यह कहने के लिए है कि ब्लॉक आधार बिंदु तर्क लेगा, जिसका उपयोग केवल सॉर्टिंग ब्लॉक के अंदर किया जाता है। (अन्यथा यह छँटाई ब्लॉक के तर्क को संदर्भित करेगा।) विधि .sortएक तर्क ले सकती है। यदि यह 1 तर्क (जैसे यहां) लेने वाला ब्लॉक है, तो सरणी को उस फ़ंक्शन के मानों के अनुसार क्रमबद्ध किया जाता है। ब्लॉक अपने आप में प्रत्येक बिंदु को बदले में लेता है और Z-आधार बिंदु निर्देशांक के साथ इसे शून्य ( ) से जोड़ देता है । फिर हम सूची में सभी तत्वों को वर्ग करते हैं »²और उनका उपयोग करते हुए योग करते हैं [+]।

एक अतिरिक्त बोनस के रूप में, यह फ्लोट निर्देशांक के साथ-साथ किसी भी आयाम में काम करेगा (जब तक आप, स्पष्ट रूप से, सभी बिंदुओं के लिए समान निर्देशांक की आपूर्ति करते हैं, यह सही काम करता है)।

---

यह अब मान्य नहीं है। मैं इसे यहां सिर्फ मनोरंजन के लिए छोड़ता हूं।

पर्ल 6 , 24 बाइट्स - केवल एक मजाक!

{@^b;@^p.sort:{$_!~~@b}}

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

चूंकि ओपी यह नहीं बताता है कि किस मीट्रिक का उपयोग किया जाएगा, यह सबमिशन असतत मीट्रिक का उपयोग करने के लिए चुनता है। इस मीट्रिक में, दो बिंदुओं के बीच की दूरी 0 है यदि वे समान हैं, और 1 यदि वे नहीं हैं। यह जांचना आसान है कि यह वास्तव में एक मीट्रिक है (यदि ρ (ए, बी) ए से बी से दूरी है, तो हमें इसकी आवश्यकता है कि 1) ρ (ए, बी) = 0 iff ए = बी, 2) ρ (ए, बी) ) = ρ (बी, ए), 3) ρ (ए, बी) + ρ (बी, सी) C ρ (ए, सी) ("त्रिकोण असमानता")।

यह शायद बहुत अधिक गोल्फ हो सकता है, लेकिन मैं इसे गंभीरता से मतलब नहीं है।

Comments

के लिए काम नहीं करता है <5 5 5>,(<5 5 10>,<6 5 5>)। सूची उनकी राशि से नहीं, बल्कि तत्व-वार तुलना द्वारा। आपको sumकहीं न कहीं जरूरत है।

— nwellnhof

@nwellnhof, बहुत धन्यवाद। मुझे नहीं पता कि मैं क्या सोच रहा था ... जल्द ही ठीक हो जाएगा।

— रामलीज

Answer 14

कोटलिन 1.1, 58 बाइट्स

{t,i->i.sortedBy{it.zip(t).map{(f,s)->(f-s)*(f-s)}.sum()}}

सजा हुआ

// t is the target, i is the list of inputs
{ t, i ->
    // Sort the inputs by the distance
    i.sortedBy {
        // For each dimension
        it.zip(t)
            // Calculate the square of the distance
            .map { (f, s) -> (f - s) * (f - s) }
            // Add up the squares
            .sum()
    }
}

परीक्षा

var f: (List<Int>, List<List<Int>>) -> List<List<Int>> =
{t,i->i.sortedBy{it.zip(t).map{(f,s)->(f-s)*(f-s)}.sum()}}

data class TestData(val target: List<Int>, val input: List<List<Int>>, val output: List<List<Int>>)

fun main(args: Array<String>) {
    val items = listOf(
            TestData(listOf(5, 5, 5),
                    listOf(listOf(0, 0, 0), listOf(10, 10, 10), listOf(2, 0, 8), listOf(10, 3, 1), listOf(4, 4, 5), listOf(5, 5, 5), listOf(5, 5, 4)),
                    listOf(listOf(5, 5, 5), listOf(5, 5, 4), listOf(4, 4, 5), listOf(2, 0, 8), listOf(10, 3, 1), listOf(0, 0, 0), listOf(10, 10, 10))
            ),
            TestData(listOf(8452, 3160, 6109),
                    listOf(listOf(7172, 5052, 4795), listOf(9789, 4033, 2952), listOf(8242, 213, 3835), listOf(177, 7083, 908), listOf(3788, 3129, 3018), listOf(9060, 464, 2701), listOf(6537, 8698, 291), listOf(9048, 3860, 6099), listOf(4600, 2696, 4854), listOf(2319, 3278, 9825)),
                    listOf(listOf(9048, 3860, 6099), listOf(7172, 5052, 4795), listOf(9789, 4033, 2952), listOf(8242, 213, 3835), listOf(4600, 2696, 4854), listOf(9060, 464, 2701), listOf(3788, 3129, 3018), listOf(2319, 3278, 9825), listOf(6537, 8698, 291), listOf(177, 7083, 908))
            ))
    items.map { it to f(it.target, it.input) }.filter { it.first.output != it.second }.forEach {
        System.err.println(it.first.output)
        System.err.println(it.second)
        throw AssertionError(it.first)
    }
    println("Test Passed")
}

Answer 15

जावा 8, 194 + 31 214 169 163 123 112 106 + 19 109 103 बाइट्स

B->P->P.sort(java.util.Comparator.comparing(p->{int d=0,i=0;while(i<3)d+=(d=p[i]-B[i++])*d;return d;}))

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

Comments

गलत परिणाम base=[2,3,3], points=[4,3,3],[1,3,4]:। आपका परिणाम है [4,3,3], [1,3,4], जबकि सही परिणाम है [1,3,4],[4,3,3]।

— ओलिवियर ग्रेजायर

@ ओलिवियरग्रेयर ओह्स, निश्चित

— रॉबर्टो ग्राहम

फिक्स + गोल्फ: b->l->{l.sort(java.util.Comparator.comparing(p->{int d=0,i=3;for(;i-->0;)d+=(b[i]-p[i])*(b[i]-p[i]);return d;}));}(114 बाइट्स), के List<int[]>बजाय एक पैरामीटर मानकर int[][]।

— ओलिवियर ग्रेगोइरे

ओह, बिना कलाकारों के powकाम करता है +=, अधिकांश अन्य मामलों में नहीं। जानकर अच्छा लगा!

— ओलिवियर ग्रेजायर

103 बाइट्स:B->P->P.sort(java.util.Comparator.comparing(p->{int d=0,i=0;while(i<3)d+=(d=p[i]-B[i++])*d;return d;}))

— नेवे

Answer 16

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

o.a,vz

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

o.a,vzNQ   implicit variables at the end
o      Q   order the points from the first input line by:
 .a           the euclidean distance between
      N       the point
   ,          and
    vz        the point from the second input line

Comments

हरोकूप्प कहते हैं Bad Request: Request Line is too large (7005 > 4094):। अधिकतम लिंक आकार फिट करने के लिए आपको अपना परीक्षण सूट छोटा करना चाहिए।

— मिस्टर एक्सकोडर

@ Mr.Xcoder धन्यवाद। मैंने ठीक कर दिया।

— जकुबे

Answer 17

पर्ल 5 , 90 बाइट्स

sub v{$i=$t=0;$t+=($_-$p[$i++])**2for pop=~/\d+/g;$t}@p=<>=~/\d+/g;say sort{v($a)<=>v$b}<>

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

इनपुट बिंदुओं की नई सूची से अलग की गई सूची है, जिसमें पहला आधार बिंदु है और अंतिम एक अनुगामी नई रेखा है। []निर्देशांक के आसपास ब्रैकेट ( ) वैकल्पिक हैं।