15

Especificações

Você tem um espaço 3D cúbico x,y,zde Sunidades inteiras de tamanho , como 0 <= x,y,z <= S.
Você começa a partir de métodos de entrada padrão uma matriz de pontos Prepresentadas como x,y,zcoordenadas inteiro, em qualquer formato razoável como você gosta, por exemplo: [x1,y1,z1],[x2,y2,z2],[x3,y3,z3] ... [xn,yn,zn].
Todos os Pvalores estarão no espaço 3D cúbico acima mencionado, como 0 <= x,y,z <= S.
O número total possível de Pserá .1 <= P <= S³
Você também obtém como entrada as x,y,zcoordenadas inteiras do ponto base B e o tamanho do cubo 3D S.

Tarefa

Seu objetivo é produzir, em seu formato preferido, os pontos Pclassificados pela distância linear (euclidiana) do ponto base B .

Regras

Se você encontrar mais de um ponto Pequidistante, Bdeverá gerar todos os equidistantes Pna sua ordem preferida.
É possível que um ponto Pcoincida com B, para que a distância deles seja 0, você deve emitir esse ponto.
Este é um desafio de código-golfe , portanto o código mais curto vence.
As brechas padrão são proibidas.
As explicações de código são apreciadas.

Casos de teste

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

É realmente necessário tomar Scomo parâmetro?

— Cristian Lupascu

@GolfWolf, se você não precisar, não aceite.

— Mario

2

Eu recomendo fortemente especificar que tipo de métrica você deseja que usemos. Algumas pessoas usam a métrica euclidiana (ρ = √ [(x₁-x₂) ² + (y₁-y₂) ² + (z₁-z₂) ²]), outras usam a métrica Manhattan (ρ = | x₁-x₂ | + | y₁-y₂ | + | z₁-z₂ |). Na minha opinião, todos deveriam usar a mesma métrica.

— Ramillies 12/09

4

@ Ramillies: O desafio especifica a distância linear que, em minha opinião, é euclidiana . Eu não consideraria Manhattan linear, mas concordo que especificar especificamente qual métrica usar deve dificultar o entendimento do desafio.

— Emigna

1

Não diga linear, diga euclidiano.

— Lyndon White

11

05AB1E , 4 bytes

ΣαnO

Experimente online!

Explicação

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

— Emigna
fonte

Por que você precisa n?

— Erik the Outgolfer

@EriktheOutgolfer: Talvez este pequeno exemplo possa mostrar a diferença entre quadrado e não.

— Emigna

Então, todo mundo está fazendo errado ou todo mundo está fazendo certo?

— Erik the Outgolfer

@ EriktheOutgolfer: Eu não verifiquei todas as respostas, mas a maioria parece estar correta.

— Emigna

Muitas respostas não se enquadram, foi por isso que perguntei, pois elas estão usando exatamente o mesmo 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
fonte

Eu acho que você pode salvar um byte usando a definição de currying e moving de ginside sort.

1

@ThePirateBay: Neil não faz caril!

— Shaggy

6

Haskell , 54 52 bytes

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

Experimente online!

Não preciso do tamanho do espaço. sum.map(^2).zipWith(-)ocalcula a distância de um ponto a o: (xo-xp)^2+(yo-yp)^2+(zo-zp)^2. Os pontos são simplesmente classificados na distância até o.

EDIT : "se você não precisar, não aceite" salvou 2 bytes.

— jferard
fonte

5

Python 3 , 68 64 bytes

-4 bytes graças a @Ramillies

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

Experimente online!

— ovs
fonte

4

R , 56 40 bytes

-16 bytes graças ao flodel por sugerir um formato de entrada diferente

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

Experimente online!

Toma Pcomo um3xn matriz de pontos, ou seja, cada coluna é um ponto; a saída está no mesmo formato.

Use a função auxiliar gpara transformar a lista de pontos Pdos casos de teste no formato R apropriado.

— Giuseppe
fonte

1

Talvez substitua sapply()por colSums((t(P)-B)^2), onde a entrada Pseria uma matriz?

— flodel

@flodel se eu vou fazer isso, eu posso tomar Pcomo uma 3xnmatriz e apenas fazê-lo colSums((P-B)^2)!

— Giuseppe

3

Mathematica, 24 bytes

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

Recebe entrada no formato f[B][P] .

Temos que usar 4 bytes xpara fazer a função aninhada. A precedência de  ( \[Function]) e //funciona bem para que a expressão seja equivalente a isso:

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

Precisamos Nporque, por padrão, o Mathematica classifica por estrutura de expressão em vez de por valor:

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 bytes

-11 bytes graças a Emigna

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

A contagem de bytes também inclui

using System.Linq;

Experimente online!

Os pontos são tratados como coleções de ints. Explicação:

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 bytes

Esta não é mais curta que a resposta de Neil , mas pensei em publicá-la de qualquer maneira para demonstrar o uso de Math.hypot(), que foi introduzido no ES6.

Recebe entrada na sintaxe de curry (p)(a), onde p = [x, y, z] é o ponto base e a é a matriz de outros pontos.

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

Mostrar snippet de código

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
fonte

3

k , 14 bytes

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

Experimente 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

Além disso, isso funciona para n dimensões e não está limitado a 3.

— zgrep
fonte

3

Japonês , 10 9 bytes

-1 byte graças a @Shaggy

ñ_íaV m²x

Toma pontos como uma matriz de matrizes de três itens e o ponto base como uma matriz única, nessa ordem. Não aceita o argumento tamanho.

Experimente online! ou execute o enorme caso de teste com -Ra saída de umx,y,z por linha.

Explicação

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

Bom :) Eu tinha 11 bytes antes do trabalho atrapalhar!

— Shaggy

Parece que isso deve funcionar para 9 bytes, mas precisa de mais testes. EDIT: Ambas as versões falham nos 2º e 3º casos de teste.

— Shaggy

@ Shaggy eu nunca percebi que ípoderia levar seus argumentos ao contrário, isso é muito bom. Eu também acho que deveria funcionar; Vou executar alguns dos outros casos de teste e editar quando voltar ao computador.

— Justin Mariner

Nota: -ou ntambém funcionaria no lugar de a.

— Shaggy

2

MATL , 7 bytes

yZP&SY)

As entradas são: matriz de 3 colunas com pontos como linhas e vetor de 3 colunas com ponto base.

Experimente no MATL Online!

Explicação

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 bytes

Guardado 1 byte, graças a Leaky Nun .

ạ²SðÞ

Experimente online!

Explicação

ðÞ²SðÞ

    Þ - Classifique por função da tecla.
difference - Diferença absoluta com os elementos na segunda lista de entrada.
 ² - quadrado. Vectorizes.
  S - soma.
   ð - Inicia uma cadeia diádica separada.
      - Saída implicitamente.

— Mr. Xcoder
fonte

Salve um byte com ạS¥Þ(não percebeu sua resposta antes de postar a minha).

— Erik the Outgolfer

Hmm ... acho que você terá que voltar para 5 bytes, desde que descobri que você precisaạ²SµÞ

— usar o

@EriktheOutgolfer Acho que corrigi-lo agora. No entanto, não tenho certeza

— Sr. Xcoder 12/17

Você precisa fazer o quadrado antes de somar (vetorizar), não depois.

— Erik the Outgolfer

@EriktheOutgolfer deve estar ok agora

— Sr. Xcoder

2

Perl 6 , 35 bytes (33 caracteres)

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

Experimente online!

Explicação: Isso pega uma lista com as coordenadas do ponto base (chamado @b) e, em seguida, uma lista de listas com coordenadas dos outros pontos (chamados @p). Em um bloco, você pode usá-los rapidamente usando o ^símbolo. Cada um dos^ variáveis 'd corresponde a um argumento. (Eles são classificados em ordem alfabética, assim @^bcomo o 1º e @^po 2º argumento .) Após um uso desse símbolo, você pode usar a variável normalmente.

A declaração @^bexiste apenas para dizer que o bloco aceitará o argumento do ponto base, que é usado apenas dentro do bloco de classificação. (Caso contrário, ele se referiria ao argumento do bloco de classificação.) O método .sortpode levar um argumento. Se for um bloco com 1 argumento (como aqui), a matriz será classificada de acordo com os valores dessa função. O bloco em si apenas pega cada ponto por vez e o fecha com menos ( Z-) com as coordenadas do ponto base. Em seguida, juntamos todos os elementos da lista »²e os somamos usando [+].

Como um bônus adicional, isso funcionará também com coordenadas flutuantes e em qualquer dimensão (desde que você, obviamente, forneça o mesmo número de coordenadas para todos os pontos, ele fará a coisa certa).

Isso não é mais válido. Deixo aqui apenas por diversão.

Perl 6 , 24 bytes - apenas uma piada!

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

Experimente online!

Como o OP não indica qual métrica deve ser usada, esse envio escolhe usar a métrica discreta. Nesta métrica, a distância entre dois pontos é 0 se eles são idênticos e 1 se não forem. É fácil verificar se essa é realmente uma métrica (se ρ (A, B) estiver na distância de A a B, é necessário que 1) ρ (A, B) = 0 se s = A = B, 2) ρ (A, B ) = ρ (B, A), 3) ρ (A, B) + ρ (B, C) ≥ ρ (A, C) ("desigualdade de triângulo")).

Provavelmente poderia ser muito mais jogado, mas não falo sério.

— Ramillies
fonte

Não funciona para <5 5 5>,(<5 5 10>,<6 5 5>). As listas não classificam por sua soma, mas por comparação entre elementos. Você precisa de um sumlugar.

— Nwellnhof 12/09

@nwellnhof, muito obrigado. Não sei o que estava pensando ... Vai consertar em breve.

— Ramillies 12/09

2

Kotlin 1.1, 58 bytes

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

Embelezado

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

Teste

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

Experimente online!

— Roberto Graham
fonte

Resultados errados: base=[2,3,3], points=[4,3,3],[1,3,4]. Seu resultado é [4,3,3], [1,3,4], enquanto o resultado correto é [1,3,4],[4,3,3].

— Olivier Grégoire

@ OlivierGrégoire Ops, corrigido

— 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), assumindo um List<int[]>parâmetro as em vez de int[][].

— Olivier Grégoire

1

Ah, powfunciona +=sem elenco, não na maioria dos outros casos. Bom 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

Try it online: Demonstration

Explanation:

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 says: Bad Request: Request Line is too large (7005 > 4094). You should make your test suite smaller in order to fit the maximum link size.

— Mr. Xcoder

@Mr.Xcoder Thanks. I fixed it.

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

Try it online!

Input is newline separated list of points, with the first one being the base point and the last having a trailing newline. Brackets ([]) around the coordinates are optional.

— Xcali
fonte

Classifique os pontos por distância linear em um espaço 3D

05AB1E , 4 bytes

JavaScript (ES6), 71 bytes

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 71 bytes

k , 14 bytes

Japonês , 10 9 bytes

Explicação

MATL , 7 bytes

Explicação

Gelatina , 5 bytes

Explicação

Perl 6 , 35 bytes (33 caracteres)

Isso não é mais válido. Deixo aqui apenas por diversão.

Perl 6 , 24 bytes - apenas uma piada!

Kotlin 1.1, 58 bytes

Embelezado

Teste

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

Pyth, 6 bytes

Explanation:

Perl 5, 90 bytes