Étant donné un entier ,, noù 3 <= n < 2^32, calculer l'aire d'un n-gon régulier avec un apothème de 1; dont la formule est n * tan(π / n). Pour ceux qui ne savent pas ce qu'est l'apothème:

L'apothème d'un polygone régulier est un segment de ligne allant du centre au milieu de l'un de ses côtés.

Affiche la zone du n-gon sous forme de virgule flottante avec au moins 8 décimales.

Cas de test

3
5.1961524227

6
3.4641016151

10
3.2491969623

20
3.1676888065

99
3.1426476062

1697
3.1415962425

15000
3.1415926995

Remarque: Les cas de test ci-dessus incluent 2 chiffres de plus que ce que vous devez produire.

— Portes Zach
source

9

Mathematica, 16 octets

N[Tan[Pi/#]#,9]&

Essayez-le en ligne!

bien sûr mathématique a intégré pour cela

Area@*RegularPolygon

— J42161217
source

Area@RegularPolygondevrait être Area@*RegularPolygon; tel qu'il est maintenant, il ne peut pas être capturé dans une variable. Autrement dit, f = Area@RegularPolygon; f[3]ne fonctionne pas. Méta-discussion pertinente

— JungHwan Min

@JungHwanMin ok, je l'ai corrigé (bien que je ne l'aie pas publié comme réponse, je montrais juste les fonctions intégrées pour le plaisir)

— J42161217

7

Java (OpenJDK 9) , 24 octets

i->i*Math.tan(Math.PI/i)

Essayez-le en ligne!

— Roman Gräf
source

6

En fait , 5 octets

╦/Tß*

Essayez-le en ligne!

Comment?

╦ / Tß * Programme complet.

╦ Appuyez sur Pi.
 / Divisez ^ par l'entrée.
  T Tangent.
   ß * Multipliez par l'entrée.
        Sortie implicitement.

Alternative: ß╦/T*. _{o_O bat réellement Jelly !!!}

— M. Xcoder
source

Noms intégrés à 2 octets ...

— Erik the Outgolfer

oui, je sais ... @EriktheOutgolfer 3 octets intégrés en Pyth>> <

— M. Xcoder

3

+1 pour " En fait bat réellement Jelly !!! " Ce jeu de mots ne vieillit jamais. ;)

— Kevin Cruijssen

4

Code machine x87, 11 octets

D9 EB
DA 31
D9 F2
DD D8
DA 09
C3

Les octets de code ci-dessus définissent une fonction qui calcule l'aire d'un n-gon régulier avec un apothème de 1. Il utilise des instructions FPU x87 (l'unité à virgule flottante classique sur les processeurs x86) pour effectuer ce calcul.

Suivant une convention d'appel standard basée sur un registre x86 (dans ce cas, __fastcall), l'argument de la fonction est un pointeur vers l'entier, passé dans le ECXregistre. Le résultat de la fonction est une valeur à virgule flottante, renvoyée en haut de la pile à virgule flottante x87 (registre ST0).

Essayez-le en ligne!

Mnémoniques d'assemblage non golfés:

D9 EB  fldpi                  ; load constant PI at top of FPU stack
DA 31  fidiv DWORD PTR [ecx]  ; divide PI by integer input (loaded from pointer
                              ;   in ECX), leaving result at top of FPU stack
D9 F2  fptan                  ; compute tangent of value at top of FPU stack
DD D8  fstp  st0              ; pop junk value (FPTAN pushes 1.0 onto stack)
DA 09  fimul DWORD PTR [ecx]  ; multiply by integer input (again, loaded via ECX)
C3     ret                    ; return control to caller

Comme vous pouvez le voir, il s'agit essentiellement d'un calcul simple de la formule donnée,
résultat = n * tan (π / n)
Seules quelques choses intéressantes méritent d'être signalées:

Le FPU x87 a une instruction dédiée pour charger la valeur constante PI ( FLDPI). Cela était rarement utilisé, même dans la journée (et évidemment beaucoup moins maintenant), mais sa taille est plus courte que l'intégration d'une constante dans votre binaire et son chargement.
L'instruction x87 FPU pour calculer la tangente, FPTANremplace la valeur du registre d'entrée (le haut de la pile FPU) par le résultat, mais pousse également une constante 1.0 en haut de la pile FPU. Ceci est fait pour une compatibilité ascendante avec le 8087 (je n'ai aucune idée pourquoi cela a été fait sur le 8087; probablement un bug). Cela signifie que nous devons retirer cette valeur inutile de la pile. Le moyen le plus rapide et le plus court de le faire est simple FSTP st0, comme nous l’utilisons ici. Nous aurions également pu faire une multiplication-et-pop , car la multiplication par 1.0 ne changera pas le résultat, mais cela représente également 2 octets (donc pas de gain en taille de code), s'exécutera probablement plus lentement et peut introduire une indétermination inutile dans le résultat.

Bien qu'un programmeur ou un compilateur moderne utilise le jeu d'instructions SSE (et versions ultérieures), plutôt que le x87 vieillissant, cela nécessiterait plus de code à implémenter, car il n'y a pas d'instruction unique pour calculer une tangente dans ces ISA plus récents.

— Cody Grey
source

3

Gelée , 6 octets

ØP÷ÆT×

Essayez-le en ligne!

Le π intégré de Jelly a> 8 décimales.

— Erik le Outgolfer
source

Agréable. J'essayais de comprendre cela (et Jelly dans son intégralité), en ce moment. :-)

— Zach Gates

3

Brachylog , 9 octets

;π/₍*₄;?×

Essayez-le en ligne!

— Erik le Outgolfer
source

3

Sakura , 4 octets

*ĳ/π

Ceci est étendu à *ĳ/π⓪⓪, qui est

*              *
 ĳ     tan(   )
  /         /
   π       π
    ⓪        n
     ⓪          n

— TuxCrafting
source

1

La non-compétition n'est plus une chose.

— Shaggy

@Shaggy que voulez-vous dire? Depuis quand?

— shooqie

Voir ce Meta , Tux.

— Shaggy

3

R , 25 octets

cat((n=scan())*tan(pi/n))

Entrée depuis stdin, sortie vers stdout.

Essayez-le en ligne!

— Giuseppe
source

1

Fonctionne sans cat(). 5 octets de moins.

— Rui Barradas - Rétablir Monic le

2

MATL , 7 octets

YPy/Z,*

Essayez-le en ligne!

— Cinaski
source

2

Japt , 7 octets

*MtMP/U

Essaye-le

Explication

Implémente simplement le forumla, où Mtest tan, MPest pi et Uest l'entrée.

— Hirsute
source

2

Ohm v2 , 7 octets

απ/ÆT³*

Essayez-le en ligne!

Comment?

Programme complet απ / ÆT³ *

απ Appuyez sur Pi.
  / Divisé par l'entrée.
   ÆT Tangent.
     ³ * Multiplié par l'entrée.
          Sortie implicite.

— M. Xcoder
source

2

var'aq , 51 octets

'Ij latlh HeHmI' tam boqHa''egh qojmI' boq'egh cha'

Explication

'Ij        - read from STDIN
latlh      - duplicate top of stack
HeHmI'     - push PI onto stack
tam        - swap first 2 elements on stack
boqHa''egh - divide
qojmI'     - take tangent
boq'egh    - multiply
cha'       - print

— Zongor
source

2

Lisp commun, 29 octets

(lambda(n)(* n(tan(/ pi n))))

Essayez-le en ligne!

— Renzo
source

2

JavaScript (ES6), 24 octets

x=>x*Math.tan(Math.PI/x)

Essayez-le

o.innerText=(f=
x=>x*Math.tan(Math.PI/x)
)(+i.value);oninput=_=>o.innerText=f(+i.value)

<input id=i min=3 type=number value=3><pre id=o>

Développer l'extrait

— Hirsute
source

1

Python 2 , 45 octets

from math import*
n=input()
print n*tan(pi/n)

Essayez-le en ligne!

— Husnain Raza
source

2

38 octets

— M. Xcoder

Dans des défis comme celui-ci, je n'aime vraiment pas utiliser lambda pour économiser des octets en mettant simplement l'impression dans le pied de page ... Par conséquent: 44 octets

— Simon

4

@Simon pourquoi? Les fonctions sont une soumission valide - vous pouvez soit sortir une valeur, soit la renvoyer depuis une fonction. L'impression dans le pied de page n'est pas requise.

— Stephen

1

Pyth , 9 octets

*.tc.n0Q2

Suite de tests.

Comment?

* .tc.n0Q2 Programme complet. Q signifie entrée.

    .n0 Pi. 
   c Divisé par:
       Q L'entrée.
 .t 2 Tangente.
* Q Multipliez par l'entrée.
             Sortie implicitement.

— M. Xcoder
source

1

Gaia , 5 octets

₵P÷ṫ×

Essayez-le en ligne!

Comment?

₵ P ÷ ṫ × Programme complet.

₵ P Poussez Pi.
  ÷ Divisé par l'entrée.
   ṫ Tangente.
    × Multipliez par l'entrée.

— M. Xcoder
source

1

Swift , 35 octets

Avec les avertissements du compilateur:

import Foundation
{tan(M_PI/$0)*$0}

Essayez-le ici!

Sans avertissements du compilateur, 40 octets :

import Foundation
{tan(Double.pi/$0)*$0}

— M. Xcoder
source

1

Excel, 16 octets

=A1*TAN(PI()/A1)

— Wernisch
source

1

Perl, 14 + 16 = 30

perl -MMath::Trig -ple'$_*=tan(pi/$_)'

14 octets pour le programme proprement dit et 16 pour les commutateurs de ligne de commande

0

Prolog (SWI) , 25 octets

f(X,Y):-X is Y*tan(pi/Y).

Essayez-le en ligne!

Ceci est ma première soumission à codegolf, j'espère que je vais bien. Écrit en fonction.

— qwertxzy
source

0

Langage de formule IBM / Lotus Notes, 13 octets

a*@Tan(@Pi/a)

Entrée prise via un champ nommé a sur le même formulaire que le champ contenant la formule. Aucun TIO disponible, donc capture d'écran de tous les cas de test ci-dessous:

— ElPedro
source

0

PowerShell , 38 octets

param($n)$n*[math]::tan([math]::pi/$n)

Essayez-le en ligne!

Fait exactement ce qu'il dit sur l'étain, prend juste un peu plus de temps en raison des longs [math]::appels .NET.

— AdmBorkBork
source

0

Rubis , 27 octets

->n{n*Math.tan(Math::PI/n)}

Essayez-le en ligne!

— Casse-croûte
source

0

Pari / GP , 14 octets

n->tan(Pi/n)*n

Essayez-le en ligne!

— alephalpha
source

0

C # (compilateur mono C #) , 24 octets


=>n*Math.Tan(Math.PI/n)

Essayez-le en ligne!

— Amit Gawande
source

3

Malheureusement, ce n'est ni un programme complet, ni une fonction. Il s'agit plutôt d'un extrait de code, qui n'est pas autorisé ici. Cependant, je pense que vous pouvez ajouter n=>au début pour en faire une fonction de flèche (prenez cela avec une pincée de sel, je ne sais pas C #) qui est valide.

— caird coinheringaahing

Vous pouvez placer l'extrait de code dans un System.Func<T, T>, qui prendrait une floatentrée et une autre en sortie. La déclaration ressemblerait à ceci System.Func<float, float> f = n=>n*Math.Tan(Math.PI/n);:, où le décompte commencerait n=>. Dans mon exemple, j'ai omis deux de vos crochets pour économiser 2 octets;)

— Ian H.

0

RPNGolf 0,6 / 0,7 , 12 octets

tbp-1mBsdmcc

Mon premier post en utilisant RPNGolf, mon nouveau langage basé sur la pile!

Il s'agit d'un programme complet qui lit un entier à partir de l'entrée standard et imprime la sortie sur la sortie standard (sans retour à la ligne).

Explication:

tb              # push user input from STDIN as int
  p             # duplicate top of stack
   -1           # push -1
     mB         # pop i, push inverse cosine of i
       s        # swap top two items on the stack
        d       # pop b, pop a, push a/b
         mc     # pop i, push tangent of i
           c    # pop b, pop a, push a*b
# RPNGolf implicity prints the stack upon normal exit

— pizzapants184
source

Calculer l'aire d'un polygone régulier

Cas de test

Mathematica, 16 octets

Java (OpenJDK 9) , 24 octets

En fait , 5 octets

Comment?

Code machine x87, 11 octets

Gelée , 6 octets

Brachylog , 9 octets

Sakura , 4 octets

R , 25 octets

MATL , 7 octets

Japt , 7 octets

Explication

Ohm v2 , 7 octets

Comment?

var'aq , 51 octets

Explication

Lisp commun, 29 octets

JavaScript (ES6), 24 octets

Essayez-le

Python 2 , 45 octets

Pyth , 9 octets

Comment?

Gaia , 5 octets

Comment?

Swift , 35 octets

Excel, 16 octets

Perl, 14 + 16 = 30

Prolog (SWI) , 25 octets

Langage de formule IBM / Lotus Notes, 13 octets

PowerShell , 38 octets

Rubis , 27 octets

Pari / GP , 14 octets

C # (compilateur mono C #) , 24 octets

RPNGolf 0,6 / 0,7 , 12 octets