รูปร่าง N-Dimension ที่ง่ายที่สุดที่สามารถสร้างสำหรับมิติใด ๆ คือSimplexและนี่คือชุดของ N + 1 จุดที่อยู่ห่างกันเท่ากัน

สำหรับ 2 มิตินี่คือสามเหลี่ยมด้านเท่าสำหรับ 3 มิตินี่คือจัตุรมุขปกติโดยที่ 4 มิติคือ5-Cellเป็นต้น

ความท้าทาย

กำหนดขนาด Integer N เป็นอินพุทเอาท์พุทอาร์เรย์ / ลิสต์ / สแต็ค / อะไรก็ตามที่มีมิติมิติที่แสดงถึง Simplex ของมิตินี้ นั่นคือจุดยอด N + 1 ที่มีระยะทางเท่ากันและไม่เป็นศูนย์จากแต่ละคน

การดำเนินการอ้างอิงใน Lua

ตัวอย่าง

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

หมายเหตุ

• อินพุตเป็นตัวเลขในรูปแบบมาตรฐานและจะเป็นจำนวนเต็มมากกว่า 1 และน้อยกว่า 10
• อนุญาตให้ใช้ Hardcoding สำหรับอินพุต 1 แต่ไม่มีอะไรสูงกว่า
• ข้อผิดพลาดที่เหมาะสมได้รับอนุญาตในการส่งออก ปัญหาเกี่ยวกับเลขคณิตจุดลอยตัวหรือตรีโกณมิติอาจถูกละเว้น
• อนุญาตให้มีการแปลงของมิติ N ได้อย่างง่ายดายตราบเท่าที่ยังคงเป็นปกติและไม่เป็นศูนย์
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือโค้ดกอล์ฟซึ่งมีจำนวนน้อยที่สุดที่จะชนะ

เยลลี่ 11 ไบต์

‘½‘÷ẋW
=þ;Ç

ลองออนไลน์!

ทำงานโดยการสร้างเมทริกซ์เอกลักษณ์ขนาดNและเชื่อมโยงกับรายการที่สร้างขึ้นโดยการทำซ้ำNครั้งเดี่ยว√ (N + 1) + 1หารด้วย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 ไบต์

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

สามารถปรับปรุงได้อย่างแน่นอนโดยเฉพาะอย่างยิ่งในการจัดการ n = 1``` (มันเป็นเรื่องง่ายแค่ไหน)แค่ตระหนักว่าไม่จำเป็น ยังสามารถปรับปรุงให้ดีขึ้นได้ ^^

ลองออนไลน์!

[i*[0]+[1]+(n+~i)*[0]for i in range(n)]สร้างเมทริกซ์เอกลักษณ์ คะแนนทั้งหมดมีระยะทางsqrt(2)จากกัน (ขอบคุณ Rod สำหรับการปรับปรุง)

ตอนนี้เราต้องการn+1จุดที่ -th โดยมีระยะทางเท่ากับจุดอื่นทั้งหมด (x, x, ... x)เราต้องเลือก

ระยะห่างจาก(1, 0, ... )ที่จะมี(x, x, ... x) sqrt((x-1)²+x²+...+x²)หากเราต้องการnมิติของซิมเพล็กซ์นี่จะเป็นsqrt((x-1)²+(n-1)x²)เพราะเรามีหนึ่ง1และn-1 0s ในจุดแรก ลดความซับซ้อนของบิต:sqrt(x²-2x+1+(n-1)x²) = sqrt(nx²-2x+1)

sqrt(2)เราต้องการระยะนี้จะเป็น

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

การแก้สมการกำลังสองนี้ (วิธีแก้ปัญหาหนึ่งอีกวิธีหนึ่งทำงานได้ดีเช่นกัน):

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

ใส่ในรายการnครั้งใส่รายการในรายการและเข้าร่วมกับเมทริกซ์เอกลักษณ์

-4 ไบต์ขอบคุณ Alex Varga:

nคูณเวกเตอร์แต่ละโดย การเปลี่ยนแปลงนี้สร้างเมทริกซ์เอกลักษณ์ที่จะlambda n:[i*[0]+[n]+(n+~i)*[0](ความยาวเดียวกัน) และได้รับการกำจัดของการแบ่งโดยnในจุดเพิ่มเติมเพื่อให้มันกลายเป็นประหยัดสองวงเล็บและn*[1+(n+1)**.5]/n

ภาษา Wolfram (Mathematica)ขนาด 46 ไบต์

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

ลองออนไลน์!

APL (Dyalog) , 20 18 ไบต์

1 ไบต์ต้องขอบคุณ @ngn

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

ลองออนไลน์!

JavaScript (ES7), 70 ไบต์

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

คำตอบ Python ของพอร์ตของ @ PattuX

ภาษา Wolfram (Mathematica), 205 ไบต์

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

ฟังก์ชั่น Simplex ใน Mathematica เริ่มต้นจาก{0,0,...]},{1,0,0,...]}การวางจุดแรกที่จุดกำเนิดจุดที่สองบนxแกนจุดที่สามในx,yระนาบจุดที่สี่ในx,y,zพื้นที่ ฯลฯ ความก้าวหน้านี้นำจุดก่อนหน้านี้ทั้งหมดมาใช้เพิ่มจุดใหม่ทีละจุดในมิติใหม่

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

การตรวจสอบ

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}

อ็อกเทฟ 31 ไบต์

ที่บันทึกไว้ 2 ไบต์ขอบคุณที่หลุยส์ Mendo

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

ลองออนไลน์!

Ruby , 55 ไบต์

แทนที่จะกลับมามีขนาดใกล้เคียงกันสำหรับทุกมิติและใช้สูตรที่(1+(n+1)**0.5)/nฉันเพิ่มขนาดโดยปัจจัยที่nจะทำให้สูตรง่ายขึ้น(1+(n+1)**0.5)

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

ลองออนไลน์!

ungolfed ในโปรแกรมทดสอบ

ฟังก์ชั่นแลมบ์ดารับnเป็นอาร์กิวเมนต์และส่งกลับอาร์เรย์ของอาร์เรย์

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

เอาท์พุต

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

Pari / GP , 37 ไบต์

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

ลองออนไลน์!

R , 38 ไบต์

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

ลองออนไลน์!