Urutkan titik dengan jarak linear dalam ruang 3D

15

Spesifikasi

  1. Anda memiliki ruang 3D kubik unit integer x,y,zukuran S, seperti 0 <= x,y,z <= S.
  2. Anda dapatkan dari metode input default array poin Pdirepresentasikan sebagai x,y,zkoordinat integer, dalam format yang wajar yang Anda inginkan, misalnya: [x1,y1,z1],[x2,y2,z2],[x3,y3,z3] ... [xn,yn,zn].
  3. Semua Pnilai akan berada di ruang 3D kubik yang disebutkan di atas, seperti 0 <= x,y,z <= S.
  4. Jumlah total yang mungkin Padalah .1 <= P <= S3
  5. Anda juga mendapatkan input x,y,zkoordinat integer dari titik dasar B dan ukuran kubus 3D S.

Tugas

Tujuan Anda adalah untuk menghasilkan, dalam format pilihan Anda, titik-titik yang Pdiurutkan berdasarkan jarak linear (Euclidean) dari titik dasar B .

Aturan

  1. Jika Anda menemukan lebih dari satu titik Pyang berjarak sama dariB Anda, Anda harus menampilkan semua titik yang sama Pdalam urutan pilihan Anda.
  2. Ada kemungkinan bahwa suatu titik Pakan bertepatan B, sehingga jarak mereka0 , Anda harus menampilkan titik itu.
  3. Ini adalah tantangan kode-golf , sehingga kode terpendek menang.
  4. Celah standar dilarang.
  5. Penjelasan kode dihargai.

Uji kasus

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
sumber
1
Apakah benar-benar perlu untuk mengambil Ssebagai parameter?
— Cristian Lupascu
@GolfWolf jika Anda tidak membutuhkannya, jangan ambil itu.
— Mario
2
Saya sangat menyarankan menentukan jenis metrik yang Anda ingin kami gunakan. Beberapa orang menggunakan metrik Euclidean (ρ = √ [(x₁-x₂) ² + (y₁-y₂) ² + (z₁-z₂) ²]), yang lain menggunakan metrik Manhattan (ρ = | x₁-x₂ | + | y₁-y₂ | + | z₁-z₂ |). Menurut pendapat saya, setiap orang harus menggunakan metrik yang sama.
— Ramillies
4
@Ramillies: Tantangannya menentukan jarak linear yang menurut saya adalah Euclidean . Saya tidak akan menyebut Manhattan linier, tetapi saya setuju bahwa menentukan secara spesifik metrik mana yang akan digunakan akan membuat lebih sulit untuk salah memahami tantangan.
— Emigna
1
Jangan katakan linear, katakan Euclidean.
— Lyndon White

Jawaban:

11

05AB1E , 4 byte

ΣαnO

Cobalah online!

Penjelasan

Σ        # sort by
   O     # sum of
  n      # square of
 α       # absolute difference between current value and second input
— Emigna
sumber
Mengapa Anda perlu n?
— Erik the Outgolfer
@EriktheOutgolfer: Mungkin contoh kecil ini dapat menunjukkan perbedaan antara mengkuadratkan dan tidak.
— Emigna
Jadi, apakah semua orang melakukan kesalahan atau semua orang melakukannya dengan benar?
— Erik the Outgolfer
@EriktheOutgolfer: Saya belum memeriksa semua jawaban, tetapi sebagian besar tampaknya benar.
— Emigna
Banyak jawaban yang tidak sesuai, itu sebabnya saya bertanya, karena mereka menggunakan algoritma yang persis sama.
— 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
sumber
Saya pikir Anda dapat menyimpan byte dengan menggunakan definisi currying dan moving gdi dalam sort.
1
@ThePirateBay: Neil tidak melakukan kari!
— Shaggy
6

Haskell , 54 52 byte

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

Cobalah online!

Saya tidak perlu ukuran ruang. sum.map(^2).zipWith(-)omenghitung jarak dari titik ke o: (xo-xp)^2+(yo-yp)^2+(zo-zp)^2. Poin hanya diurutkan pada jarak ke o.

EDIT : "jika Anda tidak membutuhkannya, jangan bawa" disimpan 2 byte.

— jferard
sumber
4

R , 56 40 byte

-16 byte berkat flodel untuk menyarankan format input yang berbeda

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

Cobalah online!

Dibawa Psebagai 3xnmatriks titik, yaitu, setiap kolom adalah titik; output dalam format yang sama.

Gunakan fungsi helper guntuk mengubah daftar poin Pdari kasus uji menjadi format R yang sesuai.

— Giuseppe
sumber
1
Mungkin ganti sapply()dengan colSums((t(P)-B)^2), di mana input Pakan menjadi matriks?
— flodel
@flodel jika saya akan melakukan itu, saya mungkin juga mengambil Psebagai 3xnmatriks dan lakukan colSums((P-B)^2)saja!
— Giuseppe
3

Mathematica, 24 byte

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

Mengambil input dalam format f[B][P].

Kita harus menggunakan 4 byte xuntuk membuat fungsi bersarang. Diutamakan dari  ( \[Function]) dan //bekerja dengan baik sehingga ekspresi setara dengan ini:

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

Kita perlu Nkarena secara default, Mathematica mengurutkan berdasarkan struktur ekspresi alih-alih berdasarkan nilai:

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

SortBy[N][{1, Sqrt@2, 2}]
{1, Sqrt[2], 2}
— hftf
sumber
3

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

-11 byte terima kasih kepada Emigna

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

Jumlah byte juga termasuk

using System.Linq;

Cobalah online!

Poin diperlakukan sebagai koleksi int. Penjelasan:

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

JavaScript (ES6), 72 71 byte

Yang ini tidak lebih pendek dari jawaban Neil , tapi saya pikir saya tetap akan mempostingnya untuk menunjukkan penggunaanMath.hypot() , yang diperkenalkan dalam ES6.

Mengambil input dalam sintaks currying (p)(a), di mana p = [x, y, z] adalah titik dasar dan a adalah array dari titik lainnya.

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

Tampilkan cuplikan kode

— Arnauld
sumber
3

k , 14 byte

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

Cobalah online!

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

Juga, ini berfungsi untuk n dimensi, dan tidak terbatas pada 3.

— zgrep
sumber
3

Japt , 10 9 byte

-1 byte terima kasih kepada @Shaggy

ñ_íaV m²x

Mengambil poin sebagai array array tiga item dan titik dasar array tunggal, dalam urutan itu. Tidak mengambil argumen ukuran.

Cobalah online! atau jalankan test case besar dengan -Routput satux,y,z per baris.

Penjelasan

ñ_            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
sumber
Bagus :) Saya turun ke 11 byte sebelum pekerjaan menghalangi!
— Shaggy
Sepertinya ini seharusnya bekerja untuk 9 byte, tetapi perlu beberapa pengujian lagi. EDIT: Kedua versi gagal pada kasus uji 2 & 3.
— Shaggy
@ Shaggy, saya tidak pernah menyadari íbisa mengambil argumen itu secara terbalik, itu cukup bagus. Saya juga berpikir itu harus berhasil; Saya akan menjalankan beberapa test case lainnya dan mengedit ketika saya kembali ke komputer.
— Justin Mariner
Catatan: -atau nakan juga berfungsi sebagai pengganti a.
— Shaggy
2

MATL , 7 byte

yZP&SY)

Inputnya adalah: matriks 3 kolom dengan titik sebagai baris, dan vektor 3 kolom dengan titik dasar.

Cobalah di MATL Online!

Penjelasan

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

Jelly , 5 byte

Disimpan 1 byte, terima kasih untuk Leaky Nun .

ạ²SðÞ

Cobalah online!

Penjelasan

ạ²SðÞ

    Þ - Urutkan berdasarkan fungsi tombol.
ạ - Perbedaan absolut dengan elemen-elemen dalam daftar input kedua.
 ² - Kotak. Vectorizes.
  S - Sum.
   ð - Memulai rantai diad yang terpisah.
      - Output secara implisit.
— Tuan Xcoder
sumber
Simpan byte dengan ạS¥Þ(tidak memperhatikan jawaban Anda sebelum memposting milik saya).
— Erik the Outgolfer
Hmm ... Saya pikir Anda harus kembali ke 5 byte karena saya menemukan bahwa Anda perlu kuadrat :ạ²SµÞ
— Erik the Outgolfer
@EriktheOutgolfer Saya pikir saya sudah memperbaikinya sekarang. Tidak yakin
— Tn. Xcoder
Anda harus menyiku sebelum menjumlahkan (vektorisasi), bukan setelahnya.
— Erik the Outgolfer
@EriktheOutgolfer Harusnya ok sekarang
— Tn. Xcoder
2

Perl 6 , 35 byte (33 karakter)

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

Cobalah online!

Penjelasan: Ini mengambil daftar dengan koordinat titik dasar (disebut @b), lalu daftar daftar dengan koordinat titik lainnya (disebut @p). Dalam sebuah blok, Anda dapat menggunakannya dengan cepat menggunakan ^simbol. Masing-masing ^variabel sesuai dengan satu argumen. (Mereka diurutkan berdasarkan abjad, begitu @^bjuga argumen 1 dan @^p2.) Setelah satu penggunaan simbol ini, Anda dapat menggunakan variabel secara normal.

Pernyataan @^bitu ada hanya untuk mengatakan bahwa blok akan mengambil argumen titik dasar, yang hanya digunakan di dalam blok penyortiran. (Kalau tidak, itu akan merujuk pada argumen dari blok penyortiran.) Metode ini .sortdapat mengambil satu argumen. Jika itu adalah blok yang mengambil 1 argumen (seperti di sini), array diurutkan sesuai dengan nilai-nilai fungsi itu. Blok itu sendiri hanya mengambil setiap titik pada gilirannya dan ritsleting dengan minus ( Z-) dengan koordinat titik dasar. Lalu, kami menguadratkan semua elemen dalam daftar »²dan menjumlahkannya menggunakan [+].

Sebagai bonus tambahan, ini akan bekerja dengan koordinat float juga, dan dalam dimensi apa pun (selama Anda, jelas, menyediakan jumlah koordinat yang sama untuk semua poin, itu melakukan hal yang benar).

Ini tidak berlaku lagi. Saya meninggalkannya di sini hanya untuk bersenang-senang.

Perl 6 , 24 byte - hanya lelucon!

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

Cobalah online!

Karena OP tidak menyatakan metrik mana yang akan digunakan, kiriman ini memilih untuk menggunakan metrik diskrit. Dalam metrik ini, jarak antara dua titik adalah 0 jika keduanya identik, dan 1 jika tidak. Sangat mudah untuk memeriksa bahwa ini memang metrik (jika ρ (A, B) adalah jarak dari A ke B, kami mensyaratkan bahwa 1) ρ (A, B) = 0 iff A = B, 2) ρ (A, B ) = ρ (B, A), 3) ρ (A, B) + ρ (B, C) ≥ ρ (A, C) ("ketimpangan segitiga")).

Mungkin bisa bermain golf lebih banyak, tapi saya tidak bermaksud serius.

— Ramillies
sumber
Tidak berhasil <5 5 5>,(<5 5 10>,<6 5 5>). Daftar tidak mengurutkan berdasarkan jumlah mereka, tetapi dengan perbandingan elemen-bijaksana. Anda butuh sumtempat.
— nwellnhof
@wellwell, terima kasih banyak. Saya tidak tahu apa yang saya pikirkan ... Akan segera diperbaiki.
— Ramillies
2

Kotlin 1.1, 58 byte

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

Yg diperindahkan

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

Uji

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

Java 8, 194 + 31 214 169 163 123 112 106 + 19 109 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;}))

Cobalah online!

— Roberto Graham
sumber
Hasil yang salah: base=[2,3,3], points=[4,3,3],[1,3,4]. Hasil Anda [4,3,3], [1,3,4], sedangkan hasil yang benar adalah [1,3,4],[4,3,3].
— Olivier Grégoire
@ OlivierGrégoire Ups, diperbaiki
— 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 bytes), dengan asumsi List<int[]>sebagai parameter alih-alih int[][].
— Olivier Grégoire
1
Oh, powapakah bekerja +=tanpa pemain, tidak dalam kebanyakan kasus lain. Bagus untuk mengetahui!
— 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

Pyth, 6 byte

o.a,vz

Cobalah online: Peragaan

Penjelasan:

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
sumber
1
Herokuapp mengatakan: Bad Request: Request Line is too large (7005 > 4094). Anda harus membuat test suite Anda lebih kecil agar sesuai dengan ukuran tautan maksimum.
— Tn. Xcoder
@ Mr.Xcoder Terima kasih. Aku telah memperbaikinya.
— Jakube
1

Perl 5 , 90 byte

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

Cobalah online!

Input adalah daftar poin yang dipisahkan baris baru, dengan yang pertama menjadi titik dasar dan yang terakhir memiliki baris baru. Kurung ([] ) di sekitar koordinat bersifat opsional.

— Xcali
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.