Disons que vous avez un effet positif entier N . Construisez d'abord un polygone régulier , qui a N sommets, avec la distance entre les sommets voisins étant 1. Ensuite, connectez les lignes de chaque sommet à tous les autres sommets. Enfin, calculez la longueur de toutes les lignes résumées ensemble.

Exemple

Étant donné l'entrée N = 6 , construisez un hexagone avec des lignes reliant chaque sommet aux autres sommets.

Comme vous pouvez le voir, il y a un total de 6 lignes de bordure (longueur = 1), 3 lignes qui ont le double de la longueur de bordure (longueur = 2) et 6 autres lignes que nous, en utilisant le théorème de Pythagore, pouvons calculer la longueur pour , lequel est

Si nous additionnons les longueurs des lignes, nous obtenons (6 * 1) + (3 * 2) + (6 * 1,732) = 22,392 .

Information additionnelle

Comme les structures avec 2 sommets ou moins ne sont pas considérées comme des polygones, affichez 0 (ou NaN, puisque la distance entre un seul sommet n'a pas beaucoup de sens) pour N = 1, car un seul sommet ne peut pas être connecté à d'autres sommets, et 1 pour N = 2, car deux sommets sont reliés par une seule ligne.

Contribution

Un entier N, dans n'importe quel format raisonnable.

Production

La longueur de toutes les lignes résumées ensemble, précise à au moins 3 décimales, soit sous forme de retour de fonction, soit directement imprimée dans stdout.

Règles

• Les failles standard sont interdites.
• C'est le code-golf , donc le code le plus court en octets, dans n'importe quelle langue, gagne.

Bonne chance!

Cas de test

(Input) -> (Output)
1 -> 0 or NaN
2 -> 1
3 -> 3
5 -> 13.091
6 -> 22.392

Python 3 (avec sympy ) ,  61 60 58 54  48 octets

-6 (peut-être même -10 si nous n'avons pas besoin de gérer n=1) grâce à xnor (simplification trigonométrique supplémentaire et golf supplémentaire pour gérer le cas de bord de 1 et enregistrer les parenthèses en déplaçant une floatdistribution (désormais inutile) ).

^{J'espère battable sans bibliothèques tierces ? Oui!! mais permet de faire avancer les choses ...}

lambda n:1%n*n/2/(1-cos(pi/n))
from math import*

Essayez-le en ligne!

Cela utilise une formule pour la somme des longueurs si un polygone est inscrit à l'intérieur d'un cercle unité, n*cot(pi/2/n)/2et ajuste le résultat à un pour la longueur du côté étant un en divisant par le péché de cette longueur de cordon sin(pi/n).

La première formule s'acquiert en considérant les n-1longueurs de cordons de toutes les diagonales émanant d'un coin qui sont de longueurs sin(pi/n)(encore),, sin(2*pi/n)..., sin((n-1)pi/n). La somme de ceci est cot(pi/2/n)qu'il y a des ncoins donc nous multiplions par n, mais ensuite nous avons compté deux fois tous les cordons, donc nous divisons par deux.

Le résultat n*cot(pi/2/n)/2/sin(pi/n)a ensuite été simplifié par xnor to n/2/(1-cos(pi/n))(holding for n>1)

... cela (tant que la précision est acceptable) ne nécessite plus sympysur le intégrémath module intégré ( math.pi=3.141592653589793).

Python , 34 octets

lambda n:1%n*n/abs(1-1j**(2/n))**2

Essayez-le en ligne!

Utilise la formule n/2/(1-cos(pi/n))simplifiée de Jonathan Allan . Neil a économisé 10 octets en notant que Python peut calculer les racines de l'unité en tant que puissances fractionnaires de 1j.

Python sans importations n'a pas de fonctions trigonométriques intégrées,, piou e. Pour faire n=1donner 0plutôt que 0.25, on préfère1%n* .

Une version plus longue utilisant uniquement des pouvoirs de nombre naturel:

lambda n:1%n*n/abs(1-(1+1e-8j/n)**314159265)**2

Essayez-le en ligne!

MATL , 16 15 octets

t:=ZF&-|Rst2)/s

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Cela utilise un commit qui a introduit la fonction FFT (Fast Fourier Transform), et qui est antérieur au défi de 8 jours.

Explication

Le code utilise cette astuce (adaptée à MATL) pour générer les racines de l'unité. Ceux-ci donnent les positions des sommets sous forme de nombres complexes, sauf que la distance entre les sommets consécutifs n'est pas normalisée à 1. Pour résoudre ce problème, après avoir calculé toutes les distances par paires, le programme les divise par la distance entre les sommets consécutifs.

t       % Implicit input, n. Duplicate
:       % Range: [1 2 ... n-1 n]
=       % Isequal, element-wise. Gives [0 0 ... 0 1]
ZF      % FFT. Gives the n complex n-th roots of unity
&-|     % Matrix of pairwise absolute differences
R       % Upper triangular matrix. This avoids counting each line twice.
s       % Sum of each column. The second entry gives the distance between
        % consecutive vertices
t2)/    % Divide all entries by the second entry
s       % Sum. Implicit display

Sauterelle, 25 primitives (11 composants, 14 fils)

J'ai lu un meta post sur les programmes dans GH et LabVIEW, et je suis des instructions similaires pour mesurer un langage visuel.

Imprimez <null>pour N = 0, 1, 2, car Polygon Primitivevous ne pouvez pas générer un polygone avec 2 bords ou moins et vous obtiendrez une liste de lignes vide.

Composants de gauche à droite:

• Side count curseur: entrée
• Polygon Primitive: dessine un polygone sur toile
• Décomposer: décomposer une polyligne en segments et sommets
• Référence croisée: créer une référence croisée holistique entre tous les sommets
• Ligne: tracez une ligne entre toutes les paires
• Supprimer les lignes en double
• Longueur de courbe
• (supérieur) Sum
• (inférieur) Division: parce que Polygon Primitivedessine un polygone en fonction du rayon, nous devons mettre la forme à l'échelle
• Multipication
• Panneau: sortie

Mathematica, 26 octets

utilise la formule de @Jonathan Allan

N@Cot[Pi/2/#]/2Csc[Pi/#]#&   

Essayez-le en ligne!

-1 octet junghwan min

Haskell , 27 octets

f 1=0
f n=n/2/(1-cos(pi/n))

Essayez-le en ligne!

Je viens de plonger dans Haskell, donc cela s'avère être un bon golf pour débutant (c'est-à-dire copier la formule à partir d'autres réponses).

J'ai également essayé de mettre $quelque part, mais le compilateur continue de me crier dessus, c'est donc le meilleur que j'ai. : P

Gelée , 13 12 11 octets

Utilise la formule de Jonathan Allan (et merci à lui d'avoir économisé 2 octets)

ØP÷ÆẠCḤɓ’ȧ÷

Essayez-le en ligne!

J'ai toujours été assez fasciné par Jelly, mais je ne l'ai pas beaucoup utilisé, donc ce n'est peut-être pas la forme la plus simple.

Javascript (ES6), 36 octets

n=>1%n*n/2/(1-Math.cos(Math.PI/n))

Port de @ JonathanAllan's Python 3 answer

f=n=>1%n*n/2/(1-Math.cos(Math.PI/n))

<input id=i type=number oninput="o.innerText=f(i.value)" /><pre id=o>