Calcular el área de un polígono regular

19

Dado un número entero, ndonde 3 <= n < 2^32, calcule el área de un ngón regular con una apotema de 1; la fórmula para la cual es n * tan(π / n). Para aquellos que no saben cuál es la apotema:

La apotema de un polígono regular es un segmento de línea desde el centro hasta el punto medio de uno de sus lados.

nGenere el área de -gon como punto flotante con no menos de 8 decimales.

Casos de prueba

3
5.1961524227

6
3.4641016151

10
3.2491969623

20
3.1676888065

99
3.1426476062

1697
3.1415962425

15000
3.1415926995

Nota: Los casos de prueba anteriores incluyen 2 dígitos más de los que se requieren para generar.

code-golf  math  number  geometry 
— Puertas de Zach
fuente

Respuestas:

9

Mathematica, 16 bytes

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

Pruébalo en línea!

por supuesto, Mathica tiene incorporados para esto 

Area@*RegularPolygon
— J42161217
fuente
Area@RegularPolygondebería ser Area@*RegularPolygon; tal como está ahora, no se puede capturar en una variable. Es decir, f = Area@RegularPolygon; f[3]no funciona. Meta discusión relevante
— JungHwan Min
@JungHwanMin ok, lo arreglé. (Aunque no lo publiqué como respuesta, solo estaba mostrando los elementos integrados por diversión)
— J42161217
6

En realidad , 5 bytes

╦/Tß*

Pruébalo en línea!

¿Cómo?

╦ / Tß * Programa completo.

╦ Empuje Pi.
 / Divide ^ por la entrada.
  T tangente.
   ß * Multiplica por la entrada.
        Salida implícita.

Alternativa: ß╦/T*. o_O En realidad realmente vence a Jelly !!!

— Sr. Xcoder
fuente
Nombres incorporados de 2 bytes ...
— Erik the Outgolfer
sí, lo sé ... @EriktheOutgolfer 3 bytes incorporados en Pyth aunque>. <
— Sr. Xcoder
3
+1 para "¡ En realidad realmente vence a Jelly! " Ese juego de palabras nunca pasa de moda. ;)
— Kevin Cruijssen
4

Código de máquina x87, 11 bytes

D9 EB
DA 31
D9 F2
DD D8
DA 09
C3

Los bytes de código anteriores definen una función que calcula el área de un n-gon regular con una apotema de 1. Utiliza instrucciones de FPU x87 (la unidad clásica de punto flotante en los procesadores x86) para hacer este cálculo.

Siguiendo una convención estándar de llamadas basadas en registros x86 (en este caso __fastcall), el argumento de la función es un puntero al número entero, pasado en el ECXregistro. El resultado de la función es un valor de coma flotante, devuelto en la parte superior de la pila de coma flotante x87 (registro ST0).

Pruébalo en línea!

Mnemónicos de ensamblaje sin golf:

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 puede ver, esto es básicamente un cálculo directo de la fórmula dada,
     resultado = n * tan (π / n)
Solo un par de cosas interesantes se destacan:

  • La FPU x87 tiene una instrucción dedicada para cargar el valor constante PI ( FLDPI). Esto rara vez se usaba, incluso en el pasado (y obviamente mucho menos ahora), pero es más corto en tamaño que incrustar una constante en su binario y cargar eso.
  • La instrucción x87 FPU para calcular la tangente, FPTANreemplaza el valor del registro de entrada (la parte superior de la pila FPU) con el resultado, pero también empuja un constante 1.0 en la parte superior de la pila FPU. Esto se hace para la compatibilidad con el 8087 (no tengo idea de por qué esto se hizo en el 8087; probablemente sea un error). Eso significa que necesitamos extraer este valor innecesario de la pila. La forma más rápida y rápida de hacerlo es simple FSTP st0, como la que usamos aquí. También podríamos haber hecho una multiplicación y pop , ya que multiplicar por 1.0 no cambiará el resultado, pero esto también es de 2 bytes (por lo que no hay ganancia en el tamaño del código), probablemente se ejecutará más lentamente y puede introducir indeterminaciones innecesarias en el resultado.

Aunque un programador o compilador moderno usaría el conjunto de instrucciones SSE (y posterior), en lugar del antiguo x87, esto requeriría más código para implementar, ya que no hay una sola instrucción para calcular una tangente en estas ISA más nuevas.

— Cody Gray
fuente
2

Japt , 7 bytes

*MtMP/U

Pruébalo

Explicación

Simplemente implementa el forumla, donde Mtes tan, MPes pi y Ues la entrada.

— Lanudo
fuente
2

Ohm v2 , 7 bytes

απ/ÆT³*

Pruébalo en línea!

¿Cómo?

Programa completo απ / ÆT³ *

απ Empuje Pi.
  / Dividido por la entrada.
   ÆT Tangente.
     ³ * Multiplicado por la entrada.
          Salida implícita.
— Sr. Xcoder
fuente
2

var'aq , 51 bytes

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

Explicación

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

JavaScript (ES6), 24 bytes

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

Intentalo

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 fragmento

— Lanudo
fuente
1

Python 2 , 45 bytes

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

Pruébalo en línea!

— Husnain Raza
fuente
2
— Sr. Xcoder
En desafíos como este, realmente no me gusta usar lambda para guardar bytes simplemente poniendo la impresión en el pie de página ... Por lo tanto: 44 bytes
— Simon
44
@Simon ¿por qué? Las funciones son un envío válido: puede generar un valor o devolverlo desde una función. No se requiere la impresión en el pie de página.
— Stephen
1

Pyth , 9 bytes

*.tc.n0Q2

Banco de pruebas.

¿Cómo?

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

    .n0 Pi. 
   c Dividido por:
       Q La entrada.
 .t 2 Tangente.
* Q Multiplica por la entrada.
             Salida implícita.
— Sr. Xcoder
fuente
1

Perl, 14 + 16 = 30

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

14 bytes para el programa propiamente dicho y 16 para los interruptores de línea de comando

0

Lenguaje de fórmulas IBM / Lotus Notes, 13 bytes

a*@Tan(@Pi/a)

Entrada tomada a través de un campo llamado a en el mismo formulario que el campo que contiene la fórmula. No hay TIO disponible, así que la captura de pantalla de todos los casos de prueba se muestra a continuación:

ingrese la descripción de la imagen aquí

— ElPedro
fuente
0

C # (compilador Mono C #) , 24 bytes


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

Pruébalo en línea!

— Amit Gawande
fuente
3
Desafortunadamente, este no es un programa completo, ni una función. En cambio, es un fragmento, que no está permitido aquí. Sin embargo, creo que puede agregar n=>al inicio para convertir esto en una función de flecha (tome esto con una pizca de sal, no sé C #) que es válido.
— caird coinheringaahing
Puedes colocar el fragmento en un System.Func<T, T> , que tomaría un floatcomo entrada y otro como salida. La declaración se vería así:, System.Func<float, float> f = n=>n*Math.Tan(Math.PI/n);donde comenzaría el bytecount n=>. En mi ejemplo, omití dos de sus corchetes para guardar 2 bytes;)
— Ian H.
0

RPNGolf 0.6 / 0.7 , 12 bytes

tbp-1mBsdmcc

¡Mi primera publicación usando RPNGolf, mi nuevo lenguaje basado en pila!

Este es un programa completo que lee un número entero desde la entrada estándar e imprime la salida a la salida estándar (sin una nueva línea final).

Explicación:

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
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.