Sắp xếp các điểm theo khoảng cách tuyến tính trong không gian 3D

15

Thông số kỹ thuật

  1. Bạn có một không gian 3D khối x,y,zcủa các Sđơn vị số nguyên kích thước , chẳng hạn như 0 <= x,y,z <= S.
  2. Bạn nhận được từ các phương thức nhập mặc định, một mảng các điểm được Pbiểu thị dưới dạng x,y,ztọa độ nguyên, ở bất kỳ định dạng hợp lý nào bạn muốn, ví dụ : [x1,y1,z1],[x2,y2,z2],[x3,y3,z3] ... [xn,yn,zn].
  3. Tất cả các Pgiá trị sẽ nằm trong không gian 3D khối nói trên, chẳng hạn như 0 <= x,y,z <= S.
  4. Tổng số Pcó thể sẽ là .1 <= P <= S3
  5. Bạn cũng nhận được như là đầu vào x,y,ztọa độ nguyên của điểm gốc B và kích thước khối 3D S.

Bài tập

Mục tiêu của bạn là xuất ra, ở định dạng ưa thích của bạn, các điểm được Psắp xếp theo khoảng cách tuyến tính (Euclide) từ điểm gốc B .

Quy tắc

  1. Nếu bạn tìm thấy nhiều hơn một điểm Ptương đương từ Bbạn, bạn phải xuất tất cả các điểm tương đươngP theo thứ tự ưa thích của bạn.
  2. Có thể một điểm Psẽ trùng với B, do đó khoảng cách của chúng là 0, bạn phải xuất điểm đó.
  3. Đây là một thử thách chơi gôn , vì vậy mã ngắn nhất sẽ thắng.
  4. Sơ hở tiêu chuẩn bị cấm.
  5. Giải thích mã được đánh giá cao.

Các trường hợp thử nghiệm

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 
— Mario
nguồn
1
Có thực sự cần thiết để lấy Snhư một tham số?
— Cristian Lupascu
@GolfWolf nếu bạn không cần nó, đừng lấy nó.
— Mario
2
Tôi thực sự khuyên bạn nên chỉ định loại số liệu bạn muốn chúng tôi sử dụng. Một số người sử dụng số liệu Euclide (ρ = √ [(x₁ - x₂) ² + (y₁ - y₂) ² + (z₁ - z₂) ²]), những người khác sử dụng số liệu Manhattan (ρ = | x₁ - x₂ | + | y₁ - y₂ | + | z₁-z₂ |). Theo tôi mọi người nên sử dụng cùng một số liệu.
— Ramillies
4
@Ramillies: Thử thách chỉ định khoảng cách tuyến tính mà trong tâm trí tôi là Euclide . Tôi sẽ không gọi Manhattan tuyến tính, nhưng tôi đồng ý rằng việc chỉ định cụ thể số liệu nào sẽ sử dụng sẽ khiến việc hiểu sai thách thức trở nên khó khăn hơn.
— Emigna
1
Đừng nói tuyến tính, hãy nói Euclide.
— Lyndon White

Câu trả lời:

11

05AB1E , 4 byte

ΣαnO

Hãy thử trực tuyến!

Giải trình

Σ        # sort by
   O     # sum of
  n      # square of
 α       # absolute difference between current value and second input
— Biểu tượng
nguồn
Tại sao bạn cần n?
— Erik the Outgolfer
@EriktheOutgolfer: Có thể ví dụ nhỏ này có thể cho thấy sự khác biệt giữa bình phương và không.
— Emigna
Vì vậy, mọi người đang làm sai hay mọi người làm đúng?
— Erik the Outgolfer
@EriktheOutgolfer: Tôi chưa kiểm tra tất cả các câu trả lời, nhưng hầu hết đều đúng.
— Emigna
Nhiều câu trả lời không vuông, đó là lý do tại sao tôi hỏi, vì họ đang sử dụng chính xác cùng một thuật toán.
— Erik the Outgolfer
6

JavaScript (ES6), 71 byte

(b,a,g=a=>a.reduce((d,c,i)=>d+(c-=b[i])*c,0))=>a.sort((b,a)=>g(b)-g(a))
— Neil
nguồn
Tôi nghĩ bạn có thể tiết kiệm một byte bằng cách sử dụng định nghĩa currying và di chuyển gbên trong sort.
1
@ThePirateBay: Neil không làm cà ri!
— Xù xì
6

Haskell , 54 52 byte

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

Hãy thử trực tuyến!

Tôi không cần kích thước của không gian. sum.map(^2).zipWith(-)otính khoảng cách từ một điểm đến o: (xo-xp)^2+(yo-yp)^2+(zo-zp)^2. Các điểm được sắp xếp đơn giản trên khoảng cách đến o.

EDIT : "nếu bạn không cần nó, đừng lấy nó" đã lưu 2 byte.

— jferard
nguồn
4

R , 56 40 byte

-16 byte nhờ flodel để đề xuất một định dạng đầu vào khác

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

Hãy thử trực tuyến!

Lấy Pnhư một 3xnma trận các điểm, nghĩa là, mỗi cột là một điểm; đầu ra có cùng định dạng.

Sử dụng hàm trợ giúp gđể chuyển đổi danh sách các điểm Ptừ các trường hợp kiểm tra sang định dạng R thích hợp.

— Giuseppe
nguồn
1
Có thể thay thế sapply()bằng colSums((t(P)-B)^2), nơi đầu vào Psẽ là một ma trận?
— flodel
@flodel nếu tôi sẽ làm điều đó, tôi cũng có thể lấy đó Plàm 3xnma trận và chỉ cần làm colSums((P-B)^2)thay thế!
— Giuseppe
3

Toán học, 24 byte

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

Đưa đầu vào theo định dạng f[B][P].

Chúng ta phải sử dụng 4 byte xđể tạo hàm lồng nhau. Ưu tiên của  ( \[Function]) và //hoạt động độc đáo để biểu thức tương đương với điều này:

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

Chúng ta cần Nbởi vì theo mặc định, Mathicala sắp xếp theo cấu trúc biểu thức thay vì theo giá trị:

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

SortBy[N][{1, Sqrt@2, 2}]
{1, Sqrt[2], 2}
— hftf
nguồn
3

C # (.NET Core) , 68 57 53 + 23 18 byte

-11 byte nhờ Emigna

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

Số lượng byte cũng bao gồm

using System.Linq;

Hãy thử trực tuyến!

Điểm được coi là bộ sưu tập của ints. Giải trình:

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
nguồn
3

JavaScript (ES6), 72 71 byte

Câu hỏi này không ngắn hơn câu trả lời của Neil , nhưng tôi nghĩ rằng dù sao tôi cũng sẽ đăng nó để chứng minh việc sử dụng Math.hypot(), được giới thiệu trong ES6.

Lấy đầu vào theo cú pháp currying (p)(a), trong đó p = [x, y, z] là điểm gốc và a là mảng của các điểm khác.

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

Hiển thị đoạn mã

— Arnauld
nguồn
3

k , 14 byte

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

Hãy thử trực tuyến!

{            } /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

Ngoài ra, điều này hoạt động cho n kích thước, và không giới hạn ở 3.

— zgrep
nguồn
3

Japt , 10 9 byte

-1 byte nhờ @Shaggy

ñ_íaV m²x

Lấy các điểm như một mảng gồm ba mảng và cơ sở chỉ một mảng duy nhất, theo thứ tự đó. Không có đối số kích thước.

Hãy thử trực tuyến! hoặc chạy trường hợp thử nghiệm lớn với -Rđầu ra x,y,zmỗi dòng.

Giải trình

ñ_            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
nguồn
Đẹp :) Tôi đã xuống tới 11 byte trước khi công việc cản trở!
— Xù xì
Có vẻ như điều này sẽ làm việc cho 9 byte, nhưng nó cần thêm một số thử nghiệm. EDIT: Cả hai phiên bản đều thất bại trong các trường hợp thử nghiệm thứ 2 & 3.
— Xù xì
@Shaggy Tôi không bao giờ nhận ra ícó thể đưa ra các lập luận ngược lại, điều đó khá hay. Tôi cũng nghĩ rằng nó nên làm việc; Tôi sẽ chạy một số trường hợp thử nghiệm khác và chỉnh sửa khi tôi quay lại máy tính.
— Justin Mariner
Lưu ý: -hoặc ncũng sẽ làm việc thay cho a.
— Xù xì
2

MATL , 7 byte

yZP&SY)

Các đầu vào là: ma trận 3 cột với các điểm là hàng và vectơ 3 cột với điểm gốc.

Hãy thử nó tại MATL Online!

Giải trình

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)
— Luis Mendo
nguồn
2

Thạch , 5 byte

Đã lưu 1 byte, nhờ Leaky Nun .

ạ²SðÞ

Hãy thử trực tuyến!

Giải trình

ạ²SðÞ

    Þ - Sắp xếp theo chức năng chính.
ạ - Khác biệt tuyệt đối với các yếu tố trong danh sách đầu vào thứ hai.
 ² - Quảng trường. Vector hóa.
  S - Tổng.
   ð - Bắt đầu một chuỗi dyadic riêng biệt.
      - Đầu ra ngầm.
— Ông Xcoder
nguồn
Save a byte with ạS¥Þ (didn't notice your answer before posting mine).
— Erik the Outgolfer
Hmm...I think you will have to go back to 5 bytes since I found that you need to square: ạ²SµÞ
— Erik the Outgolfer
@EriktheOutgolfer I think I fixed it now. Not sure though
— Mr. Xcoder
You need to square before summing (vectorize), not after.
— Erik the Outgolfer
@EriktheOutgolfer Should be ok now
— Mr. Xcoder
2

Perl 6, 35 bytes (33 characters)

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

Try it online!

Explanation: This takes a list with the coordinates of the base point (called @b), then a list of lists with coordinates of the other points (called @p). In a block, you can use them on the fly using the ^ symbol. Each of the ^'d variables corresponds to one argument. (They're sorted alphabetically, so @^b is the 1st argument and @^p the 2nd.) After one use of this symbol, you can use the variable normally.

The statement @^b is there just to say that the block will take the base point argument, which is used only inside the sorting block. (Otherwise it would refer to the argument of the sorting block.) The method .sort may take one argument. If it's a block taking 1 argument (like here), the array is sorted according to the values of that function. The block itself just takes each point in turn and zips it with minus (Z-) with the base point coordinates. Then we square all the elements in the list with »² and sum them using [+].

As an added bonus, this will work with float coordinates as well, and in any dimension (as long as you, obviously, supply the same number of coordinates for all the points, it does the right thing).

This is no longer valid. I leave it here just for fun.

Perl 6, 24 bytes — only a joke!

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

Try it online!

Since the OP doesn't state which metric shall be used, this submission chooses to use the discrete metric. In this metric, the distance between two points is 0 if they are identical, and 1 if they are not. It's easy to check that this is indeed a metric (if ρ(A,B) is distance from A to B, we require that 1) ρ(A,B) = 0 iff A = B, 2) ρ(A,B) = ρ(B,A), 3) ρ(A,B) + ρ(B,C) ≥ ρ(A,C) ("triangle inequality")).

It could be probably golfed a lot more, but I don't mean it seriously.

— Ramillies
nguồn
Không làm việc cho <5 5 5>,(<5 5 10>,<6 5 5>). Danh sách không sắp xếp theo tổng của chúng, nhưng bằng cách so sánh theo yếu tố. Bạn cần một sumnơi nào đó.
— nwellnhof
@nwellnhof, cảm ơn nhiều. Tôi không biết mình đang nghĩ gì ... Sẽ sửa ngay.
— Ramillies
2

Kotlin 1.1, 58 byte

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

Làm đẹp

// 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()
    }
}

Kiểm tra

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
nguồn
2

Java 8, 194 + 31 214 169 163 123 112 106 + 19 109 103 byte

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

Hãy thử trực tuyến!

— Roberto Graham
nguồn
Kết quả sai : base=[2,3,3], points=[4,3,3],[1,3,4]. Kết quả của bạn là [4,3,3], [1,3,4], trong khi kết quả chính xác là [1,3,4],[4,3,3].
— Olivier Grégoire
@ OlivierGrégoire Rất tiếc, đã sửa
— Roberto Graham
Fix + golf: 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 byte), giả sử List<int[]>là tham số thay vì int[][].
— Olivier Grégoire
1
Oh, powkhông làm việc trong +=mà không có diễn viên, không phải trong hầu hết các trường hợp khác. Rất vui được biết!
— Olivier Grégoire
103 byte: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

Bình thường, 6 byte

o.a,vz

Dùng thử trực tuyến: Trình diễn

Giải trình:

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
nguồn
1
Herokuapp says: Bad Request: Request Line is too large (7005 > 4094). You should make your test suite smaller in order to fit the maximum link size.
— Mr. Xcoder
@Mr.Xcoder Thanks. I fixed it.
— Jakube
1

Perl 5, 90 bytes

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

Try it online!

Input is newline separated list of points, with the first one being the base point and the last having a trailing newline. Brackets ([]) around the coordinates are optional.

— Xcali
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.