La forme N-dimensionnelle la plus simple que l'on puisse créer pour n'importe quelle dimension est un Simplex , et c'est un ensemble de N + 1 points qui sont tous à égale distance les uns des autres.

Pour 2 dimensions, c'est un triangle équilatéral, pour 3 dimensions, c'est un tétraèdre régulier, à 4 dimensions est le 5-Cell et ainsi de suite.

Le défi

Étant donné une dimension entière N en entrée, sortez un tableau / liste / pile / n'importe lequel des N points dimensionnels qui représentent un simplexe de cette dimension. Autrement dit, N + 1 sommets qui sont à distance égale et non nulle l'un de l'autre.

Implémentation de référence dans Lua

Exemples

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

Remarques

• L'entrée est un nombre dans n'importe quel format standard et sera toujours un entier supérieur à 1 et inférieur à 10
• Le codage en dur est autorisé pour une entrée de 1, mais rien de plus élevé.
• Une erreur raisonnable est autorisée dans la sortie. Les problèmes d'arithmétique en virgule flottante ou de trig peuvent être ignorés.
• Toute transformation du simplexe à N dimensions est autorisée, tant qu'elle reste régulière et non nulle.
• Les échappatoires standard sont interdites.
• Il s'agit de code-golf , donc le moins d'octets gagne.

Gelée , 11 octets

‘½‘÷ẋW
=þ;Ç

Essayez-le en ligne!

Travaux de génération de la matrice d'identité de taille N et la concaténation avec la liste générée par la répétition N fois le singleton √ (N + 1) + 1 , divisé par 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 octets

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

Peut certainement être amélioré, en particulier lors de la manipulation de n = 1 ''. (Comment est-ce même un simplexe?) Je viens de réaliser que ce n'est pas nécessaire. Peut probablement encore être amélioré ^^

Essayez-le en ligne!

[i*[0]+[1]+(n+~i)*[0]for i in range(n)]crée une matrice d'identité. Tous les points sont éloignés les sqrt(2)uns des autres. (merci à Rod pour l'amélioration)

Maintenant, nous avons besoin d'un n+1point -th avec la même distance à tous les autres points. Nous devons choisir (x, x, ... x).

La distance de (1, 0, ... )à (x, x, ... x)est sqrt((x-1)²+x²+...+x²). Si nous voulons un nsimplexe dimensionnel, cela s'avère être sqrt((x-1)²+(n-1)x²), comme nous avons un 1et n-1 0s dans le premier point. Simplifiez un peu:sqrt(x²-2x+1+(n-1)x²) = sqrt(nx²-2x+1)

Nous voulons que cette distance soit sqrt(2).

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

Résoudre cette équation quadratique (une solution, l'autre fonctionne bien aussi):

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

Mettez cela dans une liste nfois, mettez cette liste dans une liste et joignez-vous à la matrice d'identité.

-4 octets grâce à Alex Varga:

Multipliez chaque vecteur par n. Cela modifie la création de la matrice d'identité en lambda n:[i*[0]+[n]+(n+~i)*[0](même longueur) et supprime la division par nau point supplémentaire, ce qui devient n*[1+(n+1)**.5], en enregistrant deux crochets et le /n.

Wolfram Language (Mathematica) , 46 octets

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

Essayez-le en ligne!

APL (Dyalog) , 20 18 octets

1 octet grâce à @ngn

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

Essayez-le en ligne!

JavaScript (ES7), 70 octets

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

Port de la réponse Python de @ PattuX.

Wolfram Language (Mathematica), 205 octets

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

Fonction simplexe dans Mathematica À partir de {0,0,...]},{1,0,0,...]}, Placement du premier point à l'origine, Deuxième point sur l' xaxe Troisième point dans le x,yplan, Quatrième point dans l' x,y,zespace, etc. Cette progression réutilise tous les points précédents, en ajoutant un nouveau point à la fois dans une nouvelle dimension

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

Vérification

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 octets

Enregistré 2 octets grâce à Luis Mendo .

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

Essayez-le en ligne!

Rubis , 55 octets

plutôt que de renvoyer des grandeurs similaires pour toutes les dimensions et d'utiliser la formule (1+(n+1)**0.5)/nI pour augmenter le facteur de nsimplifier la formule en(1+(n+1)**0.5)

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

Essayez-le en ligne!

non golfé dans le programme de test

Une fonction lambda prenant ncomme argument et renvoyant un tableau de tableaux.

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

production

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

Pari / GP , 37 octets

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

Essayez-le en ligne!

R , 38 octets

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

Essayez-le en ligne!