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

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

7

Java (OpenJDK 9) , 24 bytes

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

Experimente online!

Roman Gräf
fonte

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

3

Gelatina , 6 bytes

ØP÷ÆT×

Experimente online!

O π interno da geléia tem> 8 casas decimais.

Erik, o Outgolfer
fonte

Agradável. Eu estava tentando descobrir isso (e Jelly na íntegra), agora. :-)

Zach Gates

3

Braquilog , 9 bytes

;π/₍*₄;?×

Experimente online!

Erik, o Outgolfer
fonte

3

Sakura , 4 bytes

*ĳ/π

Isso é expandido para *ĳ/π⓪⓪, que é

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

TuxCrafting
fonte

11

Não competir não é mais nada.

Shaggy

@ Shaggy, o que você quer dizer? Desde quando?

shooqie

Veja este Meta , Tux.

Shaggy

3

R , 25 bytes

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

Entrada de stdin, saída para stdout.

Experimente online!

Giuseppe
fonte

11

Funciona sem cat(). 5 bytes a menos.

Rui Barradas - Reinstate Monic

2

MATL , 7 bytes

YPy/Z,*

Experimente online!

Cinaski
fonte

2

Japonês , 7 bytes

*MtMP/U

Teste-o

Explicação

Apenas implementa o forumla, onde Mté tan, MPé pi e Ué a entrada.

Shaggy
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

Lisp comum, 29 bytes

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

Experimente online!

Renzo
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

Python 2 , 45 bytes

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

Experimente online!

Husnain Raza
fonte

2

38 bytes

Mr. Xcoder 4/17

Em desafios como esse, eu realmente não gosto de usar o lambda para salvar bytes, basta colocar a impressão no rodapé ... Portanto: 44 bytes

Simon

4

@ Simon por quê? As funções são um envio válido - você pode gerar um valor ou retorná-lo de uma função. A impressão no rodapé não é necessária.

Stephen

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

Rápido , 35 bytes

Com avisos do compilador:

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

Experimente aqui!

Sem avisos do compilador, 40 bytes :

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

Mr. Xcoder
fonte

1

Excel, 16 bytes

=A1*TAN(PI()/A1)

Wernisch
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

fonte

0

Prolog (SWI) , 25 bytes

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

Experimente online!

Esta é a minha primeira submissão ao codegolf, espero que eu esteja bem. Escrito como uma função.

qwertxzy
fonte

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:

ElPedro
fonte

0

PowerShell , 38 bytes

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

Experimente online!

Faz exatamente o que diz na lata, só demora um pouco mais devido às longas [math]::chamadas do .NET.

AdmBorkBork
fonte

0

Ruby , 27 bytes

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

Experimente online!

Lanche
fonte

0

Pari / GP , 14 bytes

n->tan(Pi/n)*n

Experimente online!

alefalpha
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

Calcular a área de um polígono regular

Casos de teste

Respostas:

Mathematica, 16 bytes

Java (OpenJDK 9) , 24 bytes

Na verdade , 5 bytes

Quão?

Código de máquina x87, 11 bytes

Gelatina , 6 bytes

Braquilog , 9 bytes

Sakura , 4 bytes

R , 25 bytes

MATL , 7 bytes

Japonês , 7 bytes

Explicação

Ohm v2 , 7 bytes

Quão?

var'aq , 51 bytes

Explicação

Lisp comum, 29 bytes

JavaScript (ES6), 24 bytes

Tente

Python 2 , 45 bytes

Pitão , 9 bytes

Quão?

Gaia , 5 bytes

Quão?

Rápido , 35 bytes

Excel, 16 bytes

Perl, 14 + 16 = 30

Prolog (SWI) , 25 bytes

IBM / Lotus Notes Formula Language, 13 bytes

PowerShell , 38 bytes

Ruby , 27 bytes

Pari / GP , 14 bytes

C # (compilador Mono C #) , 24 bytes

RPNGolf 0.6 / 0.7 , 12 bytes