3B alanda noktaları doğrusal mesafeye göre sıralayın

15

gözlük

  1. Kübik bir 3D alanınız var x,y,zBoyutu Stamsayı birimleri gibi0 <= x,y,z <= S .
  2. Varsayılan giriş yöntemlerinden bir dizi nokta elde edersinizP olarak temsil x,y,zistediğiniz gibi örneğin herhangi makul bir biçimde, tam sayı koordinatlar: [x1,y1,z1],[x2,y2,z2],[x3,y3,z3] ... [xn,yn,zn].
  3. Hepsi P değerler yukarıda belirtilen kübik 3B alanda olacaktır 0 <= x,y,z <= S.
  4. Olası toplam sayısı P olacaktır .1 <= P <= S3
  5. Ayrıca baz noktasınınx,y,z tamsayı koordinatlarını girdi olarak alırsınız B ve 3D küp boyutunuS .

Görev

Amacınız, tercih ettiğiniz biçimde, taban noktadanP doğrusal (Öklid) mesafeye göre sıralanmış puanlar vermektir . B

kurallar

  1. Eğer Peşit uzaklıkta olan birden fazla nokta bulursanız , eşit uzaklıkta bulunanların Btümünü Ptercih ettiğiniz sırada çıkarmalısınız .
  2. Bir noktanın Pçakışması mümkündür B, böylece uzaklıkları 0o noktayı çıkarmanız gerekir.
  3. Bu bir kod golf mücadelesi, bu yüzden en kısa kod kazanır.
  4. Standart boşluklar yasaktır.
  5. Kod açıklamaları takdir edilmektedir.

Test senaryoları

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
kaynak
1
SParametre olarak almak gerçekten gerekli mi?
— Cristian Lupascu
@GolfWolf İhtiyacınız yoksa almayın.
— Mario
2
Hangi tür metriği kullanmamızı istediğinizi belirtmenizi önemle tavsiye ederim. Bazı insanlar Öklid metriğini kullanır (ρ = √ [(x₁-x₂) ² + (y₁-y₂) ² + (z₁-z₂) ²]), diğerleri Manhattan metriğini kullanır (ρ = | x₁-x₂ | + | y₁-y₂ | + | z₁-z₂ |). Bence herkes aynı metriği kullanıyor olmalı.
— Ramillies
4
@Ramillies: Zorluk kafamda Öklid olan doğrusal mesafeyi belirtir . Ben demezdim Manhattan doğrusal, ama özellikle belirterek yanlış anlamak meydan zor yapmalıdır kullanımına metrik hangi konusunda hemfikirdir.
— Emigna
1
Doğrusal demeyin, Öklid deyin.
— Lyndon White

Yanıtlar:

11

05AB1E , 4 bayt

ΣαnO

Çevrimiçi deneyin!

açıklama

Σ        # sort by
   O     # sum of
  n      # square of
 α       # absolute difference between current value and second input
— Emigna
kaynak
Neden ihtiyacın var n?
— Outgolfer Erik
@EriktheOutgolfer: Belki de bu küçük örnek , kareleme ve değil arasındaki farkı gösterebilir.
— Emigna
Peki, herkes yanlış mı yapıyor yoksa herkes doğru mu yapıyor?
— Outgolfer Erik
@EriktheOutgolfer: Tüm cevapları kontrol etmedim, ancak çoğu doğru gibi görünüyor.
— Emigna
Birçok cevap kare değil, bu yüzden sordum, çünkü aynı algoritmayı kullanıyorlar.
— Outgolfer Erik
6

JavaScript (ES6), 71 bayt

(b,a,g=a=>a.reduce((d,c,i)=>d+(c-=b[i])*c,0))=>a.sort((b,a)=>g(b)-g(a))
— Neil
kaynak
gİçeride curried ve hareketli tanımı kullanarak bir bayt kaydedebileceğinizi düşünüyorum sort.
1
@ThePirateBay: Neil körelmiyor!
— Shaggy
6

Haskell , 54 52 bayt

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

Çevrimiçi deneyin!

Alanın büyüklüğüne ihtiyacım yok. sum.map(^2).zipWith(-)oBir noktadan mesafeyi hesaplar o: (xo-xp)^2+(yo-yp)^2+(zo-zp)^2. Noktalar mesafeye göre sıralanır o.

EDIT : "ihtiyacınız yoksa, almayın" kaydedilmiş 2 bayt.

— jferard
kaynak
4

R , 56 40 bayt

Farklı giriş formatı önerdiği için flodel sayesinde -16 bayt

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

Çevrimiçi deneyin!

Alır Pa kadar3xn nokta matrisi, yani, her bir sütunun bir nokta; çıktı aynı biçimde.

Test durumlarından gnokta listesini Puygun R biçimine dönüştürmek için yardımcı işlevini kullanın .

— Giuseppe
kaynak
1
Belki yerini sapply()ile colSums((t(P)-B)^2)giriş nerede, Pbir matris olurdu?
— flodel
@flodel eğer bunu yapacaksam, Pbir 3xnmatris olarak da alıp colSums((P-B)^2)onun yerine yapabilirim!
— Giuseppe
3

Mathematica, 24 bayt

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

Biçimi girdi alır f[B][P].

xYuvalanmış işlevi yapmak için 4 bayt kullanmamız gerekir . Öncelik  ( \[Function]) ve //ifadesi bu eşdeğer olduğunu güzelce böylece dışarı çalışır:

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

İhtiyacımız var, Nçünkü Mathematica değere göre ifade yapısına göre sıralıyor:

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

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

C # (.NET Çekirdek) , 68 57 53 + 23 18 bayt

Emigna sayesinde -11 bayt

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

Bayt sayısı ayrıca şunları içerir:

using System.Linq;

Çevrimiçi deneyin!

Puanlar ints toplama olarak kabul edilir. Açıklama:

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

JavaScript (ES6), 72 71 bayt

Bu, Neil'in cevabından daha kısa değil , ama yine deMath.hypot() ES6'da tanıtılan düşündüm.

Curry sözdiziminde girdi alır; (p)(a)burada p = [x, y, z] temel nokta ve a diğer noktaların dizisidir.

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

Kod snippet'ini göster

— Arnauld
kaynak
3

k , 14 bayt

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

Çevrimiçi deneyin!

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

Ayrıca, bu n boyutlarında işe yarar ve 3 ile sınırlı değildir.

— zgrep
kaynak
3

Japt , 10 9 bayt

@Shaggy sayesinde -1 bayt

ñ_íaV m²x

Noktaları üç öğeli diziler dizisi olarak alır ve taban noktası bu sırayla tek bir dizi alır. Boyut argümanını almaz.

Çevrimiçi deneyin! veya çalıştırmak büyük bir test durumu ile -Rçıkış birine x,y,zsatıra.

açıklama

ñ_            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
kaynak
Güzel :) İş yolunda var önce ben 11 bayt aşağı oldu !
— Shaggy
Gibi görünüyor bu 9 bayt için çalışmak gerekir, ancak biraz daha test ihtiyacı var. EDIT: Her iki sürüm 2. ve 3. test durumlarında başarısız.
— Shaggy
@ Hiç fark etmedim í, argümanları tersine çevirebilirdi, bu oldukça hoş. Ben de işe yarayacağını düşünüyorum; Diğer test senaryolarından bazılarını çalıştırıp bir bilgisayara döndüğümde düzenleyeceğim.
— Justin Mariner
Not: -veya nyerine de çalışır a.
— Shaggy
2

MATL , 7 bayt

yZP&SY)

Girişler şunlardır: satırlar halinde noktalara sahip 3 sütunlu matris ve taban noktasıyla 3 sütunlu vektör.

MATL Online'da deneyin !

açıklama

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

Jöle , 5 bayt

1 bayt kaydedildi, Leaky Nun kurtardı .

ạ²SðÞ

Çevrimiçi deneyin!

açıklama

ạ²SðÞ

    Þ - Tuş işlevine göre sıralayın.
ạ - İkinci giriş listesindeki öğelerle mutlak fark.
 ² - Kare. Vektörleştirir.
  S - Toplam.
   ð - Ayrı bir ikili zincir başlatır.
      - Örtük olarak çıktı.
— Bay Xcoder
kaynak
İle bir bayt kaydedin ạS¥Þ(benimkini göndermeden önce cevabınızı fark etmediniz).
— Outgolfer Erik
Hmm ... Sanırım 5 bayta geri dönmen gerekecek çünkü kareye ihtiyacın olduğunu buldum :ạ²SµÞ
— Erik the Outgolfer
@EriktheOutgolfer Sanırım şimdi düzelttim. Yine de emin değilim
— Bay Xcoder
Toplamadan önce (kare), sonra değil kare gerekir.
— Outgolfer Erik
@EriktheOutgolfer Tamam olmalı
— Bay
2

Perl 6 , 35 bayt (33 karakter)

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

Çevrimiçi deneyin!

Açıklama: Bu, temel noktanın (çağrılan @b) koordinatlarını, ardından diğer noktaların (çağrılan @p) koordinatlarını içeren bir liste alır . Bir blokta, ^sembolü kullanarak bunları anında kullanabilirsiniz . ^'D değişkenlerinin her biri bir argümana karşılık gelir. (Alfabetik olarak sıralanırlar, @^bbirinci argüman ve @^p2.

Bu ifade @^bsadece bloğun sadece sıralama bloğu içinde kullanılan temel nokta argümanını alacağını söylemek için vardır. (Aksi takdirde sıralama bloğunun argümanına atıfta bulunur.) Yöntem .sortbir argüman alabilir. 1 argüman alan bir bloksa (burada olduğu gibi), dizi o işlevin değerlerine göre sıralanır. Bloğun kendisi her noktayı sırayla alır Z-ve taban noktası koordinatları ile eksi ( ) ile sıkıştırır . Sonra listedeki tüm öğeleri »²karelerle ve bunları kullanarak toplarız [+].

Ek bir bonus olarak, bu şamandıra koordinatları ile de çalışacaktır ve herhangi bir boyutta (açıkçası, tüm noktalar için aynı sayıda koordinat sağladığınız sürece, doğru olanı yapar).

Bu artık geçerli değil. Sadece eğlence için burada bırakıyorum.

Perl 6 , 24 bayt - sadece bir şaka!

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

Çevrimiçi deneyin!

OP hangi metriğin kullanılacağını belirtmediği için, bu gönderim ayrık metriği kullanmayı seçer. Bu metrikte, iki nokta arasındaki mesafe özdeş ise 0, değilse 1'dir. Bunun gerçekten bir metrik olduğunu kontrol etmek kolaydır (eğer ρ (A, B) A'dan B'ye uzaksa, 1) ρ (A, B) = 0 iff A = B, 2) ρ (A, B ) = ρ (B, A), 3) ρ (A, B) + ρ (B, C) ≥ ρ (A, C) ("üçgen eşitsizliği")).

Muhtemelen çok daha fazla golf olabilir, ama ciddi demek istemiyorum.

— Ramillies
kaynak
Çalışmıyor <5 5 5>,(<5 5 10>,<6 5 5>). Listeler toplamlarına göre değil, öğe bazında karşılaştırmaya göre sıralanır. Bir sumyere ihtiyacın var .
— nwellnhof
@nwellnhof, çok teşekkürler. Ne düşündüğümü bilmiyorum ... Kısaca düzelecek.
— Ramillies
2

Kotlin 1.1, 58 bayt

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

Beautified

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

Ölçek

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

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

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

Çevrimiçi deneyin!

— Roberto Graham
kaynak
Yanlış sonuçlar: base=[2,3,3], points=[4,3,3],[1,3,4]. Sonuç, [4,3,3], [1,3,4]doğru sonuç olur [1,3,4],[4,3,3].
— Olivier Grégoire
@ OlivierGrégoire Hata! Sabit
— 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 bayt), List<int[]>yerine a parametresi varsayılarak int[][].
— Olivier Grégoire
1
Oh, çoğu durumda değil, döküm olmadan powçalışır +=. Bilmek güzel!
— Olivier Grégoire
103 bayt: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 bayt

o.a,vz

Çevrimiçi deneyin: Gösteri

Açıklama:

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
kaynak
1
Herokuapp diyor: Bad Request: Request Line is too large (7005 > 4094). Maksimum bağlantı boyutuna sığdırmak için test takımınızı küçültmelisiniz.
— Bay Xcoder
@ Mr.Xcoder Teşekkürler. Düzelttim.
— Jakube
1

Perl 5,90 bayt

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

Çevrimiçi deneyin!

Girdi, ilk satırın taban noktası ve son satırın sonunda bir satırsonu olan yeni satırla ayrılmış nokta listesidir. []Koordinatların etrafındaki köşeli parantezler ( ) isteğe bağlıdır.

— Xcali
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.