15

Technische Daten

Sie haben einen kubischen 3D-Raum x,y,zmit Sganzzahligen Größeneinheiten, z 0 <= x,y,z <= S.
Sie erhalten von Standard - Eingabemethoden eine Reihe von Punkten Pwie dargestellt x,y,zganzzahligen Koordinaten, in jedem vernünftigen Format , wie Sie mögen, zum Beispiel: [x1,y1,z1],[x2,y2,z2],[x3,y3,z3] ... [xn,yn,zn].
Alle PWerte werden in dem oben genannten kubischen 3D-Raum liegen, wie z 0 <= x,y,z <= S.
Die mögliche Gesamtzahl Pwird sein .1 <= P <= S³
Als Eingabe erhalten Sie auch die x,y,zganzzahligen Koordinaten des Basispunkts B und die 3D-Würfelgröße S.

Aufgabe

Ihr Ziel ist die Ausgabe der Punkte in Ihrem bevorzugten Format, Psortiert nach dem linearen (euklidischen) Abstand vom Basispunkt B .

Regeln

Wenn Sie mehr als einen Punkt Pmit gleichem Abstand finden B, müssen Sie alle Äquidistanten Pin Ihrer bevorzugten Reihenfolge ausgeben .
Es ist möglich, dass ein Punkt Pmit dem Punkt übereinstimmt B, sodass die Entfernung der Punkte so ist 0, dass Sie diesen Punkt ausgeben müssen.
Dies ist eine Code-Golf- Herausforderung, also gewinnt der kürzeste Code.
Standardlücken sind verboten.
Code-Erklärungen sind willkommen.

Testfälle

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
quelle

1

Muss man das wirklich Sals Parameter nehmen?

— Cristian Lupascu

@GolfWolf Wenn du es nicht brauchst, nimm es nicht.

— Mario

2

Es wird dringend empfohlen, anzugeben, welche Art von Metrik von uns verwendet werden soll. Einige Leute verwenden die euklidische Metrik (ρ = √ [(x₁-x₂) ² + (y₁-y₂) ² + (z₁-z₂) ²]), andere die Manhattan-Metrik (ρ = | x₁-x₂ | + | y₁-y₂) | + | z₁-z₂ |). Meiner Meinung nach sollte jeder die gleiche Metrik verwenden.

— Ramillies

4

@ Ramillies: Die Herausforderung gibt die lineare Distanz an, die in meinen Augen euklidisch ist . Ich würde Manhattan nicht linear nennen, aber ich stimme zu, dass es schwieriger sein sollte, die Herausforderung falsch zu verstehen, wenn man genau angibt, welche Metrik verwendet werden soll.

— Emigna

1

Sagen Sie nicht linear, sagen Sie euklidisch.

— Lyndon White

11

05AB1E , 4 Bytes

ΣαnO

Probieren Sie es online!

Erläuterung

Σ        # sort by
   O     # sum of
  n      # square of
 α       # absolute difference between current value and second input

— Emigna
quelle

Warum brauchen Sie n?

— Erik der Outgolfer

@EriktheOutgolfer: Vielleicht kann dieses kleine Beispiel den Unterschied zwischen Quadrieren und Nicht-Quadrieren zeigen.

— Emigna

Also, macht jeder es falsch oder macht jeder es richtig?

— Erik der Outgolfer

@EriktheOutgolfer: Ich habe nicht alle Antworten überprüft, aber die meisten scheinen korrekt zu sein.

— Emigna

Viele Antworten stimmen nicht überein, deshalb habe ich gefragt, da sie genau den gleichen Algorithmus verwenden.

— Erik der 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
quelle

Ich denke, Sie können ein Byte sparen, indem Sie die Definition von ginside ändern und verschieben sort.

1

@ThePirateBay: Neil macht kein Curry!

— Shaggy

6

Haskell , 54 52 Bytes

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

Probieren Sie es online!

Ich brauche nicht die Größe des Raums. sum.map(^2).zipWith(-)oberechnet den Abstand von einem Punkt zu o: (xo-xp)^2+(yo-yp)^2+(zo-zp)^2. Die Punkte werden einfach nach der Entfernung zu sortiert o.

BEARBEITEN : "Wenn Sie es nicht brauchen, nehmen Sie es nicht" 2 Bytes gespeichert.

— jferard
quelle

5

Python 3 , 68 64 Bytes

-4 Bytes dank @Ramillies

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

Probieren Sie es online!

— ovs
quelle

4

R , 56 40 Bytes

-16 bytes dank flodel für den vorschlag eines anderen eingabeformats

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

Probieren Sie es online!

Nimmt Pals 3xnMatrix von Punkten, dh jede Spalte ist ein Punkt; Die Ausgabe erfolgt im selben Format.

Verwenden Sie die Hilfsfunktion, gum die Liste der Punkte Paus den Testfällen in das entsprechende R-Format umzuwandeln.

— Giuseppe
quelle

1

Vielleicht ist das Ersetzen sapply()mit colSums((t(P)-B)^2), wo der Eingang Pwäre eine Matrix sein?

— Flodel

@flodel wenn ich das mache, kann ich das genauso gut Pals 3xnMatrix nehmen und einfach colSums((P-B)^2)stattdessen machen!

— Giuseppe

3

Mathematica, 24 Bytes

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

Übernimmt Eingaben im Format f[B][P].

Wir müssen 4 Bytes verwenden x, um die verschachtelte Funktion zu erstellen. Der Vorrang von  ( \[Function]) und //funktioniert gut, so dass der Ausdruck dem folgenden entspricht:

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

Wir brauchen, Nweil Mathematica standardmäßig nach Ausdrucksstruktur statt nach Wert sortiert:

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

SortBy[N][{1, Sqrt@2, 2}]
{1, Sqrt[2], 2}

— hftf
quelle

3

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

-11 Bytes dank Emigna

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

Die Byteanzahl umfasst auch

using System.Linq;

Probieren Sie es online!

Punkte werden als Sammlungen von Ints behandelt. Erläuterung:

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
quelle

3

JavaScript (ES6), 72 bis 71 Byte

Dieser ist nicht kürzer als Neils Antwort , aber ich dachte, ich würde ihn trotzdem posten, um die Verwendung von zu demonstrieren Math.hypot(), die in ES6 eingeführt wurde.

Nimmt Eingaben in Curry-Syntax vor (p)(a), wobei p = [x, y, z] der Basispunkt und a das Array anderer Punkte ist.

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

Code-Snippet anzeigen

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

Erweitern Sie das Snippet

— Arnauld
quelle

3

k , 14 Bytes

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

Probieren Sie es 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

Dies funktioniert auch für n Dimensionen und ist nicht auf 3 beschränkt.

— zgrep
quelle

3

Japt , 10 9 Bytes

-1 Byte dank @Shaggy

ñ_íaV m²x

Nimmt Punkte als Array von Arrays mit drei Elementen und den Basispunkt als einzelnes Array in dieser Reihenfolge. Nimmt das Größenargument nicht an.

Probieren Sie es online! oder führen Sie den großen Testfall mit aus, -Rum einen x,y,zpro Zeile auszugeben .

Erläuterung

ñ_            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
quelle

Nizza :) Ich war bis zu 11 Bytes, bevor die Arbeit im Weg stand!

— Shaggy

Sieht so aus, als ob dies für 9 Bytes funktionieren sollte, es sind jedoch noch einige Tests erforderlich. BEARBEITEN: Beide Versionen schlagen im 2. und 3. Testfall fehl.

— Shaggy

@ Shaggy Ich hätte nie gedacht, dass ich ídie Argumente umgekehrt sehen könnte, das ist ziemlich nett. Ich denke auch, dass es funktionieren sollte; Ich führe einige der anderen Testfälle aus und bearbeite sie, wenn ich wieder an einem Computer bin.

— Justin Mariner

Hinweis: -oder nwürde auch anstelle von arbeiten a.

— Shaggy

2

MATL , 7 Bytes

yZP&SY)

Eingaben sind: 3-Spalten-Matrix mit Punkten als Zeilen und 3-Spalten-Vektor mit Basispunkt.

Probieren Sie es bei MATL Online!

Erläuterung

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
quelle

2

Gelee , 5 Bytes

1 Byte gespeichert, dank Leaky Nun .

ạ²SðÞ

Probieren Sie es online!

Erläuterung

ạ²SðÞ

    Þ - Nach Tastenfunktion sortieren.
ạ - Absoluter Unterschied zu den Elementen in der zweiten Eingabeliste.
 ² - Quadrat. Vektorisiert.
  S - Summe.
   ð - Startet eine separate dyadische Kette.
      - Implizit ausgeben.

— Mr. Xcoder
quelle

Speichere ein Byte mit ạS¥Þ(habe deine Antwort nicht bemerkt, bevor du meine gepostet hast).

— Erik der Outgolfer

Hmm ... Ich denke, Sie müssen auf 5 Bytes zurückgehen, da ich herausgefunden habe, dass Sie das Quadrat benötigen :ạ²SµÞ

— Erik the Outgolfer

@EriktheOutgolfer Ich glaube, ich habe es jetzt behoben. Ich

— bin

Sie müssen vor dem Summieren quadrieren (vektorisieren), nicht danach.

— Erik der Outgolfer

@EriktheOutgolfer Sollte jetzt in Ordnung sein

— Mr. Xcoder

2

Perl 6 , 35 Bytes (33 Zeichen)

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

Probieren Sie es online!

Erläuterung: Es wird eine Liste mit den Koordinaten des Basispunkts (aufgerufen @b) erstellt und anschließend eine Liste mit den Koordinaten der anderen Punkte (aufgerufen @p). In einem Block können Sie sie mithilfe des ^Symbols im laufenden Betrieb verwenden. Jede der ^Variablen 'd entspricht einem Argument. (Sie sind alphabetisch sortiert, ebenso @^bdas erste und @^pdas zweite Argument .) Nach einmaliger Verwendung dieses Symbols können Sie die Variable normal verwenden.

Die Anweisung @^bsoll nur sagen, dass der Block das Basispunktargument übernimmt, das nur innerhalb des Sortierblocks verwendet wird. (Andernfalls wird auf das Argument des Sortierblocks verwiesen.) Die Methode .sortkann ein Argument annehmen. Wenn es sich um einen Block mit 1 Argument handelt (wie hier), wird das Array nach den Werten dieser Funktion sortiert. Der Block selbst nimmt einfach jeden Punkt der Reihe nach und zippt ihn mit minus ( Z-) mit den Basispunktkoordinaten. Dann quadrieren wir alle Elemente in der Liste mit »²und addieren sie mit [+].

Als zusätzlichen Bonus funktioniert dies auch mit Float-Koordinaten und in jeder Dimension (solange Sie für alle Punkte die gleiche Anzahl von Koordinaten angeben, ist dies das Richtige).

Dies ist nicht mehr gültig. Ich lasse es hier nur zum Spaß.

Perl 6 , 24 Bytes - nur ein Witz!

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

Probieren Sie es online!

Da das OP nicht angibt, welche Metrik verwendet werden soll, wählt diese Einreichung die Verwendung der diskreten Metrik. In dieser Metrik ist der Abstand zwischen zwei Punkten 0, wenn sie identisch sind, und 1, wenn sie nicht identisch sind. Es ist leicht zu überprüfen, ob es sich tatsächlich um eine Metrik handelt (wenn ρ (A, B) der Abstand von A nach B ist, benötigen wir 1) ρ (A, B) = 0, wenn A = B, 2) ρ (A, B) ) = ρ (B, A), 3) ρ (A, B) + ρ (B, C) ≥ ρ (A, C) ("Dreieckungleichung").

Es könnte wahrscheinlich viel mehr Golf gespielt werden, aber ich meine es nicht ernst.

— Ramillies
quelle

Funktioniert nicht für <5 5 5>,(<5 5 10>,<6 5 5>). Listen werden nicht nach ihrer Summe sortiert, sondern nach Elementen. Du brauchst sumirgendwo einen.

— Nwellnhof

@nwellnhof, vielen dank. Ich weiß nicht, was ich gedacht habe ... Wird in Kürze behoben.

— Ramillies

2

Kotlin 1.1, 58 Bytes

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

Verschönert

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

Prüfung

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
quelle

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

Probieren Sie es online!

— Roberto Graham
quelle

Falsche Ergebnisse: base=[2,3,3], points=[4,3,3],[1,3,4]. Ihr Ergebnis ist [4,3,3], [1,3,4], während das richtige Ergebnis ist [1,3,4],[4,3,3].

— Olivier Grégoire

@ OlivierGrégoire Ups, behoben

— 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) unter der Annahme eines List<int[]>as-Parameters anstelle von int[][].

— Olivier Grégoire

1

Oh, powfunktioniert +=ohne Cast, in den meisten anderen Fällen nicht. Gut zu wissen!

— Olivier Grégoire

103 Bytes:B->P->P.sort(java.util.Comparator.comparing(p->{int d=0,i=0;while(i<3)d+=(d=p[i]-B[i++])*d;return d;}))

— Nevay

1

Pyth, 6 Bytes

o.a,vz

Probieren Sie es online aus: Demonstration

Erläuterung:

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
quelle

1

Herokuapp sagt: Bad Request: Request Line is too large (7005 > 4094). Sie sollten Ihre Testsuite verkleinern, um die maximale Linkgröße zu erreichen.

— Mr. Xcoder

@ Mr.Xcoder Danke. Ich habe es repariert.

— 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}<>

Probieren Sie es online!

Die Eingabe ist eine durch Zeilenumbrüche getrennte Liste von Punkten, wobei der erste Punkt der Basispunkt ist und der letzte eine abschließende Zeilenumbrüche aufweist. Klammern ( []) um die Koordinaten sind optional.

— Xcali
quelle

Sortieren Sie die Punkte in einem 3D-Raum nach linearem Abstand

05AB1E , 4 Bytes

JavaScript (ES6), 71 Byte

Haskell , 54 52 Bytes

Python 3 , 68 64 Bytes

R , 56 40 Bytes

Mathematica, 24 Bytes

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

JavaScript (ES6), 72 bis 71 Byte

k , 14 Bytes

Japt , 10 9 Bytes

Erläuterung

MATL , 7 Bytes

Erläuterung

Gelee , 5 Bytes

Erläuterung

Perl 6 , 35 Bytes (33 Zeichen)

Dies ist nicht mehr gültig. Ich lasse es hier nur zum Spaß.

Perl 6 , 24 Bytes - nur ein Witz!

Kotlin 1.1, 58 Bytes

Verschönert

Prüfung

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

Pyth, 6 Bytes

Erläuterung:

Perl 5 , 90 Bytes