Ordina i punti per distanza lineare in uno spazio 3D

15

Specifiche

  1. Hai uno spazio 3D cubico x,y,zdi Sunità di dimensioni intere, ad esempio 0 <= x,y,z <= S.
  2. Si ottiene da metodi di input predefiniti una matrice di punti Prappresentati come x,y,zcoordinate intere, in qualsiasi formato ragionevole a piacere, ad esempio: [x1,y1,z1],[x2,y2,z2],[x3,y3,z3] ... [xn,yn,zn].
  3. Tutti i Pvalori saranno nello spazio cubico 3D sopra indicato, come ad esempio 0 <= x,y,z <= S.
  4. Il possibile numero totale di Psarà .1 <= P <= S3
  5. Inoltre ottieni come input le x,y,zcoordinate intere del punto base B e la dimensione del cubo 3D S.

Compito

Il tuo obiettivo è quello di produrre, nel tuo formato preferito, i punti Pordinati in base alla distanza lineare (euclidea) dal punto base B .

Regole

  1. Se trovi più di un punto Pequidistante da Bte, devi generare tutti gli equidistanti Pnel tuo ordine preferito.
  2. È possibile che un punto Pcoincida B, quindi la loro distanza è 0, è necessario emettere quel punto.
  3. Questa è una sfida di code-golf , quindi vince il codice più corto.
  4. Sono vietate le scappatoie standard .
  5. Le spiegazioni del codice sono apprezzate.

Casi test

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
fonte
1
È davvero necessario prendere Scome parametro?
— Cristian Lupascu,
@GolfWolf se non ti serve, non prenderlo.
— Mario,
2
Consiglio vivamente di specificare quale tipo di metrica desideri che utilizziamo. Alcune persone usano la metrica euclidea (ρ = √ [(x₁-x₂) ² + (y₁-y₂) ² + (z₁-z₂) ²]), altri usano la metrica di Manhattan (ρ = | x₁-x₂ | + | y₁-y₂ | + | z₁-z₂ |). Secondo me tutti dovrebbero usare la stessa metrica.
— Ramillies,
4
@Ramillies: La sfida specifica la distanza lineare che nella mia mente è euclidea . Non chiamerei Manhattan lineare, ma concordo sul fatto che specificare specificamente quale metrica utilizzare dovrebbe rendere più difficile fraintendere la sfida.
— Emigna,
1
Non dire lineare, dì Euclideo.
— Lyndon White,

Risposte:

11

05AB1E , 4 byte

ΣαnO

Provalo online!

Spiegazione

Σ        # sort by
   O     # sum of
  n      # square of
 α       # absolute difference between current value and second input
— Emigna
fonte
Perché avete bisogno n?
— Erik the Outgolfer,
@EriktheOutgolfer: forse questo piccolo esempio può mostrare la differenza tra quadratura e non.
— Emigna,
Quindi, tutti lo stanno facendo male o tutti lo stanno facendo bene?
— Erik the Outgolfer,
@EriktheOutgolfer: non ho controllato tutte le risposte, ma la maggior parte sembra essere corretta.
— Emigna,
Molte risposte non quadrano, ecco perché l'ho chiesto, poiché usano esattamente lo stesso algoritmo.
— Erik the Outgolfer,
6

JavaScript (ES6), 71 byte

(b,a,g=a=>a.reduce((d,c,i)=>d+(c-=b[i])*c,0))=>a.sort((b,a)=>g(b)-g(a))
— Neil
fonte
Penso che puoi salvare un byte usando il curry e spostando la definizione di ginside sort.
1
@ThePirateBay: Neil non fa curry!
— Shaggy,
6

Haskell , 54 52 byte

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

Provalo online!

Non ho bisogno delle dimensioni dello spazio. sum.map(^2).zipWith(-)ocalcola la distanza da un punto a o: (xo-xp)^2+(yo-yp)^2+(zo-zp)^2. I punti vengono semplicemente ordinati in base alla distanza o.

EDIT : "se non ti serve, non prenderlo" salvato 2 byte.

— jferard
fonte
4

R , 56 40 byte

-16 byte grazie a flodel per aver suggerito un diverso formato di input

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

Provalo online!

Prende Pcome una 3xnmatrice di punti, cioè ogni colonna è un punto; l'output è nello stesso formato.

Utilizzare la funzione di aiuto g per trasformare l'elenco di punti Pdai casi di test nel formato R appropriato.

— Giuseppe
fonte
1
Forse sostituire il sapply()con colSums((t(P)-B)^2), dove l'ingresso Psarebbe una matrice?
— flodel,
@flodel, se ho intenzione di farlo, posso anche prendere Puna 3xnmatrice e fare colSums((P-B)^2)invece invece!
— Giuseppe,
3

Mathematica, 24 byte

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

Accetta input nel formato f[B][P] .

Dobbiamo usare 4 byte su xper rendere la funzione nidificata. La precedenza di  ( \[Function]) e //funziona bene in modo che l'espressione sia equivalente a questa:

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

Abbiamo bisogno Nperché per impostazione predefinita, Mathematica ordina per struttura di espressione anziché per valore:

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

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

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

-11 byte grazie a Emigna

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

Il conteggio dei byte include anche

using System.Linq;

Provalo online!

I punti sono trattati come raccolte di ints. Spiegazione:

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

JavaScript (ES6), 72 71 byte

Questo non è più breve della risposta di Neil , ma ho pensato di pubblicarlo comunque per dimostrare l'uso diMath.hypot() , che è stato introdotto in ES6.

Accetta input nella sintassi del curry (p)(a), dove p = [x, y, z] è il punto base e a è l'array di altri punti.

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

Mostra snippet di codice

— Arnauld
fonte
3

k , 14 byte

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

Provalo 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

Inoltre, funziona con n dimensioni e non è limitato a 3.

— zgrep
fonte
3

Japt , 10 9 byte

-1 byte grazie a @Shaggy

ñ_íaV m²x

Prende punti come un array di array a tre elementi e il punto base è un singolo array, in quell'ordine. Non accetta l'argomento size.

Provalo online! oppure esegui l' enorme caso di test con -Rl'output di uno x,y,zper riga.

Spiegazione

ñ_            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
fonte
Bello :) Ero giù a 11 byte prima che il lavoro si mettesse in mezzo!
— Shaggy,
Sembra che questo dovrebbe funzionare per 9 byte, ma ha bisogno di ulteriori test. EDIT: Entrambe le versioni falliscono nel 2 ° e 3 ° caso di test.
— Shaggy,
@Shaggy Non mi ero mai reso conto di ípoter prendere le sue argomentazioni al contrario, è abbastanza carino. Anch'io penso che dovrebbe funzionare; Eseguirò alcuni degli altri casi di test e li modificherò quando torno a un computer.
— Justin Mariner,
Nota: -o nfunzionerebbe anche al posto di a.
— Shaggy,
2

MATL , 7 byte

yZP&SY)

Gli input sono: matrice a 3 colonne con punti come righe e vettore a 3 colonne con punto base.

Provalo a MATL Online!

Spiegazione

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

Gelatina , 5 byte

Salvato 1 byte, grazie a Leaky Nun .

ạ²SðÞ

Provalo online!

Spiegazione

ạ²SðÞ

    Þ - Ordina per funzione tasto.
ạ - Differenza assoluta con gli elementi nel secondo elenco di input.
 ² - Quadrato. Vettorizza.
  S - Somma.
   ð - Avvia una catena diadica separata.
      - Uscita implicita.
— Mr. Xcoder
fonte
Salva un byte con ạS¥Þ(non ho notato la tua risposta prima di pubblicare la mia).
— Erik the Outgolfer,
Hmm ... Penso che dovrai tornare a 5 byte poiché ho scoperto che devi quadrare :ạ²SµÞ
— Erik the Outgolfer,
@EriktheOutgolfer Penso di averlo risolto ora. Non sono sicuro però
— Mr. Xcoder,
Devi quadrare prima di sommare (vettorializzare), non dopo.
— Erik the Outgolfer,
@EriktheOutgolfer Dovrebbe essere ok ora
— Mr. Xcoder,
2

Perl 6 , 35 byte (33 caratteri)

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

Provalo online!

Spiegazione: Questo prende un elenco con le coordinate del punto base (chiamato @b), quindi un elenco di elenchi con coordinate degli altri punti (chiamato @p). In un blocco, puoi usarli al volo usando il ^simbolo. Ognuna delle ^variabili 'd corrisponde a un argomento. (Sono ordinati alfabeticamente, così @^bcome il 1 ° argomento e@^p il 2 °.) Dopo un uso di questo simbolo, è possibile utilizzare normalmente la variabile.

L'affermazione @^bè lì solo per dire che il blocco prenderà l'argomento del punto base, che viene utilizzato solo all'interno del blocco di ordinamento. (Altrimenti farebbe riferimento all'argomento del blocco di ordinamento.) Il metodo .sortpuò accettare un argomento. Se è un blocco che accetta 1 argomento (come qui), l'array viene ordinato in base ai valori di quella funzione. Il blocco stesso prende solo ogni punto a sua volta e lo zip con meno ( Z-) con le coordinate del punto base. Quindi quadriamo tutti gli elementi nell'elenco »²e li sommiamo usando [+].

Come bonus aggiuntivo, funzionerà anche con coordinate float e in qualsiasi dimensione (purché tu, ovviamente, fornisca lo stesso numero di coordinate per tutti i punti, faccia la cosa giusta).

Questo non è più valido Lo lascio qui solo per divertimento.

Perl 6 , 24 byte - solo uno scherzo!

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

Provalo online!

Poiché l'OP non indica quale metrica deve essere utilizzata, questa presentazione sceglie di utilizzare la metrica discreta. In questa metrica, la distanza tra due punti è 0 se sono identici e 1 se non lo sono. È facile verificare che si tratti effettivamente di una metrica (se ρ (A, B) è distanza da A a B, è necessario che 1) ρ (A, B) = 0 iff A = B, 2) ρ (A, B ) = ρ (B, A), 3) ρ (A, B) + ρ (B, C) ≥ ρ (A, C) ("disuguaglianza del triangolo")).

Probabilmente potrebbe essere giocato a golf molto di più, ma non intendo sul serio.

— Ramillies
fonte
Non funziona per <5 5 5>,(<5 5 10>,<6 5 5>). Gli elenchi non ordinano in base alla loro somma, ma in base al confronto saggio degli elementi. Hai bisogno di un sumposto.
— nwellnhof,
@nwellnhof, molte grazie. Non so cosa stavo pensando ... Risolverà a breve.
— Ramillies,
2

Kotlin 1.1, 58 byte

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

Abbellire

// 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
fonte
2

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

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

Provalo online!

— Roberto Graham
fonte
Risultati errati: base=[2,3,3], points=[4,3,3],[1,3,4]. Il tuo risultato è [4,3,3], [1,3,4], mentre il risultato corretto è [1,3,4],[4,3,3].
— Olivier Grégoire,
@ OlivierGrégoire Oops, risolto
— 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 byte), assumendo un List<int[]>parametro come anziché int[][].
— Olivier Grégoire,
1
Oh, powfunziona +=senza cast, non nella maggior parte degli altri casi. Bello sapere!
— Olivier Grégoire,
103 byte:B->P->P.sort(java.util.Comparator.comparing(p->{int d=0,i=0;while(i<3)d+=(d=p[i]-B[i++])*d;return d;}))
— Nevay,
1

Pyth, 6 byte

o.a,vz

Provalo online: dimostrazione

Spiegazione:

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
fonte
1
Herokuapp dice: Bad Request: Request Line is too large (7005 > 4094). È necessario ridurre le dimensioni della suite di test per adattarsi alla dimensione massima del collegamento.
— Mr. Xcoder,
@ Mr.Xcoder Grazie. L'ho riparato.
— Jakube,
1

Perl 5 , 90 byte

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

Provalo online!

L'input è un elenco di punti separato da una nuova riga, con il primo come punto base e l'ultimo con una nuova riga finale. Le parentesi ( []) attorno alle coordinate sono opzionali.

— Xcali
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.