Hình dạng N-Dimensional đơn giản nhất mà người ta có thể tạo cho bất kỳ kích thước nào là Simplex và đây là một tập hợp các điểm N + 1, tất cả đều cách xa nhau.

Đối với 2 chiều, đây là một tam giác đều, đối với 3 chiều, đây là một tứ diện đều, ở 4 chiều là 5 ô , v.v.

Các thách thức

Cho một số nguyên N là đầu vào, xuất ra một mảng / Danh sách / Ngăn xếp / Bất kể điểm N nào đại diện cho một Simplex của thứ nguyên này. Đó là, các đỉnh N + 1 có khoảng cách bằng nhau và khác không so với nhau.

Tham khảo thực hiện tại Lua

Ví dụ

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

Ghi chú

• Đầu vào là một số ở bất kỳ định dạng chuẩn nào và sẽ luôn là số nguyên lớn hơn 1 và nhỏ hơn 10
• Hardcoding được phép cho đầu vào là 1, nhưng không có gì cao hơn.
• Lỗi hợp lý được cho phép trong đầu ra. Các vấn đề với số học hoặc trig dấu phẩy động có thể bị bỏ qua.
• Bất kỳ sự biến đổi nào của đơn giản N chiều đều được cho phép, miễn là nó vẫn là Chính quy và khác không.
• Lỗ hổng tiêu chuẩn bị cấm.
• Đây là mã golf , vì vậy ít byte nhất sẽ thắng.

Thạch , 11 byte

‘½‘÷ẋW
=þ;Ç

Hãy thử trực tuyến!

Công trình bằng cách tạo ra các ma trận sắc kích thước N và concatenating nó với danh sách được tạo ra bằng cách lặp lại N lần singleton √ (N + 1) + 1 , chia cho 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 byte

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

Chắc chắn có thể được cải thiện, đặc biệt là khi xử lý n = 1```. (Làm thế nào mà ngay cả một đơn giản?) Chỉ cần nhận ra rằng không cần thiết. Có lẽ vẫn có thể được cải thiện ^^

Hãy thử trực tuyến!

[i*[0]+[1]+(n+~i)*[0]for i in range(n)]tạo ma trận danh tính. Tất cả các điểm có khoảng cách sqrt(2)với nhau. (cảm ơn Rod đã cải thiện)

Bây giờ chúng ta cần một n+1điểm thứ với cùng khoảng cách với tất cả các điểm khác. Chúng ta phải lựa chọn (x, x, ... x).

Khoảng cách từ (1, 0, ... )đến (x, x, ... x)là sqrt((x-1)²+x²+...+x²). Nếu chúng ta muốn một nchiều đơn giản thì điều này hóa ra là sqrt((x-1)²+(n-1)x²), vì chúng ta có một 1và n-1 0s ở điểm đầu tiên. Đơn giản hóa một chút:sqrt(x²-2x+1+(n-1)x²) = sqrt(nx²-2x+1)

Chúng tôi muốn khoảng cách này được sqrt(2).

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

Giải phương trình bậc hai này (một giải pháp, một giải pháp khác cũng hoạt động tốt):

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

Đặt nó trong một danh sách nlần, đặt danh sách đó vào một danh sách và tham gia với ma trận danh tính.

-4 byte nhờ Alex Varga:

Nhân mỗi vectơ với n. Điều này thay đổi việc tạo ma trận danh tính thành lambda n:[i*[0]+[n]+(n+~i)*[0](cùng độ dài) và thoát khỏi phép chia bằng nđiểm bổ sung, do đó, nó trở thành n*[1+(n+1)**.5], lưu hai dấu ngoặc và dấu /n.

Ngôn ngữ Wolfram (Mathicala) , 46 byte

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

Hãy thử trực tuyến!

APL (Dyalog) , 20 18 byte

1 byte nhờ @ngn

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

Hãy thử trực tuyến!

JavaScript (ES7), 70 byte

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

Cổng câu trả lời Python của @ PattuX.

Ngôn ngữ Wolfram (Mathicala), 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}]

Hàm Simplex trong Mathicala Bắt đầu từ {0,0,...]},{1,0,0,...]}, Đặt điểm đầu tiên tại điểm gốc, Điểm thứ hai trên xtrục Điểm thứ ba trong x,ymặt phẳng, Điểm thứ tư trong x,y,zkhông gian, v.v. Tiến trình này sử dụng lại tất cả các điểm trước đó, thêm một điểm mới tại một chiều mới

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

xác minh

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}

Octave , 31 byte

Đã lưu 2 byte nhờ Luis Mendo .

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

Hãy thử trực tuyến!

Ruby , 55 byte

thay vì trả lại cường độ tương tự cho tất cả các kích thước và sử dụng công thức (1+(n+1)**0.5)/ntôi mở rộng theo hệ số nđể đơn giản hóa công thức thành(1+(n+1)**0.5)

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

Hãy thử trực tuyến!

vô dụng trong chương trình thử nghiệm

Hàm lambda dùng nlàm đối số và trả về một mảng các mảng.

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

đầu ra

[[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])

Hãy thử trực tuyến!

R , 38 byte

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

Hãy thử trực tuyến!