รับจำนวนเต็มnที่ไหน3 <= n < 2^32คำนวณพื้นที่ของปกติn-gon กับ apothem ของ 1; n * tan(π / n)สูตรสำหรับซึ่งเป็น สำหรับผู้ที่ไม่ทราบว่า apothem คืออะไร:

Apothem ของรูปหลายเหลี่ยมปกติคือส่วนของเส้นตรงจากจุดกึ่งกลางไปยังจุดกึ่งกลางของด้านใดด้านหนึ่ง

เอาต์พุตพื้นที่ของn-gon เป็นจุดลอยตัวที่มีทศนิยมไม่ต่ำกว่า 8 ตำแหน่ง

กรณีทดสอบ

3
5.1961524227

6
3.4641016151

10
3.2491969623

20
3.1676888065

99
3.1426476062

1697
3.1415962425

15000
3.1415926995

หมายเหตุ: กรณีทดสอบด้านบนมีตัวเลข 2 หลักมากกว่าที่คุณต้องการเพื่อส่งออก

Mathematica ขนาด 16 ไบต์

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

ลองออนไลน์!

แน่นอนว่า mathematica ได้สร้าง -ins สำหรับสิ่งนี้

Area@*RegularPolygon

Java (OpenJDK 9) , 24 ไบต์

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

ลองออนไลน์!

ที่จริงแล้ว 5 ไบต์

╦/Tß*

ลองออนไลน์!

อย่างไร?

╦ / Tß * โปรแกรมเต็มรูปแบบ

╦กด Pi
 / หาร ^ โดยอินพุต
  t แทนเจนต์
   ß * คูณด้วยอินพุต
        ผลผลิตโดยปริยาย

ทางเลือก: ß╦/T*. _{o_O จริง ๆ แล้วเต้นJelly !}

x87 รหัสเครื่อง 11 ไบต์

D9 EB
DA 31
D9 F2
DD D8
DA 09
C3

ไบต์ของโค้ดด้านบนจะกำหนดฟังก์ชั่นที่คำนวณพื้นที่ของ n-gon ปกติด้วย apothem ที่ 1 โดยใช้คำสั่ง x87 FPU (หน่วยจุดลอยตัวแบบคลาสสิกบนโปรเซสเซอร์ x86) เพื่อทำการคำนวณนี้

หลังจากการเรียกใช้การลงทะเบียนแบบ x86 มาตรฐาน (ในกรณีนี้__fastcall) อาร์กิวเมนต์ของฟังก์ชันคือตัวชี้ไปยังจำนวนเต็มที่ส่งผ่านในการECXลงทะเบียน ผลลัพธ์ของฟังก์ชันคือค่าเลขทศนิยมซึ่งส่งคืนที่ด้านบนของ x87 จุดลอยตัวสแต็ก (รีจิสเตอร์ST0)

ลองออนไลน์!

คำย่อของชุดประกอบ Ungolfed:

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

อย่างที่คุณเห็นนี่เป็นเพียงการคำนวณสูตรที่ตรงไปตรง
     มา result = n * tan (π / n)
มีเพียงสิ่งที่น่าสนใจสองสามข้อที่ชี้ให้เห็น:

• x87 FPU มีคำแนะนำเฉพาะสำหรับการโหลดค่าคงที่ PI ( FLDPI) สิ่งนี้ไม่ค่อยได้ใช้แม้แต่วัน (และตอนนี้ก็ชัดเจนน้อยกว่า) แต่ก็มีขนาดที่สั้นกว่าการฝังค่าคงที่ลงในไบนารีของคุณแล้วโหลดมัน
• คำสั่ง x87 FPU เพื่อคำนวณแทนเจนต์, FPTANแทนที่ค่าของอินพุตรีจิสเตอร์ (ด้านบนของ FPU สแต็ก) ด้วยผลลัพธ์ แต่ยังเพิ่มค่าคงที่ 1.0 ลงด้านบนของ FPU สแต็ก สิ่งนี้ทำเพื่อความเข้ากันได้ย้อนหลังกับ 8087 (ฉันไม่รู้ว่าทำไมสิ่งนี้ถึงเกิดขึ้นใน 8087 อาจเป็นข้อผิดพลาด) นั่นหมายความว่าเราจำเป็นต้องแสดงค่าที่ไม่จำเป็นนี้ออกจากสแต็ก วิธีที่เร็วและสั้นที่สุดในการทำเช่นนั้นเป็นเรื่องง่ายFSTP st0เหมือนที่เราใช้ที่นี่ เราสามารถทำทวีคูณและป๊อปได้เนื่องจากการคูณด้วย 1.0 จะไม่เปลี่ยนผลลัพธ์ แต่นี่ก็เป็น 2 ไบต์ (ดังนั้นจึงไม่ชนะขนาดรหัส) อาจทำงานช้ากว่าและอาจแนะนำการกำหนดที่ไม่จำเป็นเข้ามา ผลลัพธ์.

แม้ว่าโปรแกรมเมอร์หรือคอมไพเลอร์สมัยใหม่จะใช้ชุดคำสั่ง SSE (และรุ่นที่ใหม่กว่า) แทนที่จะเป็นชุดอายุ x87 แต่จะต้องใช้รหัสเพิ่มเติมในการติดตั้งเนื่องจากไม่มีคำสั่งเดียวในการคำนวณแทนเจนต์ใน ISAs ที่ใหม่กว่านี้

เยลลี่ 6 ไบต์

ØP÷ÆT×

ลองออนไลน์!

π builtin ของ Jelly มีทศนิยม 8 ตำแหน่ง

Brachylogขนาด 9 ไบต์

;π/₍*₄;?×

ลองออนไลน์!

ซากุระขนาด 4 ไบต์

*ij/π

นี่คือการขยายไปสู่*ij/π⓪⓪ซึ่งเป็น

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

R , 25 ไบต์

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

อินพุตจาก stdin, เอาต์พุตไปยัง stdout

ลองออนไลน์!

MATL , 7 ไบต์

YPy/Z,*

ลองออนไลน์!

Japtap , 7 ไบต์

*MtMP/U

ทดสอบมัน

คำอธิบาย

เพียงแค่ใช้ forumla ซึ่งMtเป็นสีแทนMPคือ pi และUเป็นอินพุต

โอห์ม v2 , 7 ไบต์

απ/ÆT³*

ลองออนไลน์!

อย่างไร?

απ / ÆT³ * โปรแกรมเต็มรูปแบบ

απ Push Pi
  / หารด้วยอินพุท
   TangT แทนเจนต์
     ³ * คูณด้วยอินพุต
          เอาต์พุตโดยปริยาย

var'aq , 51 ไบต์

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

คำอธิบาย

'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

Lisp ทั่วไป, 29 ไบต์

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

ลองออนไลน์!

JavaScript (ES6), 24 ไบต์

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

ลองมัน

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>

Python 2 , 45 ไบต์

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

ลองออนไลน์!

Pyth , 9 ไบต์

*.tc.n0Q2

ชุดทดสอบ

อย่างไร?

* .tc.n0Q2 โปรแกรมเต็มรูปแบบ Q หมายถึงอินพุต

    .n0 Pi 
   c หารด้วย:
       Q การป้อนข้อมูล
 .t 2 แทนเจนต์
* Q คูณด้วยอินพุต
             ผลผลิตโดยปริยาย

Gaiaขนาด 5 ไบต์

₵P÷ṫ×

ลองออนไลน์!

อย่างไร?

₵ P ÷ṫ×โปรแกรมเต็ม

Push P Push Pi
  ÷หารด้วยอินพุต
   ṫแทนเจนต์
    ×คูณด้วยอินพุต

Swift , 35 ไบต์

ด้วยคำเตือนของคอมไพเลอร์:

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

ลองที่นี่!

ไม่มีคำเตือนของคอมไพเลอร์40 ไบต์ :

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

Excel, 16 ไบต์

=A1*TAN(PI()/A1)

Perl, 14 + 16 = 30

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

14 ไบต์สำหรับโปรแกรมที่เหมาะสมและ 16 สำหรับสวิตช์บรรทัดคำสั่ง

Prolog (SWI) 25 ไบต์

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

ลองออนไลน์!

นี่เป็นครั้งแรกที่ฉันส่ง codegolf หวังว่าฉันจะสบายดี เขียนเป็นฟังก์ชั่น

ภาษาสูตร IBM / Lotus Notes ขนาด 13 ไบต์

a*@Tan(@Pi/a)

ข้อมูลที่ป้อนผ่านฟิลด์ชื่อ a บนแบบฟอร์มเดียวกับฟิลด์ที่มีสูตร ไม่มี TIO ให้ภาพหน้าจอของกรณีทดสอบทั้งหมดที่แสดงด้านล่าง:

PowerShellขนาด 38 ไบต์

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

ลองออนไลน์!

ทำสิ่งที่ตรงกับที่บอกไว้ในกระป๋องเพียงแค่ใช้เวลานานขึ้นเล็กน้อยเนื่องจากการ[math]::เรียก. NET

Ruby , 27 ไบต์

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

ลองออนไลน์!

Pari / GPขนาด 14 ไบต์

n->tan(Pi/n)*n

ลองออนไลน์!

C # (คอมไพเลอร์ Mono C #) , 24 ไบต์

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

ลองออนไลน์!

RPNGolf 0.6 / 0.7 , 12 ไบต์

tbp-1mBsdmcc

โพสต์แรกของฉันที่ใช้ RPNGolf ซึ่งเป็นภาษาสแต็กใหม่ของฉัน!

นี่เป็นโปรแกรมเต็มรูปแบบที่อ่านจำนวนเต็มจากอินพุตมาตรฐานและพิมพ์เอาต์พุตไปยังเอาต์พุตมาตรฐาน (โดยไม่ขึ้นบรรทัดใหม่)

คำอธิบาย:

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