Ordenar los puntos por distancia lineal en un espacio 3D

15

Especificaciones

  1. Tiene un espacio cúbico 3D x,y,zde Sunidades enteras de tamaño , como 0 <= x,y,z <= S.
  2. Que se obtiene de los métodos de entrada por defecto una serie de puntos Prepresentados como x,y,zcoordenadas enteras, en cualquier formato razonable como desee, por ejemplo: [x1,y1,z1],[x2,y2,z2],[x3,y3,z3] ... [xn,yn,zn].
  3. Todos los Pvalores estarán en el espacio cúbico 3D mencionado anteriormente, como 0 <= x,y,z <= S.
  4. El número total posible de Pserá .1 <= P <= S3
  5. También obtiene como entrada las x,y,zcoordenadas enteras del punto base B y el tamaño del cubo 3D S.

Tarea

Su objetivo es generar, en su formato preferido, los puntos Pordenados por la distancia lineal (Euclidiana) desde el punto base B .

Reglas

  1. Si encuentra más de un punto Pque es equidistante B, debe mostrar todos los equidistantes Pen su orden preferido.
  2. Es posible que un punto Pcoincida B, por lo que su distancia es 0, debe generar ese punto.
  3. Este es un desafío de código de golf , por lo que gana el código más corto.
  4. Las lagunas estándar están prohibidas.
  5. Se agradecen las explicaciones del código.

Casos de prueba

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
fuente
1
¿Es realmente necesario tomar Scomo parámetro?
Cristian Lupascu
@GolfWolf si no lo necesitas, no lo tomes.
Mario
2
Le recomiendo que especifique qué tipo de métrica desea que usemos. Algunas personas usan métrica euclidiana (ρ = √ [(x₁-x₂) ² + (y₁-y₂) ² + (z₁-z₂) ²]), otras usan métrica de Manhattan (ρ = | x₁-x₂ | + | y₁-y₂ | + | z₁-z₂ |). En mi opinión, todos deberían usar la misma métrica.
Ramillies
44
@Ramillies: El desafío especifica una distancia lineal que, en mi opinión, es euclidiana . No llamaría a Manhattan lineal, pero estoy de acuerdo en que especificar específicamente qué métrica usar debería dificultar la comprensión errónea del desafío.
Emigna
1
No digas lineal, di Euclidiana.
Lyndon White

Respuestas:

11

05AB1E , 4 bytes

ΣαnO

Pruébalo en línea!

Explicación

Σ        # sort by
   O     # sum of
  n      # square of
 α       # absolute difference between current value and second input
Emigna
fuente
¿Por qué lo necesitas n?
Erik the Outgolfer
@EriktheOutgolfer: Tal vez este pequeño ejemplo puede mostrar la diferencia entre cuadrar y no.
Emigna
Entonces, ¿todos lo están haciendo mal o todos lo están haciendo bien?
Erik the Outgolfer
@EriktheOutgolfer: No he verificado todas las respuestas, pero la mayoría parece ser correcta.
Emigna
Muchas respuestas no cuadran, por eso pregunté, ya que están usando exactamente el mismo algoritmo.
Erik the Outgolfer
6

JavaScript (ES6), 71 bytes

(b,a,g=a=>a.reduce((d,c,i)=>d+(c-=b[i])*c,0))=>a.sort((b,a)=>g(b)-g(a))
Neil
fuente
Creo que puede guardar un byte utilizando el currículum y la definición móvil del ginterior sort.
1
@ThePirateBay: ¡Neil no hace curry!
Shaggy
6

Haskell , 54 52 bytes

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

Pruébalo en línea!

No necesito el tamaño del espacio. sum.map(^2).zipWith(-)ocalcula la distancia de un punto a o: (xo-xp)^2+(yo-yp)^2+(zo-zp)^2. Los puntos simplemente se ordenan en la distancia a o.

EDITAR : "si no lo necesita, no lo tome" guardó 2 bytes.

jferard
fuente
4

R , 56 40 bytes

-16 bytes gracias a flodel por sugerir un formato de entrada diferente

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

Pruébalo en línea!

Toma P como una 3xnmatriz de puntos, es decir, cada columna es un punto; La salida está en el mismo formato.

Use la función auxiliar gpara transformar la lista de puntos Pde los casos de prueba al formato R apropiado.

Giuseppe
fuente
1
Tal vez reemplace sapply()con colSums((t(P)-B)^2), donde la entrada Psería una matriz?
flodel
@flodel si voy a hacer eso, ¡también podría tomarlo Pcomo una 3xnmatriz y simplemente hacerlo colSums((P-B)^2)!
Giuseppe
3

Mathematica, 24 bytes

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

Toma entrada en el formato f[B][P].

Tenemos que usar 4 bytes xpara hacer la función anidada. La precedencia de  ( \[Function]) y //funciona bien para que la expresión sea equivalente a esto:

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

Necesitamos Nporque, por defecto, Mathematica ordena por estructura de expresión en lugar de por valor:

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

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

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

-11 bytes gracias a Emigna

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

El recuento de bytes también incluye

using System.Linq;

Pruébalo en línea!

Los puntos se tratan como colecciones de entradas. Explicación:

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

JavaScript (ES6), 72 71 bytes

Este no es más corto que la respuesta de Neil , pero pensé que lo publicaría de todos modos para demostrar el uso de Math.hypot(), que se introdujo en ES6.

Toma entrada en la sintaxis de curry (p)(a), donde p = [x, y, z] es el punto base y a es la matriz de otros puntos.

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

Mostrar fragmento de código

Arnauld
fuente
3

k , 14 bytes

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

Pruébalo en línea!

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

Además, esto funciona para n dimensiones, y no está limitado a 3.

zgrep
fuente
3

Japt , 10 9 bytes

-1 byte gracias a @Shaggy

ñ_íaV m²x

Toma puntos como un conjunto de conjuntos de tres elementos y el punto base como un conjunto único, en ese orden. No toma el argumento del tamaño.

Pruébalo en línea! o ejecutar el gran caso de prueba con-R una salida x,y,zpor línea.

Explicación

ñ_            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
fuente
Agradable :) ¡Había reducido a 11 bytes antes de que el trabajo se interpusiera!
Shaggy
Parece que esto debería funcionar para 9 bytes, pero necesita algunas pruebas más. EDITAR: Ambas versiones fallan en los casos de segunda y tercera prueba.
Shaggy
@Shaggy Nunca me di cuenta de que ípodría tomar sus argumentos al revés, eso es bastante bueno. Yo también creo que debería funcionar; Ejecutaré algunos de los otros casos de prueba y los editaré cuando vuelva a la computadora.
Justin Mariner
Nota: -o ntambién funcionaría en lugar de a.
Shaggy
2

MATL , 7 bytes

yZP&SY)

Las entradas son: matriz de 3 columnas con puntos como filas, y vector de 3 columnas con punto base.

¡Pruébalo en MATL Online!

Explicación

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

Jalea , 5 bytes

Guardado 1 byte, gracias a Leaky Nun .

ạ²SðÞ

Pruébalo en línea!

Explicación

ạ²SðÞ

    Þ - Ordenar por función de la tecla.
ạ - Diferencia absoluta con los elementos en la segunda lista de entrada.
 ² - Cuadrado. Vectoriza
  S - Suma.
   ð - Inicia una cadena diádica separada.
      - Salida implícita.
Sr. Xcoder
fuente
Guarde un byte con ạS¥Þ(no noté su respuesta antes de publicar la mía).
Erik the Outgolfer
Hmm ... Creo que tendrá que volver a 5 bytes ya que descubrí que necesita cuadrar :ạ²SµÞ
Erik the Outgolfer
@EriktheOutgolfer Creo que lo arreglé ahora. Aunque no estoy seguro
Sr. Xcoder
Debe cuadrar antes de sumar (vectorizar), no después.
Erik the Outgolfer
@EriktheOutgolfer debería estar bien ahora
Sr. Xcoder
2

Perl 6 , 35 bytes (33 caracteres)

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

Pruébalo en línea!

Explicación: Esto toma una lista con las coordenadas del punto base (llamado @b), luego una lista de listas con coordenadas de los otros puntos (llamado @p). En un bloque, puede usarlos sobre la marcha usando el ^símbolo. Cada una de las ^variables 'd corresponde a un argumento. (Están ordenados alfabéticamente, así @^bes el primer argumento y @^pel segundo.) Después de un uso de este símbolo, puede usar la variable normalmente.

La declaración @^bestá ahí solo para decir que el bloque tomará el argumento del punto base, que se usa solo dentro del bloque de clasificación. (De lo contrario, se referiría al argumento del bloque de clasificación). El método .sortpuede tomar un argumento. Si es un bloque que toma 1 argumento (como aquí), la matriz se ordena de acuerdo con los valores de esa función. El bloque en sí solo toma cada punto por turno y lo comprime con menos ( Z-) con las coordenadas del punto base. Luego cuadramos todos los elementos de la lista »²y los sumamos usando [+].

Como beneficio adicional, esto también funcionará con coordenadas flotantes, y en cualquier dimensión (siempre y cuando, obviamente, proporcione el mismo número de coordenadas para todos los puntos, hace lo correcto).

Esto ya no es válido. Lo dejo aquí solo por diversión.

Perl 6 , 24 bytes, ¡solo una broma!

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

Pruébalo en línea!

Dado que el OP no indica qué métrica se utilizará, esta presentación elige utilizar la métrica discreta. En esta métrica, la distancia entre dos puntos es 0 si son idénticos y 1 si no lo son. Es fácil comprobar que esto es realmente una métrica (si ρ (A, B) es la distancia de A a B, requerimos que 1) ρ (A, B) = 0 iff A = B, 2) ρ (A, B ) = ρ (B, A), 3) ρ (A, B) + ρ (B, C) ≥ ρ (A, C) ("desigualdad triangular")).

Probablemente podría jugar mucho más al golf, pero no lo digo en serio.

Ramillies
fuente
No funciona para <5 5 5>,(<5 5 10>,<6 5 5>). Las listas no se ordenan por su suma, sino por comparación por elementos. Necesitas un sumlugar.
nwellnhof
@nwellnhof, muchas gracias. No sé lo que estaba pensando ... Se solucionará en breve.
Ramillies
2

Kotlin 1.1, 58 bytes

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

Embellecido

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

Prueba

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

Pruébalo en línea!

Roberto Graham
fuente
Resultados erróneos: base=[2,3,3], points=[4,3,3],[1,3,4]. Su resultado es [4,3,3], [1,3,4], mientras que el resultado correcto es [1,3,4],[4,3,3].
Olivier Grégoire
@ OlivierGrégoire Vaya, arreglado
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), suponiendo un List<int[]>como parámetro en lugar de int[][].
Olivier Grégoire
1
Oh, powfunciona +=sin yeso, no en la mayoría de los otros casos. ¡Bueno saber!
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

Pruébalo en línea: demostración

Explicación:

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
fuente
1
Herokuapp dice: Bad Request: Request Line is too large (7005 > 4094). Debe hacer que su conjunto de pruebas sea más pequeño para que se ajuste al tamaño máximo del enlace.
Sr. Xcoder
@ Mr.Xcoder Gracias. Lo arreglé.
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}<>

Pruébalo en línea!

La entrada es una lista de puntos separados por una nueva línea, siendo el primero el punto base y el último con una nueva línea final. Los corchetes ( []) alrededor de las coordenadas son opcionales.

Xcali
fuente