Sortuj punkty według odległości liniowej w przestrzeni 3D

15

Okular

  1. Masz sześcienną przestrzeń 3D jednostek liczb całkowitych x,y,zwielkości S, takich jak 0 <= x,y,z <= S.
  2. Można uzyskać z metod wprowadzania domyślnych tablicę punktów Preprezentowane x,y,zwspółrzędnych całkowitych, w jakimkolwiek rozsądnym formacie, jak chcesz, na przykład: [x1,y1,z1],[x2,y2,z2],[x3,y3,z3] ... [xn,yn,zn].
  3. Wszystkie Pwartości będą w wyżej wymienionej sześciennej przestrzeni 3D, np 0 <= x,y,z <= S.
  4. Możliwa całkowita liczba Pto .1 <= P <= S3
  5. Otrzymujesz również jako dane wejściowe x,y,zwspółrzędne całkowite punktu bazowego B i rozmiar kostki 3D S.

Zadanie

Twoim celem jest wyprowadzenie, w preferowanym formacie, punktów Pposortowanych według odległości liniowej (euklidesowej) od punktu bazowego B .

Zasady

  1. Jeśli znajdziesz więcej niż jeden punkt, Pktóry jest w równej odległości B, musisz wyprowadzić wszystkie równoodległe Pw preferowanej kolejności.
  2. Możliwe jest, że punkt Pzbiegnie się B, więc jego odległość wynosi 0, musisz go wyprowadzić.
  3. To wyzwanie dla golfa , więc wygrywa najkrótszy kod.
  4. Standardowe luki są zabronione.
  5. Docenia się wyjaśnienia kodu.

Przypadki testowe

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
źródło
1
Czy naprawdę trzeba wziąć Sjako parametr?
— Cristian Lupascu,
@GolfWolf, jeśli nie potrzebujesz, nie bierz tego.
— Mario,
2
Zdecydowanie zalecam określenie, jakiego rodzaju danych chcesz używać. Niektórzy używają metryk euklidesowych (ρ = √ [(x₁-x₂) ² + (y₁-y₂) ² + (z₁-z₂) ²]), inni używają metryk Manhattan (ρ = | x₁-x₂ | + | y₁-y₂ | + | z₁-z₂ |). Moim zdaniem każdy powinien używać tej samej metryki.
— Ramillies
4
@Ramillies: Wyzwanie określa odległość liniową, która moim zdaniem jest euklidesowa . Nie nazwałbym Manhattanu liniowym, ale zgadzam się, że określenie konkretnie, jakich mierników użyć, powinno utrudnić niezrozumienie wyzwania.
— Emigna
1
Nie mów liniowo, powiedz euklidesowy.
— Lyndon White,

Odpowiedzi:

11

05AB1E , 4 bajty

ΣαnO

Wypróbuj online!

Wyjaśnienie

Σ        # sort by
   O     # sum of
  n      # square of
 α       # absolute difference between current value and second input
— Emigna
źródło
Dlaczego musisz n?
— Erik the Outgolfer
@EriktheOutgolfer: Może ten mały przykład pokazuje różnicę między kwadratem a nie.
— Emigna
Czy więc wszyscy robią to źle, czy wszyscy robią to dobrze?
— Erik the Outgolfer
@EriktheOutgolfer: Nie sprawdziłem wszystkich odpowiedzi, ale większość wydaje się poprawna.
— Emigna
Wiele odpowiedzi nie jest kwadratowych, dlatego zapytałem, ponieważ używają dokładnie tego samego algorytmu.
— Erik the Outgolfer
6

JavaScript (ES6), 71 bajtów

(b,a,g=a=>a.reduce((d,c,i)=>d+(c-=b[i])*c,0))=>a.sort((b,a)=>g(b)-g(a))
— Neil
źródło
Myślę, że możesz zaoszczędzić bajt, używając curry i ruchomej definicji gwnętrza sort.
1
@ThePirateBay: Neil nie robi curry!
— Shaggy
6

Haskell , 54 52 bajty

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

Wypróbuj online!

Nie potrzebuję wielkości przestrzeni. sum.map(^2).zipWith(-)ooblicza odległość od punktu do o: (xo-xp)^2+(yo-yp)^2+(zo-zp)^2. Punkty są po prostu sortowane według odległości do o.

EDYCJA : „jeśli nie potrzebujesz, nie bierz” zapisał 2 bajty.

— Jferard
źródło
4

R , 56 40 bajtów

-16 bajtów dzięki flodel za sugerowanie innego formatu wejściowego

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

Wypróbuj online!

Trwa Pjako3xn macierz punktów, tj. Każda kolumna jest punktem; dane wyjściowe są w tym samym formacie.

Użyj funkcji pomocnika, gaby przekształcić listę punktów Pz przypadków testowych do odpowiedniego formatu R.

— Giuseppe
źródło
1
Może zastąpić sapply()z colSums((t(P)-B)^2), gdzie wejście Pbyłaby matryca?
— flodel
@flodel, jeśli mam to zrobić, równie dobrze mogę wziąć Pjako 3xnmatrycę i po prostu zrobić colSums((P-B)^2)!
— Giuseppe,
3

Mathematica, 24 bajty

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

Pobiera dane wejściowe w formacie f[B][P].

Musimy użyć 4 bajtów, xaby zagnieżdżona funkcja. Pierwszeństwo  ( \[Function]) i //działa dobrze, dzięki czemu wyrażenie jest równoważne z tym:

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

Potrzebujemy, Nponieważ domyślnie Mathematica sortuje według struktury wyrażeń zamiast według wartości:

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

SortBy[N][{1, Sqrt@2, 2}]
{1, Sqrt[2], 2}
— hftf
źródło
3

C # (.NET Core) , 68 57 53 + 23 18 bajtów

-11 bajtów dzięki Emignie

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

Liczba bajtów obejmuje również

using System.Linq;

Wypróbuj online!

Punkty są traktowane jako zbiory liczb wewnętrznych. Wyjaśnienie:

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
źródło
3

JavaScript (ES6), 72 71 bajtów

Ten nie jest krótszy niż odpowiedź Neila , ale pomyślałem, że i tak opublikuję go, aby zademonstrować użycie Math.hypot(), które zostało wprowadzone w ES6.

Pobiera dane wejściowe w składni curry (p)(a), gdzie p = [x, y, z] jest punktem bazowym, a a jest tablicą innych punktów.

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

Pokaż fragment kodu

— Arnauld
źródło
3

k , 14 bajtów

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

Wypróbuj 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

Działa to również dla n wymiarów i nie jest ograniczone do 3.

— zgrep
źródło
3

Japt , 10 9 bajtów

-1 bajt dzięki @Shaggy

ñ_íaV m²x

Pobiera punkty jako tablicę trzyelementowych tablic, a punkt bazowy pojedynczą tablicę, w tej kolejności. Nie przyjmuje argumentu rozmiaru.

Wypróbuj online! lub uruchom ogromny sprawdzian z -Rjednego wyjściax,y,z na linię.

Wyjaśnienie

ñ_            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
źródło
Fajnie :) Miałem do 11 bajtów, zanim praca mi przeszkodziła!
— Shaggy
Wygląda na to, że powinno to działać dla 9 bajtów, ale wymaga nieco więcej testów. EDYCJA: Obie wersje zawodzą w drugim i trzecim przypadku testowym.
— Shaggy
@Shaggy, nigdy nie zdawałem sobie sprawy, że ímożna wziąć to na odwrót, to całkiem miłe. Ja też uważam, że to powinno działać; Uruchomię kilka innych przypadków testowych i dokonam edycji, gdy wrócę do komputera.
— Justin Mariner,
Uwaga: -lub nteż działałby zamiast a.
— Shaggy,
2

MATL , 7 bajtów

yZP&SY)

Dane wejściowe to: 3-kolumnowa macierz z punktami jako wierszami i 3-kolumnowy wektor z punktem bazowym.

Wypróbuj w MATL Online!

Wyjaśnienie

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
źródło
2

Galareta , 5 bajtów

Oszczędność 1 bajtu dzięki Dziurawej Zakonnicy .

ạ²SðÞ

Wypróbuj online!

Wyjaśnienie

ạ²SðÞ

    Þ - Sortuj według funkcji przycisku.
ạ - Bezwzględna różnica w stosunku do elementów z drugiej listy danych wejściowych.
 ² - kwadrat. Wektoryzuje.
  S - Suma.
   ð - Rozpoczyna oddzielny łańcuch dyadiczny.
      - Wynik niejawny.
— Pan Xcoder
źródło
Zapisz bajt za pomocą ạS¥Þ(nie zauważyłem twojej odpowiedzi przed wysłaniem mojego).
— Erik the Outgolfer
Hmm ... Myślę, że będziesz musiał wrócić do 5 bajtów, ponieważ odkryłem, że musiszạ²SµÞ
— wyrównać
@EriktheOutgolfer Myślę, że teraz to naprawiłem. Nie jestem jednak pewien
— Mr. Xcoder
Musisz wyrównać przed zsumowaniem (wektoryzacją), a nie po.
— Erik the Outgolfer
@EriktheOutgolfer Powinno już być ok
— Mr. Xcoder
2

Perl 6 , 35 bajtów (33 znaków)

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

Wypróbuj online!

Objaśnienie: Pobiera listę ze współrzędnymi punktu bazowego (nazywanego @b), a następnie listę list ze współrzędnymi innych punktów (nazywanej @p). W bloku możesz ich używać w locie za pomocą ^symbolu. Każda ze ^zmiennych „d” odpowiada jednemu argumentowi. (Są one posortowane alfabetycznie, podobnie @^bjak 1. argument i @^p2.). Po jednym użyciu tego symbolu można normalnie używać zmiennej.

Instrukcja @^bma tylko powiedzieć, że blok przyjmuje argument punktu bazowego, który jest używany tylko w bloku sortującym. (W przeciwnym razie odnosi się do argumentu bloku sortującego.) Metoda .sortmoże przyjąć jeden argument. Jeśli jest to blok przyjmujący 1 argument (jak tutaj), tablica jest sortowana zgodnie z wartościami tej funkcji. Sam blok po prostu bierze kolejno każdy punkt i zamyka go za pomocą minus ( Z-) ze współrzędnymi punktu bazowego. Następnie kwadratujemy wszystkie elementy na liście »²i sumujemy je za pomocą [+].

Jako dodatkowy bonus, będzie to również działać ze współrzędnymi zmiennoprzecinkowymi i w każdym wymiarze (dopóki oczywiście podasz tę samą liczbę współrzędnych dla wszystkich punktów, robi to dobrze).

To nie jest już ważne. Zostawiam to tutaj dla zabawy.

Perl 6 , 24 bajtów - tylko żart!

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

Wypróbuj online!

Ponieważ PO nie określa, która metryka ma zostać użyta, w tym zgłoszeniu zdecydowano się na użycie metryki dyskretnej. W tej metodzie odległość między dwoma punktami wynosi 0, jeśli są identyczne, i 1, jeśli nie są. Łatwo jest sprawdzić, czy rzeczywiście jest to metryka (jeśli ρ (A, B) to odległość od A do B, wymagamy, aby 1) ρ (A, B) = 0 iff A = B, 2) ρ (A, B ) = ρ (B, A), 3) ρ (A, B) + ρ (B, C) ≥ ρ (A, C) („nierówność trójkąta”)).

Prawdopodobnie można by grać w golfa o wiele więcej, ale nie mówię tego poważnie.

— Ramillies
źródło
Nie działa dla <5 5 5>,(<5 5 10>,<6 5 5>). Listy nie są sortowane według ich sumy, ale według porównania elementów. Potrzebujesz sumgdzieś.
— nwellnhof
@nwellnhof, wielkie dzięki. Nie wiem o czym myślałem ... Wkrótce to naprawię.
— Ramillies,
2

Kotlin 1.1, 58 bajtów

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

Upiększony

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

Test

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
źródło
2

Java 8, 194 + 31 214 169 163 123 112 106 + 19 109 103 bajtów

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

Wypróbuj online!

— Roberto Graham
źródło
Nieprawidłowe wyniki: base=[2,3,3], points=[4,3,3],[1,3,4]. Twój wynik jest [4,3,3], [1,3,4], a poprawny wynik to [1,3,4],[4,3,3].
— Olivier Grégoire,
@ OlivierGrégoire Ups, naprawiono
— 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 bajtów), przyjmując List<int[]>parametr jako zamiast int[][].
— Olivier Grégoire,
1
Och, powdziała +=bez obsady, nie w większości innych przypadków. Dobrze wiedzieć!
— Olivier Grégoire,
103 bajty: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 bajtów

o.a,vz

Wypróbuj online: demonstracja

Wyjaśnienie:

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
źródło
1
Herokuapp mówi: Bad Request: Request Line is too large (7005 > 4094). Powinieneś zmniejszyć swój zestaw testowy, aby pasował do maksymalnego rozmiaru łącza.
— Pan Xcoder,
@ Mr.Xcoder Thanks. Naprawiłem to.
— Jakube,
1

Perl 5 , 90 bajtów

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

Wypróbuj online!

Dane wejściowe to lista punktów oddzielona znakiem nowej linii, przy czym pierwsza jest punktem bazowym, a ostatnia ma nową linię końcową. Wsporniki ( []) wokół współrzędnych są opcjonalne.

— Xcali
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.