Calcular a área de um polígono regular

19

Dado um número inteiro, nonde 3 <= n < 2^32, calcule a área de um regular n-gon com um apótema de 1; a fórmula para qual é n * tan(π / n). Para aqueles que não sabem o que é o apotema:

O apótema de um polígono regular é um segmento de linha do centro até o ponto médio de um de seus lados.

Produza a área do n-gon como um ponto flutuante com não menos que 8 casas decimais.

Casos de teste

3
5.1961524227

6
3.4641016151

10
3.2491969623

20
3.1676888065

99
3.1426476062

1697
3.1415962425

15000
3.1415926995

Nota: Os casos de teste acima incluem mais 2 dígitos do que o necessário para a saída.

code-golf  math  number  geometry 
— Zach Gates
fonte

Respostas:

9

Mathematica, 16 bytes

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

Experimente online!

é claro que o mathematica possui built-ins para esse 

Area@*RegularPolygon
— J42161217
fonte
Area@RegularPolygondeveria ser Area@*RegularPolygon; como está agora, não pode ser capturado em uma variável. Ou seja, f = Area@RegularPolygon; f[3]não funciona. Meta-discussão relevante
— JungHwan Min 5/09/17
@JungHwanMin ok, eu fixa-lo (embora eu não publicá-la como uma answer.I estava apenas mostrando os built-ins para se divertir).
— J42161217
6

Na verdade , 5 bytes

╦/Tß*

Experimente online!

Quão?

╦ / Tß * Programa completo.

╦ Pressione Pi.
 / Divida ^ pela entrada.
  T Tangente.
   ß * Multiplique pela entrada.
        Saída implicitamente.

Alternativa: ß╦/T*. o_O Na verdade, é melhor do que Jelly !!!

— Mr. Xcoder
fonte
Nomes embutidas 2 bytes ...
— Erik o Outgolfer
Sim, eu sei ... @EriktheOutgolfer 3 bytes embutidos em Pyth embora>. <
— Mr. Xcoder 4/17/17
3
+1 para " Na verdade, bate Jelly !!! " Esse trocadilho nunca fica velho. ;)
— Kevin Cruijssen
4

Código de máquina x87, 11 bytes

D9 EB
DA 31
D9 F2
DD D8
DA 09
C3

Os bytes de código acima definem uma função que calcula a área de um n-gon regular com um apótema de 1. Ele usa instruções x87 FPU (a unidade clássica de ponto flutuante nos processadores x86) para fazer esse cálculo.

Após uma convenção de chamada padrão baseada em registro x86 (neste caso __fastcall), o argumento da função é um ponteiro para o número inteiro passado no ECXregistro. O resultado da função é um valor de ponto flutuante, retornado na parte superior da pilha de ponto flutuante x87 (registrador ST0).

Experimente online!

Mnemônicos de montagem não destruídos:

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

Como você pode ver, isso é basicamente apenas um cálculo direto da fórmula fornecida,
     result = n * tan (π / n)
Apenas algumas coisas interessantes merecem destaque:

  • A xU FPU possui uma instrução dedicada para carregar o valor constante PI ( FLDPI). Isso raramente era usado, mesmo no passado (e obviamente muito menos agora), mas é menor em tamanho do que incorporar uma constante ao seu binário e carregá-lo.
  • A instrução x87 da FPU para calcular a tangente FPTANsubstitui o valor do registro de entrada (a parte superior da pilha da FPU) pelo resultado, mas também coloca uma constante 1,0 na parte superior da pilha da FPU. Isso é feito para compatibilidade retroativa com o 8087 (não tenho idéia do por que isso foi feito no 8087; provavelmente um bug). Isso significa que precisamos extrair esse valor desnecessário da pilha. A maneira mais rápida e curta de fazer isso é simples FSTP st0, como usamos aqui. Também poderíamos ter feito um multiplique e pop , pois multiplicar por 1.0 não mudará o resultado, mas isso também é de 2 bytes (portanto, não há ganho no tamanho do código), provavelmente será executado mais lentamente e poderá introduzir indeterminação desnecessária. o resultado.

Embora um programador ou compilador moderno usasse o conjunto de instruções SSE (e posterior), em vez do x87 antigo, isso exigiria mais código para implementar, pois não há uma instrução única para calcular uma tangente nesses novos ISAs.

— Cody Gray
fonte
2

Ohm v2 , 7 bytes

απ/ÆT³*

Experimente online!

Quão?

απ / ÆT³ * Programa completo

απ Pressione Pi.
  / Dividido pela entrada.
   A Tangent.
     ³ * Multiplicado pela entrada.
          Saída implícita.
— Mr. Xcoder
fonte
2

var'aq , 51 bytes

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

Explicação

'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
fonte
2

JavaScript (ES6), 24 bytes

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

Tente

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>
Expandir snippet

— Shaggy
fonte
1

Pitão , 9 bytes

*.tc.n0Q2

Suíte de teste.

Quão?

* .tc.n0Q2 Programa completo. Q significa entrada.

    .n0 Pi. 
   c Dividido por:
       Q A entrada.
 .t 2 Tangente.
* Q Multiplique pela entrada.
             Saída implicitamente.
— Mr. Xcoder
fonte
1

Gaia , 5 bytes

₵P÷ṫ×

Experimente online!

Quão?

₵ P ÷ ṫ × Programa completo.

Push P Pressione Pi.
  Ided Dividido pela entrada.
   ent Tangente.
    × Multiplique pela entrada.
— Mr. Xcoder
fonte
1

Perl, 14 + 16 = 30

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

14 bytes para o programa apropriado e 16 para as opções de linha de comando

0

IBM / Lotus Notes Formula Language, 13 bytes

a*@Tan(@Pi/a)

Entrada obtida por meio de um campo denominado a no mesmo formulário do campo que contém a fórmula. Nenhum TIO disponível, portanto, captura de tela de todos os casos de teste mostrados abaixo:

insira a descrição da imagem aqui

— ElPedro
fonte
0

C # (compilador Mono C #) , 24 bytes


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

Experimente online!

— Amit Gawande
fonte
3
Infelizmente, este não é um programa completo, nem uma função. Em vez disso, é um trecho, que não é permitido aqui. No entanto, acho que você pode adicionar n=>ao início para transformar isso em uma função de seta (leve isso com uma pitada de sal, não sei C #) que é válido.
— caird coinheringaahing 5/09/17
Você pode colocar o snippet em a System.Func<T, T>, o que levaria a floatcomo entrada e outro como saída. A declaração ficaria assim: System.Func<float, float> f = n=>n*Math.Tan(Math.PI/n);onde o número de bytes começaria n=>. No meu exemplo eu omitido dois de seus suportes para salvar 2 bytes;)
— Ian H.
0

RPNGolf 0.6 / 0.7 , 12 bytes

tbp-1mBsdmcc

Minha primeira postagem usando o RPNGolf, minha nova linguagem baseada em pilha!

Este é um programa completo que lê um número inteiro da entrada padrão e imprime a saída na saída padrão (sem uma nova linha à direita).

Explicação:

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
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.