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

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

7

Java (OpenJDK 9) , 24 bytes

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

Pruébalo en línea!

Roman Gräf
fuente

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

3

Jalea , 6 bytes

ØP÷ÆT×

Pruébalo en línea!

El π incorporado de Jelly tiene> 8 decimales.

Erik el Outgolfer
fuente

Agradable. Estaba tratando de resolver esto (y Jelly en su totalidad), ahora mismo. :-)

Zach Gates

3

Brachylog , 9 bytes

;π/₍*₄;?×

Pruébalo en línea!

Erik el Outgolfer
fuente

3

Sakura , 4 bytes

*ĳ/π

Esto se expande a *ĳ/π⓪⓪, que es

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

TuxCrafting
fuente

1

No competir ya no es una cosa.

Shaggy

@ Shaggy, ¿qué quieres decir? ¿Desde cuando?

shooqie

Ver este Meta , Tux.

Shaggy

3

R , 25 bytes

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

Entrada de stdin, salida a stdout.

Pruébalo en línea!

Giuseppe
fuente

1

Trabaja sin cat(). 5 bytes menos.

Rui Barradas - Restablecer Monic

2

MATL , 7 bytes

YPy/Z,*

Pruébalo en línea!

Cinaski
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

Lisp común, 29 bytes

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

Pruébalo en línea!

Renzo
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

38 bytes

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

Gaia , 5 bytes

₵P÷ṫ×

Pruébalo en línea!

¿Cómo?

₵ P ÷ ṫ × Programa completo.

Push P Push Pi.
  ÷ Dividido por la entrada.
   ṫ Tangente.
    × Multiplica por la entrada.

Sr. Xcoder
fuente

1

Swift , 35 bytes

Con advertencias del compilador:

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

Pruébalo aquí!

Sin advertencias del compilador, 40 bytes :

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

Sr. Xcoder
fuente

1

Excel, 16 bytes

=A1*TAN(PI()/A1)

Wernisch
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

fuente

0

Prólogo (SWI) , 25 bytes

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

Pruébalo en línea!

Esta es mi primera presentación a codegolf, espero que esté bien. Escrito como una función.

qwertxzy
fuente

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:

ElPedro
fuente

0

PowerShell , 38 bytes

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

Pruébalo en línea!

Hace exactamente lo que dice en la lata, solo toma un poco más de tiempo debido a las largas [math]::llamadas .NET.

AdmBorkBork
fuente

0

Rubí , 27 bytes

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

Pruébalo en línea!

Bocadillo
fuente

0

Pari / GP , 14 bytes

n->tan(Pi/n)*n

Pruébalo en línea!

alephalpha
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

Calcular el área de un polígono regular

Casos de prueba

Respuestas:

Mathematica, 16 bytes

Java (OpenJDK 9) , 24 bytes

En realidad , 5 bytes

¿Cómo?

Código de máquina x87, 11 bytes

Jalea , 6 bytes

Brachylog , 9 bytes

Sakura , 4 bytes

R , 25 bytes

MATL , 7 bytes

Japt , 7 bytes

Explicación

Ohm v2 , 7 bytes

¿Cómo?

var'aq , 51 bytes

Explicación

Lisp común, 29 bytes

JavaScript (ES6), 24 bytes

Intentalo

Python 2 , 45 bytes

Pyth , 9 bytes

¿Cómo?

Gaia , 5 bytes

¿Cómo?

Swift , 35 bytes

Excel, 16 bytes

Perl, 14 + 16 = 30

Prólogo (SWI) , 25 bytes

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

PowerShell , 38 bytes

Rubí , 27 bytes

Pari / GP , 14 bytes

C # (compilador Mono C #) , 24 bytes

RPNGolf 0.6 / 0.7 , 12 bytes