Die einfachste N-dimensionale Form, die für jede Dimension erstellt werden kann, ist ein Simplex . Hierbei handelt es sich um eine Menge von N + 1 Punkten, die alle gleich weit voneinander entfernt sind.

Bei 2 Dimensionen ist dies ein gleichseitiges Dreieck, bei 3 Dimensionen ist dies ein regulärer Tetraeder, bei 4 Dimensionen ist das 5-Zellen- Dreieck und so weiter.

Die Herausforderung

Wenn Sie eine Ganzzahldimension N als Eingabe angeben, geben Sie ein Array / eine Liste / einen Stapel / beliebige N-dimensionale Punkte aus, die einen Simplex dieser Dimension darstellen. Das heißt, N + 1 Scheitelpunkte, die gleich und ungleich Null voneinander entfernt sind.

Referenzimplementierung in Lua

Beispiele

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

Anmerkungen

• Die Eingabe ist eine Zahl in einem beliebigen Standardformat und wird immer eine ganze Zahl größer als 1 und kleiner als 10 sein
• Hardcoding ist für die Eingabe von 1 zulässig, jedoch nicht höher.
• Angemessener Fehler ist in der Ausgabe zulässig. Probleme mit Gleitkomma-Arithmetik oder Trigger können ignoriert werden.
• Jede Transformation des N-dimensionalen Simplex ist zulässig, solange sie regelmäßig und nicht null bleibt.
• Standardlücken sind verboten.
• Das ist Code-Golf , also gewinnen die wenigsten Bytes.

Gelee , 11 Bytes

‘½‘÷ẋW
=þ;Ç

Probieren Sie es online!

Generiert die Identitätsmatrix der Größe N und verknüpft sie mit der Liste, die durch N- maliges Wiederholen des Singleton √ (N + 1) + 1 geteilt durch N generiert wurde .

‘½‘÷ẋ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]]

Kann sicherlich verbessert werden, insbesondere bei der Handhabung von n = 1```. (Wie ist das überhaupt ein Simplex?) Nur gemerkt, dass das nicht nötig ist. Kann wohl noch verbessert werden ^^

Probieren Sie es online!

[i*[0]+[1]+(n+~i)*[0]for i in range(n)]schafft Identitätsmatrix. Alle Punkte haben Distanzsqrt(2) voneinander. (Danke an Rod für die Verbesserung)

Jetzt brauchen wir einen n+1-ten Punkt mit dem gleichen Abstand zu allen anderen Punkten. Wir müssen uns entscheiden(x, x, ... x) .

Entfernung von (1, 0, ... )bis (x, x, ... x)ist sqrt((x-1)²+x²+...+x²). Wenn wir einen ndimensionalen Simplex wollen, stellt sich heraus, dass dies so ist sqrt((x-1)²+(n-1)x²), wie wir einen 1und habenn-1 0 s in den ersten Punkt. Vereinfachen Sie ein bisschen:sqrt(x²-2x+1+(n-1)x²) = sqrt(nx²-2x+1)

Wir wollen, dass diese Distanz ist sqrt(2).

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

Lösen Sie diese quadratische Gleichung (eine Lösung, die andere funktioniert auch):

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

Schreiben Sie das nmal in eine Liste , schreiben Sie diese Liste in eine Liste und verbinden Sie sich mit der Identitätsmatrix.

-4 Bytes dank Alex Varga:

Multiplizieren Sie jeden Vektor mit n. Dies ändert die Erstellung der Identitätsmatrix auf lambda n:[i*[0]+[n]+(n+~i)*[0](gleiche Länge) und beseitigt die Teilung durch nim zusätzlichen Punkt, so dass n*[1+(n+1)**.5]zwei Klammern und die /n.

Wolfram Language (Mathematica) , 46 Byte

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

Probieren Sie es online!

APL (Dyalog) , 20 bis 18 Bytes

1 Byte danke an @ngn

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

Probieren Sie es online!

JavaScript (ES7), 70 Byte

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

Port von @ PattuX's Python Antwort.

Wolfram Language (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}]

Simplex-Funktion in Mathematica Ausgehend von {0,0,...]},{1,0,0,...]}Platzieren des ersten Punkts am Ursprung, des zweiten Punkts auf der xAchse, des dritten Punkts in der x,yEbene, des vierten Punkts im x,y,zRaum usw. Bei dieser Abfolge werden alle vorherigen Punkte wiederverwendet und jeweils ein neuer Punkt in einer neuen Dimension hinzugefügt

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

Nachprüfung

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}

Oktave , 31 Bytes

2 Bytes dank Luis Mendo gespeichert .

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

Probieren Sie es online!

Ruby , 55 Bytes

anstatt für alle Dimensionen ähnliche Beträge zurückzugeben und die Formel (1+(n+1)**0.5)/nI num den Faktor 1 zu vergrößern, um die Formel zu vereinfachen(1+(n+1)**0.5)

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

Probieren Sie es online!

im Testprogramm ungolfed

Eine Lambda-Funktion, die nals Argument ein Array von Arrays zurückgibt.

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

Ausgabe

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

Pari / GP , 37 Bytes

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

Probieren Sie es online!

R , 38 Bytes

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

Probieren Sie es online!