15

Okular

Masz sześcienną przestrzeń 3D jednostek liczb całkowitych x,y,zwielkości S, takich jak 0 <= x,y,z <= S.
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].
Wszystkie Pwartości będą w wyżej wymienionej sześciennej przestrzeni 3D, np 0 <= x,y,z <= S.
Możliwa całkowita liczba Pto .1 <= P <= S³
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

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.
Możliwe jest, że punkt Pzbiegnie się B, więc jego odległość wynosi 0, musisz go wyprowadzić.
To wyzwanie dla golfa , więc wygrywa najkrótszy kod.
Standardowe luki są zabronione.
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,

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

5

Python 3 , 68 64 bajtów

-4 bajty dzięki @Ramillies

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

Wypróbuj online!

ovs
ź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

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]])))

Expand snippet

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

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

Odpowiedzi:

05AB1E , 4 bajty

JavaScript (ES6), 71 bajtów

Haskell , 54 52 bajty

Python 3 , 68 64 bajtów

R , 56 40 bajtów

Mathematica, 24 bajty

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

JavaScript (ES6), 72 71 bajtów

k , 14 bajtów

Japt , 10 9 bajtów

Wyjaśnienie

MATL , 7 bajtów

Wyjaśnienie

Galareta , 5 bajtów

Wyjaśnienie

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

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

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

Kotlin 1.1, 58 bajtów

Upiększony

Test

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

Pyth, 6 bajtów

Wyjaśnienie:

Perl 5 , 90 bajtów