Kişinin herhangi bir boyut için yaratabileceği en basit N-Boyut şekli bir Simplex'tir ve bu, birbirinden eşit mesafede olan bir N + 1 noktası kümesidir.

2 boyut için, bu bir eşkenar üçgen, 3 boyut için, bu normal bir tetrahedron, 4 boyutta 5-Hücre vb.

Meydan okuma

Giriş olarak bir Tamsayı boyutu N verildiğinde, bu boyutun bir Simpleksini temsil eden Boyutsal noktalardan oluşan bir Dizi / Liste / Yığın / Ne olursa olsun çıktı alın. Yani, birbirinden eşit ve sıfır olmayan mesafe olan N + 1 tepe noktaları.

Lua'da referans uygulaması

Örnekler

1 -> [[0], [1]]
2 -> [[0, 0], [1, 0], [0.5, 0.866...]]
4 -> [[0, 0, 0, 0], [1, 0, 0, 0], [0.5, 0.866..., 0, 0], [0.5, 0.288..., 0.816..., 0], [0.5, 0.288..., 0.204..., 0.790...]]

notlar

• Giriş, herhangi bir standart biçimde bir sayıdır ve her zaman 1'den büyük ve 10'dan küçük bir tam sayı olacaktır
• 1 girişinde sabit kodlamaya izin verilir, ancak daha yüksek bir değer yoktur.
• Çıktıda makul hataya izin verilir. Kayan noktalı aritmetik veya trig ile ilgili sorunlar göz ardı edilebilir.
• N boyutlu simpleksin herhangi bir dönüşümüne, Düzenli ve Sıfırdan farklı kaldığı sürece izin verilir.
• Standart Loopholes yasaktır.
• Bu kod golf , çok az bayt kazanır.

Jöle , 11 bayt

‘½‘÷ẋW
=þ;Ç

Çevrimiçi deneyin!

Üreterek İşleri kimlik matrisi büyüklüğü N ve tekrar oluşturulan listesi ile birleştirerek N kez Singleton √ (N + 1) + 1 , bölü N .

‘½‘÷ẋW – Helper link (monadic). I'll call the argument N.

‘      – Increment N (N + 1).
 ½     – Square root.
  ‘    – Increment (√(N + 1) + 1).
   ÷   – Divide by N.
    ẋ  – Repeat this singleton list N times.
     W – And wrap that into another list.

––––––––––––––––––––––––––––––––––––––––––

=þ;Ç   – Main link.

=þ     – Outer product of equality.
  ;Ç   – Concatenate with the result given by the helper link applied to the input.

Python 78 66 Bayt

lambda n:[i*[0]+[n]+(n+~i)*[0]for i in range(n)]+[n*[1+(n+1)**.5]]

Elbette, özellikle n = 1 '' kullanımında geliştirilebilir . (Bu nasıl bir simpleks?) Sadece bunun gerekli olmadığını fark ettim. Muhtemelen hala geliştirilebilir ^ ^

Çevrimiçi deneyin!

[i*[0]+[1]+(n+~i)*[0]for i in range(n)]kimlik matrisi oluşturur. Tüm noktalar sqrt(2)birbirinden uzaktır. (iyileştirme için Rod'a teşekkürler)

Şimdi n+1diğer tüm noktalara aynı mesafede bir- noktaya ihtiyacımız var . Seçmek zorundayız (x, x, ... x).

Uzaklık (1, 0, ... )için (x, x, ... x)olduğunu sqrt((x-1)²+x²+...+x²). nBoyutsal bir simpleks istiyorsak , ilk noktada sqrt((x-1)²+(n-1)x²)bir 1ve n-1 0s'ye sahip olduğumuz için bu ortaya çıkıyor . Biraz basitleştirin:sqrt(x²-2x+1+(n-1)x²) = sqrt(nx²-2x+1)

Bu mesafenin olmasını istiyoruz sqrt(2).

sqrt(2) = sqrt(nx²-2x+1)
2 = nx²-2x+1
0 = nx²-2x-1
0 = x²-2/n*x+1/n

Bu ikinci dereceden denklemi çözmek (bir çözüm, diğeri de iyi çalışır):

x = 1/n+sqrt(1/n²+1/n) = 1/n+sqrt((n+1)/n²) = 1/n+sqrt(n+1)/n = (1+sqrt(n+1))/n

Bunu bir liste nsüresine koyun, listeyi bir listeye koyun ve kimlik matrisine katılın.

Alex Varga sayesinde -4 bayt:

Her vektörü çarpın n. Bu, kimlik matrisinin oluşturulmasını lambda n:[i*[0]+[n]+(n+~i)*[0](aynı uzunlukta) değiştirir ve nek noktadan bölünmeden kurtulur , böylece n*[1+(n+1)**.5]iki parantez ve /n.

Wolfram Dili (Mathematica) , 46 bayt

IdentityMatrix@#~Join~{Table[1-(#+1)^.5,#]/#}&

Çevrimiçi deneyin!

APL (Dyalog) , 20 18 bayt

@Ngn sayesinde 1 bayt teşekkürler

∘.=⍨∘⍳⍪1÷¯1+4○*∘.5

Çevrimiçi deneyin!

JavaScript (ES7), 70 bayt

n=>[a=Array(n++).fill((1+n**.5)/--n),...a.map((_,i)=>a.map(_=>+!i--))]

Bağlantı noktası @ PattuX'in Python cevabı.

Wolfram Dili (Mathematica), 205 bayt

f1 = Sqrt[# (# + 1)/2]/# /(# + 1) & ;
f2 = Sqrt[# (# + 1)/2]/# & ;
simplex[k_] := {ConstantArray[0, k]}~Join~Table[
   Table[f1[n], {n, 1, n - 1}]~Join~{f2[n]}~Join~
    ConstantArray[0, k - n],
   {n, k}]

Mathematica'da tek yönlü işlev Başlangıç, Başlangıç {0,0,...]},{1,0,0,...]}noktasını başlangıç ​​noktasına yerleştirme, Eksende ikinci nokta Düzlemde xüçüncü nokta x,y, x,y,zUzayda dördüncü nokta , vb. Bu ilerleme, önceki tüm noktaları yeniden kullanır ve yeni boyutta her seferinde yeni bir nokta ekler.

simplex[6]={{0, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1/2, Sqrt[3]/2, 0, 0, 0, 
  0}, {1/2, 1/(2 Sqrt[3]), Sqrt[2/3], 0, 0, 0}, {1/2, 1/(2 Sqrt[3]), 
  1/(2 Sqrt[6]), Sqrt[5/2]/2, 0, 0}, {1/2, 1/(2 Sqrt[3]), 1/(
  2 Sqrt[6]), 1/(2 Sqrt[10]), Sqrt[3/5], 0}, {1/2, 1/(2 Sqrt[3]), 1/(
  2 Sqrt[6]), 1/(2 Sqrt[10]), 1/(2 Sqrt[15]), Sqrt[7/3]/2}}

Doğrulama

In[64]:= EuclideanDistance[simplex[10][[#[[1]]]],simplex[10][[#[[2]]]]] & /@ Permutations[Range[10],{2}]//Simplify
Out[64]= {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}

Oktav , 31 bayt

Luis Mendo sayesinde 2 bayt tasarruf etti .

@(n)[n*eye(n);~~(1:n)+(n+1)^.5]

Çevrimiçi deneyin!

Ruby , 55 bayt

tüm boyutlar için benzer büyüklükler döndürmek yerine ve formül (1+(n+1)**0.5)/nI'i kullanarak formülün nbasitleştirilmesi(1+(n+1)**0.5)

->n{(a=[n]+[0]*~-n).map{a=a.rotate}+[[1+(n+1)**0.5]*n]}

Çevrimiçi deneyin!

test programında çözülmemiş

Bağımsız ndeğişken olarak alan ve bir dizi dizi döndüren lambda işlevi .

f=->n{
  (a=[n]+[0]*~-n).map{        #setup an array `a` containing `n` and `n-1` zeros. perform `n` iterations (which happens to be the the size of the array.)
  a=a.rotate}+                #in each iteration rotate `a` and return an array of all possible rotations of array `a`     
  [[1+(n+1)**0.5]*n]          #concatenate an array of n copies of 1+(n+1)**0.5
}

p f[3]                        # call for n=3 and print output

çıktı

[[0, 0, 3], [0, 3, 0], [3, 0, 0], [3.0, 3.0, 3.0]]

Pari / GP , 37 bayt

n->concat((n+1)^.5-matid(n),1^[1..n])

Çevrimiçi deneyin!

R , 38 bayt

function(n)rbind(diag(n,n),1+(n+1)^.5)

Çevrimiçi deneyin!