จัดเรียงคะแนนตามระยะเชิงเส้นในพื้นที่ 3D

15

รายละเอียด

  1. คุณมีพื้นที่ลูกบาศก์ 3D x,y,zของSหน่วยจำนวนเต็มขนาดเช่น0 <= x,y,z <= Sหน่วยจำนวนเต็มเช่น
  2. คุณได้รับจากวิธีการป้อนค่าเริ่มต้นอาร์เรย์ของจุดที่Pแสดงเป็นx,y,zพิกัดจำนวนเต็มในรูปแบบที่เหมาะสมตามที่คุณต้องการตัวอย่างเช่น[x1,y1,z1],[x2,y2,z2],[x3,y3,z3] ... [xn,yn,zn]ตามที่คุณต้องการตัวอย่างเช่น:
  3. Pค่าทั้งหมดจะอยู่ในพื้นที่ลูกบาศก์ 3D ดังกล่าวข้างต้นเช่น0 <= x,y,z <= Sลูกบาศก์เช่น
  4. จำนวนที่เป็นไปได้ทั้งหมดPจะเป็น1 <= P <= S3จะ
  5. คุณยังได้รับปัจจัยในx,y,zจำนวนเต็มพิกัดของจุดฐาน และขนาดลูกบาศก์B 3DS

งาน

เป้าหมายของคุณคือการส่งออกในรูปแบบที่คุณต้องการจุด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]
code-golf  geometry  integer 
— มาริโอ
แหล่งที่มา
1
จำเป็นSหรือไม่ที่จะใช้เป็นพารามิเตอร์?
— Cristian Lupascu
@ WolfWolf ถ้าคุณไม่ต้องการมันอย่าไปรับมัน
— มาริโอ
2
ฉันขอแนะนำอย่างยิ่งให้ระบุประเภทของการวัดที่คุณต้องการให้เราใช้ บางคนใช้ตัวชี้วัดแบบยุคลิด (ρ = √ [(x₁-x₂) ² + (y₁-y₂)) ² + (z₁-z₂) ²]) คนอื่น ๆ ใช้ตัวชี้วัดแมนฮัตตัน (ρ = | x₁-x₂ | + | y₁-y₂ | + | z₁-z₂ |) ในความคิดของฉันทุกคนควรใช้เมตริกเดียวกัน
— Ramillies
4
@Ramillies: ความท้าทายระบุเชิงเส้นระยะทางซึ่งในใจของฉันเป็นแบบยุคลิด ฉันจะไม่เรียกแมนฮัตตันเป็นเส้นตรง แต่ฉันยอมรับว่าการระบุตัวชี้วัดที่จะใช้โดยเฉพาะควรทำให้ยากต่อการเข้าใจผิดถึงความท้าทาย
— Emigna
1
อย่าพูดเป็นเส้นตรงพูดแบบยุคลิด
— Lyndon White

คำตอบ:

11

05AB1E , 4 ไบต์

ΣαnO

ลองออนไลน์!

คำอธิบาย

Σ        # sort by
   O     # sum of
  n      # square of
 α       # absolute difference between current value and second input
— Emigna
แหล่งที่มา
ทำไมคุณต้องn?
— Erik the Outgolfer
@EriktheOutgolfer: บางทีตัวอย่างเล็ก ๆ นี้อาจแสดงความแตกต่างระหว่างกำลังสองและไม่ได้
— Emigna
ดังนั้นทุกคนทำผิดหรือทุกคนทำถูกต้องหรือไม่
— Erik the Outgolfer
@EriktheOutgolfer: ฉันยังไม่ได้ตรวจสอบคำตอบทั้งหมด แต่ส่วนใหญ่ดูเหมือนจะถูกต้อง
— Emigna
คำตอบจำนวนมากไม่ได้เป็นรูปสี่เหลี่ยมนั่นคือสาเหตุที่ฉันถาม
— Erik the Outgolfer
6

JavaScript (ES6), 71 ไบต์

(b,a,g=a=>a.reduce((d,c,i)=>d+(c-=b[i])*c,0))=>a.sort((b,a)=>g(b)-g(a))
— นีล
แหล่งที่มา
ฉันคิดว่าคุณสามารถบันทึกไบต์โดยใช้ currying และการเคลื่อนย้ายความหมายของภายในg sort
1
@ThePirateBay: Neil ไม่ได้ทำแกงกะหรี่!
— Shaggy
6

Haskell , 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)^2o

แก้ไข : "หากคุณไม่ต้องการไม่ใช้" บันทึก 2 ไบต์

— jferard
แหล่งที่มา
4

R , 56 40 ไบต์

-16 ไบต์ขอบคุณ flodel สำหรับการแนะนำรูปแบบอินพุตอื่น

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

ลองออนไลน์!

ใช้Pเป็น3xnเมทริกซ์ของคะแนนกล่าวคือแต่ละคอลัมน์เป็นจุด เอาต์พุตอยู่ในรูปแบบเดียวกัน

ใช้ฟังก์ชันตัวช่วยgเพื่อแปลงรายการคะแนนPจากกรณีทดสอบเป็นรูปแบบ R ที่เหมาะสม

— จูเซปเป้
แหล่งที่มา
1
อาจแทนที่sapply()ด้วยcolSums((t(P)-B)^2)ซึ่งอินพุตPจะเป็นเมทริกซ์หรือไม่
— flodel
@flodel ถ้าฉันจะทำอย่างนั้นฉันเป็นดีอาจจะPเป็น3xnเมทริกซ์และเพียงแค่ทำcolSums((P-B)^2)แทน!
— Giuseppe
3

Mathematica ขนาด 24 ไบต์

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

f[B][P]จะเข้าในรูปแบบ

เราต้องใช้ 4 ไบต์xเพื่อสร้างฟังก์ชั่นที่ซ้อนกัน ความสำคัญของ ( \[Function]) และ//ทำงานได้ดีเพื่อให้การแสดงออกเทียบเท่ากับสิ่งนี้:

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

เราต้องการNเพราะโดยปกติ Mathematica จะเรียงลำดับตามโครงสร้างนิพจน์แทนที่จะเป็นตามค่า:

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

SortBy[N][{1, Sqrt@2, 2}]
{1, Sqrt[2], 2}
— hftf
แหล่งที่มา
3

C # (.NET Core) , 68 57 53 + 23 18 ไบต์

-11 ไบต์ขอบคุณEmigna

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

จำนวนไบต์ยังรวมถึง

using System.Linq;

ลองออนไลน์!

คะแนนจะถือว่าเป็นชุดของ ints คำอธิบาย:

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
    )
— Grzegorz Puławski
แหล่งที่มา
3

JavaScript (ES6), 72 71 ไบต์

อันนี้ไม่สั้นกว่าคำตอบของ Neilแต่ฉันคิดว่าฉันจะโพสต์ต่อไปเพื่อแสดงให้เห็นถึงการใช้งานMath.hypot()ซึ่งได้รับการแนะนำใน ES6

รับอินพุตในรูปแบบ currying (p)(a)โดยที่p = [x, y, z]เป็นจุดฐานและaคืออาร์เรย์ของจุดอื่น

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

แสดงตัวอย่างรหัส

— Arnauld
แหล่งที่มา
3

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

— zgrep
แหล่งที่มา
3

Japt , 10 9 ไบต์

-1 ไบต์ขอบคุณ @Shaggy

ñ_íaV m²x

ใช้คะแนนเป็นอาร์เรย์ของอาร์เรย์สามรายการและจุดฐานเป็นอาร์เรย์เดียวตามลำดับ อย่าใช้อาร์กิวเมนต์ขนาด

ลองออนไลน์! หรือเรียกใช้กรณีทดสอบขนาดใหญ่ด้วย-Rการส่งออกอย่างใดอย่างหนึ่งx,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
— Justin Mariner
แหล่งที่มา
ดี :) ฉันลงไป11 ไบต์ก่อนที่งานจะมาถึง!
— Shaggy
ดูเหมือนว่าสิ่งนี้จะทำงานได้ 9 ไบต์ แต่ต้องมีการทดสอบเพิ่มเติม แก้ไข: ทั้งสองรุ่นล้มเหลวในกรณีทดสอบที่ 2 และ 3
— ขนปุย
@Shaggy ฉันไม่เคยรู้เลยว่าíมันอาจเป็นข้อโต้แย้งในทางกลับกันมันค่อนข้างดี ฉันก็คิดว่ามันควรจะใช้ได้ ฉันจะเรียกใช้กรณีทดสอบอื่น ๆ และแก้ไขเมื่อฉันกลับไปที่คอมพิวเตอร์
— Justin Mariner
หมายเหตุ: -หรือยังจะทำงานในสถานที่ของn a
— Shaggy
2

MATL , 7 ไบต์

yZP&SY)

อินพุตคือ: เมทริกซ์ 3 คอลัมน์ที่มีจุดเป็นแถวและเวกเตอร์ 3 คอลัมน์พร้อมจุดฐาน

ลองที่MATL Online!

คำอธิบาย

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)
— หลุยส์เมนโด
แหล่งที่มา
2

เยลลี่ 5 ไบต์

ที่บันทึกไว้ 1 ไบต์ขอบคุณรั่วนูน

ạ²SðÞ

ลองออนไลน์!

คำอธิบาย

ạ²SðÞ

    Þ - จัดเรียงตามฟังก์ชั่นคีย์
ạ - ความแตกต่างแน่นอนกับองค์ประกอบในรายการอินพุตที่สอง
 ² - สแควร์ เวกเตอร์
  S - ผลรวม
   ð - เริ่มสายโซ่ dyadic แยกจากกัน
      - ผลผลิตโดยปริยาย
— นาย Xcoder
แหล่งที่มา
บันทึกไบต์ด้วยạS¥Þ(ไม่ได้สังเกตคำตอบของคุณก่อนโพสต์ของฉัน)
— Erik the Outgolfer
อืม ... ฉันคิดว่าคุณจะต้องย้อนกลับไปที่ 5 ไบต์เนื่องจากฉันพบว่าคุณต้องทำตาราง :ạ²SµÞ
— Erik the Outgolfer
@EriktheOutgolfer ฉันคิดว่าฉันคงตอนนี้แล้ว ไม่แน่ใจว่า
— Mr. Xcoder
คุณต้องยกกำลังสองก่อนที่จะหาผลรวม
— Erik the Outgolfer
@EriktheOutgolfer น่าจะโอเคตอนนี้
— Mr. Xcoder
2

Perl 6 , 35 ไบต์ (33 ตัวอักษร)

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

ลองออนไลน์!

คำอธิบาย:ใช้รายการที่มีพิกัดของจุดฐาน (เรียกว่า@b) จากนั้นรายการของรายการที่มีพิกัดของจุดอื่น ๆ (เรียกว่า@p) ในบล็อกคุณสามารถใช้มันได้ทันทีโดยใช้^สัญลักษณ์ แต่ละ^'d ตัวแปรสอดคล้องกับหนึ่งอาร์กิวเมนต์ (เรียงลำดับตามตัวอักษรตามลำดับดังนั้นจึง@^bเป็นอาร์กิวเมนต์ที่ 1 และ@^pที่ 2) หลังจากใช้สัญลักษณ์นี้ไปครั้งหนึ่งแล้วคุณสามารถใช้ตัวแปรได้ตามปกติ

คำสั่ง@^bอยู่ที่นั่นเพียงเพื่อบอกว่าบล็อกจะใช้อาร์กิวเมนต์จุดฐานซึ่งจะใช้เฉพาะในบล็อกการเรียงลำดับ (มิฉะนั้นจะอ้างถึงอาร์กิวเมนต์ของบล็อกการเรียงลำดับ) เมธอด.sortอาจรับหนึ่งอาร์กิวเมนต์ หากเป็นบล็อกที่มีอาร์กิวเมนต์ 1 ตัว (เหมือนที่นี่) อาร์เรย์จะถูกจัดเรียงตามค่าของฟังก์ชันนั้น บล็อกนั้นใช้เวลาแต่ละจุดในการเปิดและรหัสไปรษณีย์ด้วยเครื่องหมายลบ ( Z-) ด้วยพิกัดจุดฐาน แล้วเราตารางองค์ประกอบทั้งหมดในรายการด้วยและรวมพวกเขาใช้»²[+]

ในฐานะโบนัสเพิ่มเติมสิ่งนี้จะทำงานร่วมกับพิกัดลอยเช่นกันและในมิติใด ๆ (ตราบใดที่คุณเห็นได้ชัดว่ามีจำนวนพิกัดเท่ากันทุกจุดทำในสิ่งที่ถูกต้อง)

สิ่งนี้ไม่ถูกต้องอีกต่อไป ฉันทิ้งไว้ที่นี่เพื่อความสนุก

Perl 6 , 24 bytes - เพียงเรื่องตลก!

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

ลองออนไลน์!

เนื่องจาก OP ไม่ได้ระบุว่าจะใช้เมตริกใดการส่งนี้จึงเลือกใช้เมทริกที่ไม่ต่อเนื่อง ในตัวชี้วัดนี้ระยะห่างระหว่างจุดสองจุดคือ 0 ถ้าพวกเขาเหมือนกันและ 1 ถ้าไม่เหมือนกัน มันง่ายที่จะตรวจสอบว่านี่เป็นตัวชี้วัด (ถ้าρ (A, B) อยู่ห่างจาก A ถึง B เราจำเป็นต้องมี 1) ρ (A, B) = 0 iff A = B, 2) ρ (A, B ) = ρ (B, A), 3) ρ (A, B) + ρ (B, C) ≥ρ (A, C) ("ความไม่เท่าเทียมกันของรูปสามเหลี่ยม")

มันอาจจะเล่นกอล์ฟได้มากขึ้น แต่ฉันไม่ได้ตั้งใจอย่างจริงจัง

— มิลลี่ย์
แหล่งที่มา
<5 5 5>,(<5 5 10>,<6 5 5>)ไม่ทำงานสำหรับ รายการไม่ได้จัดเรียงตามผลรวมของพวกเขา แต่จากการเปรียบเทียบองค์ประกอบที่ชาญฉลาด คุณต้องการsumที่ไหนสักแห่ง
— nwellnhof
@nwellnhof ขอบคุณมาก ฉันไม่รู้ว่าฉันคิดอะไรอยู่ ... จะแก้ไขในไม่ช้า
— Ramillies
2

Kotlin 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")
}
— jrtapsell
แหล่งที่มา
2

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

ลองออนไลน์!

— Roberto Graham
แหล่งที่มา
ผลลัพธ์ไม่ถูกต้อง: base=[2,3,3], points=[4,3,3],[1,3,4]. ผลของคุณคือในขณะที่ผลที่ถูกต้องคือ[4,3,3], [1,3,4] [1,3,4],[4,3,3]
— Olivier Grégoire
@ OlivierGrégoireโอ๊ะโอคงที่
— Roberto Graham
แก้ไข + กอล์ฟ: 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 bytes) สมมติว่าเป็นพารามิเตอร์แทนList<int[]> int[][]
— Olivier Grégoire
1
โอ้powทำงานได้+=โดยไม่ต้องหล่อไม่ใช่ในกรณีอื่น ๆ ดีที่รู้!
— Olivier Grégoire
103 bytes: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;}))
— Nevay
1

Pyth, 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
— Jakube
แหล่งที่มา
1
Herokuapp Bad Request: Request Line is too large (7005 > 4094)พูดว่า: คุณควรทำให้ชุดทดสอบของคุณเล็กลงเพื่อให้พอดีกับขนาดลิงก์สูงสุด
— Mr. Xcoder
@ Mr.Xcoder ขอบคุณ ฉันซ่อมมัน.
— Jakube
1

Perl 5 , 90 ไบต์

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

ลองออนไลน์!

อินพุตคือรายการที่คั่นด้วยจุดขึ้นบรรทัดใหม่โดยอันแรกเป็นจุดฐานและบรรทัดสุดท้ายมีการขึ้นบรรทัดใหม่ วงเล็บ ( []) รอบพิกัดเป็นตัวเลือก

— Xcali
แหล่งที่มา
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.