Bentuk N-Dimensi Sederhana yang dapat dibuat untuk dimensi apa pun adalah Simplex , dan ini adalah sekumpulan titik N + 1 yang semuanya berjarak sama dari satu sama lain.

Untuk 2 dimensi, ini adalah segitiga sama sisi, untuk 3 dimensi, ini adalah tetrahedron biasa, pada 4 dimensi adalah 5-Sel dan seterusnya.

Tantangan

Diberikan dimensi Integer N sebagai input, output Array / Daftar / Tumpukan / Apa pun dari titik-titik N Dimensi yang mewakili Simpleks dimensi ini. Artinya, N + 1 vertex yang sama dan tidak nol jarak dari satu sama lain.

Implementasi referensi di Lua

Contohnya

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...]]

Catatan

• Input adalah angka dalam format standar apa pun , dan akan selalu menjadi bilangan bulat lebih besar dari 1 dan kurang dari 10
• Hardcoding diperbolehkan untuk input 1, tetapi tidak ada yang lebih tinggi.
• Kesalahan wajar diizinkan dalam output. Masalah dengan floating point aritmatika atau trigonometri dapat diabaikan.
• Setiap transformasi simpleks dimensional N diperbolehkan, asalkan tetap Reguler dan Non-nol.
• Celah Standar dilarang.
• Ini adalah kode-golf , byte paling sedikit menang.

Jelly , 11 byte

‘½‘÷ẋW
=þ;Ç

Cobalah online!

Karya-karya menghasilkan matriks identitas berukuran N dan concatenating dengan daftar yang dihasilkan oleh mengulangi N kali tunggal √ (N + 1) + 1 , dibagi dengan 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 Bytes

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

Tentunya dapat ditingkatkan, terutama pada penanganan n = 1```. (Bagaimana itu bahkan simpleks?) Baru sadar itu tidak perlu. Mungkin masih bisa diperbaiki ^^

Cobalah online!

[i*[0]+[1]+(n+~i)*[0]for i in range(n)]menciptakan matriks identitas. Semua titik memiliki jarak sqrt(2)satu sama lain. (terima kasih kepada Rod untuk meningkatkan)

Sekarang kita membutuhkan n+1titik ke-1 dengan jarak yang sama ke semua titik lainnya. Kita harus memilih (x, x, ... x).

Jarak dari (1, 0, ... )ke (x, x, ... x)adalah sqrt((x-1)²+x²+...+x²). Jika kita menginginkan nsimpleks dimensional, ini menjadi sqrt((x-1)²+(n-1)x²)seperti kita memiliki satu 1dan n-1 0s pada poin pertama. Sederhanakan sedikit:sqrt(x²-2x+1+(n-1)x²) = sqrt(nx²-2x+1)

Kami ingin jarak ini sqrt(2).

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

Memecahkan persamaan kuadratik ini (satu solusi, solusi lain juga berfungsi dengan baik):

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

Masukkan itu dalam daftar nwaktu, masukkan daftar itu dalam daftar dan bergabung dengan matriks identitas.

-4 Bytes berkat Alex Varga:

Kalikan setiap vektor dengan n. Ini mengubah penciptaan matriks identitas ke lambda n:[i*[0]+[n]+(n+~i)*[0](panjang yang sama) dan menghilangkan pembagian oleh npada titik tambahan, sehingga menjadi n*[1+(n+1)**.5], menyimpan dua tanda kurung dan /n.

Bahasa Wolfram (Mathematica) , 46 byte

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

Cobalah online!

APL (Dyalog) , 20 18 byte

1 byte terima kasih kepada @ngn

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

Cobalah online!

JavaScript (ES7), 70 byte

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

Port dari jawaban Python @ PattuX.

Bahasa Wolfram (Mathematica), 205 byte

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

Fungsi simpleks dalam Mathematica Mulai dari {0,0,...]},{1,0,0,...]}, Menempatkan titik pertama di titik asal, Titik kedua di xsumbu Titik ketiga di x,ypesawat, Titik keempat di x,y,zruang angkasa, dll. Perkembangan ini menggunakan kembali semua titik sebelumnya, menambahkan satu titik baru pada suatu waktu dalam dimensi baru

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

Verifikasi

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}

Oktaf , 31 byte

Disimpan 2 byte berkat Luis Mendo .

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

Cobalah online!

Ruby , 55 byte

alih-alih mengembalikan besaran yang sama untuk semua dimensi dan menggunakan rumus (1+(n+1)**0.5)/nI, skalakan dengan faktor nuntuk menyederhanakan rumus(1+(n+1)**0.5)

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

Cobalah online!

ungolfed dalam program tes

Fungsi lambda mengambil nsebagai argumen dan mengembalikan array array.

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

keluaran

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

Pari / GP , 37 byte

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

Cobalah online!

R , 38 byte

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

Cobalah online!