एक नियमित बहुभुज के क्षेत्र की गणना करें

Question

पूर्णांक को देखते हुए n, जहां 3 <= n < 2^32, n1 के एपोटेम के साथ एक नियमित- आंगन के क्षेत्र की गणना करता है ; जिसके लिए सूत्र है n * tan(π / n)। उन लोगों के लिए जो यह नहीं जानते कि एपोटेम क्या है:

एक नियमित बहुभुज का एपोटेम केंद्र से उसके एक किनारे के मध्य बिंदु तक एक रेखा खंड है।

n8-दशमलव स्थानों से कम वाले फ्लोटिंग पॉइंट के रूप में -ऑगन के क्षेत्र का आउटपुट ।

परीक्षण के मामलों

3
5.1961524227

6
3.4641016151

10
3.2491969623

20
3.1676888065

99
3.1426476062

1697
3.1415962425

15000
3.1415926995

नोट: ऊपर दिए गए परीक्षण मामलों में आउटपुट के लिए आवश्यक 2 से अधिक अंक शामिल हैं।

Answer 1

गणितज्ञ, 16 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इसके लिए गणितज्ञों ने बिल्ट-इन किया है

Area@*RegularPolygon

Comments

Area@RegularPolygonहोना चाहिए Area@*RegularPolygon; जैसा कि अभी है, इसे एक चर में कैद नहीं किया जा सकता है। यानी f = Area@RegularPolygon; f[3]काम नहीं करता। प्रासंगिक मेटा चर्चा

— जंगहवान मिन सिप

@JungHwanMin ठीक है, मैंने इसे ठीक कर लिया है। (हालांकि मैंने इसे एक उत्तर के रूप में पोस्ट नहीं किया था। मैं सिर्फ मनोरंजन के लिए बनाया गया था)

— J42161217

Answer 2

जावा (ओपनजेडके 9) , 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 3

दरअसल , 5 बाइट्स

╦/Tß*

इसे ऑनलाइन आज़माएं!

---

कैसे?

╦ / Tß * पूर्ण कार्यक्रम।

╦ पुश पाई।
 इनपुट द्वारा / विभाजित करें।
  टी स्पर्शरेखा।
   ß * इनपुट से गुणा करें।
        आउटपुट निहित है।

वैकल्पिक: ß╦/T*। _{o_O वास्तव में जेली की धड़कन है !!!}

Comments

2-बाइट

— बिलिन के

हाँ, मुझे पता है ... @ ErictheOutgolfer 3 बाइट बिल्ट-इन पाइथ हालांकि>। <

— श्री एक्सकोडर

+1 के लिए " असल में वास्तव में जेली !!! " ;)

— केविन क्रूज़सेन 13

Answer 4

x87 मशीन कोड, 11 बाइट्स

D9 EB
DA 31
D9 F2
DD D8
DA 09
C3

कोड के ऊपर बाइट्स एक फ़ंक्शन को परिभाषित करता है जो 1. के एपोटेम के साथ एक नियमित एन-गॉन के क्षेत्र की गणना करता है। यह गणना करने के लिए x87 FPU निर्देशों (x86 प्रोसेसर पर क्लासिक फ्लोटिंग-पॉइंट यूनिट) का उपयोग करता है।

मानक x86 रजिस्टर-आधारित कॉलिंग कन्वेंशन (इस मामले में __fastcall) के बाद, फ़ंक्शन का तर्क पूर्णांक के लिए एक संकेतक है, जो ECXरजिस्टर में पास किया गया है । फ़ंक्शन का परिणाम एक फ्लोटिंग-पॉइंट वैल्यू है, जो x87 फ्लोटिंग-पॉइंट स्टैक (रजिस्टर ST0) के शीर्ष पर लौटा है ।

इसे ऑनलाइन आज़माएं!

असेंबली असेंबली mnemonics:

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

जैसा कि आप देख सकते हैं, यह मूल रूप से दिए गए सूत्र का केवल एक सीधा संगणना है,
     परिणाम = n * tan (
Only / n) केवल कुछ दिलचस्प बातें बताते हैं:

• X87 FPU में स्थिर मान PI ( FLDPI) लोड करने के लिए एक समर्पित निर्देश है । यह शायद ही कभी इस्तेमाल किया गया था, यहां तक ​​कि दिन में वापस (और जाहिर तौर पर अब तक बहुत कम है), लेकिन यह आपके बाइनरी में एक स्थिरांक को एम्बेड करने और उसे लोड करने की तुलना में आकार में छोटा है।
• X87 FPU निर्देश स्पर्शरेखा की गणना करने के लिए FPTAN, परिणाम के साथ इनपुट रजिस्टर (FPU स्टैक के शीर्ष) के मूल्य को बदलता है, लेकिन FPU स्टैक के शीर्ष पर एक निरंतर 1.0 को भी धक्का देता है। यह 8087 के साथ पीछे की संगतता के लिए किया गया है (मुझे नहीं पता कि यह 8087 पर क्यों किया गया था; शायद एक बग)। इसका मतलब है कि हमें स्टैक से इस अनावश्यक मान को पॉप करने की आवश्यकता है। ऐसा करने का सबसे तेज़ और सबसे छोटा तरीका एक सरल है FSTP st0, जैसे हम यहाँ उपयोग करते हैं। हम एक बहु-और-पॉप भी कर सकते थे , क्योंकि 1.0 से गुणा करने से परिणाम नहीं बदलेगा, लेकिन यह 2 बाइट्स भी है (इसलिए कोड आकार में कोई जीत नहीं), शायद अधिक धीरे-धीरे निष्पादित करेगा, और अनावश्यक अनिश्चितता का परिचय दे सकता है परिणाम।

हालांकि एक आधुनिक प्रोग्रामर या कंपाइलर SSE (और बाद में) निर्देश सेट का उपयोग करेगा, उम्र बढ़ने के x87 के बजाय, इसे लागू करने के लिए अधिक कोड की आवश्यकता होगी, क्योंकि इन नए ISAs में एक स्पर्शरेखा की गणना करने के लिए कोई एकल निर्देश नहीं है।

Answer 5

जेली , 6 बाइट्स

ØP÷ÆT×

इसे ऑनलाइन आज़माएं!

जेली के elly बिलिन में> 8 दशमलव स्थान हैं।

Comments

अच्छा लगा। मैं अभी इसका पता लगाने की कोशिश कर रहा था (और इसकी संपूर्णता में जेली), अभी। :-)

— ज़च गेट्स

Answer 6

ब्रेकीलॉग , 9 बाइट्स

;π/₍*₄;?×

इसे ऑनलाइन आज़माएं!

Answer 7

सकुरा , 4 बाइट्स

*ij/π

इसका विस्तार किया जाता है *ij/π⓪⓪, जो कि है

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

Comments

गैर-प्रतिस्पर्धा कोई भी चीज़ नहीं है।

— शैगी

@ शगुन का क्या मतलब है? कब से?

— शौकी

यह मेटा , टक्स देखें ।

— झबरा

Answer 8

आर , 25 बाइट्स

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

स्टड से इनपुट, आउटपुट से स्टडआउट।

इसे ऑनलाइन आज़माएं!

Comments

बिना काम करता है cat()। 5 बाइट्स कम।

— रुई बरदास -

Answer 9

MATL , 7 बाइट्स

YPy/Z,*

इसे ऑनलाइन आज़माएं!

Answer 10

जाप , 7 बाइट्स

*MtMP/U

झसे आज़माओ

---

व्याख्या

बस मंचला लागू करता है, जहां Mtतन है, MPपी है और Uइनपुट है।

Answer 11

ओम v2 , 7 बाइट्स

απ/ÆT³*

इसे ऑनलाइन आज़माएं!

---

कैसे?

α / πT³ * पूर्ण कार्यक्रम

α पुश पाई।
  / इनपुट द्वारा विभाजित।
   ÆT स्पर्शरेखा।
     ³ * इनपुट द्वारा गुणा किया जाता है।
          अवैध रूप से उत्पादन।

Answer 12

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

Answer 13

आम लिस्प, 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 14

जावास्क्रिप्ट (ईएस 6), 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>

Answer 15

पायथन 2 , 45 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

38 बाइट्स

— मिस्टर एक्सकोडर

इस तरह के चालान में मैं वास्तव में फूटर में प्रिंट लगाकर बाइट्स को बचाने के लिए लैम्ब्डा का उपयोग करना पसंद नहीं करता ... इसलिए: 44 बाइट्स

— साइमन

@ साइमन क्यों? फ़ंक्शंस एक वैध सबमिशन हैं - आप या तो एक मूल्य आउटपुट कर सकते हैं, या इसे किसी फ़ंक्शन से वापस कर सकते हैं। पाद लेख में प्रिंट की आवश्यकता नहीं है।

— स्टीफन

Answer 16

अजगर , 9 बाइट्स

*.tc.n0Q2

परीक्षण सूट।

---

कैसे?

* .tc.n0Q2 पूर्ण कार्यक्रम। क्यू का मतलब इनपुट है।

    .n0 पाई। 
   c द्वारा विभाजित:
       Q इनपुट।
 .t 2 स्पर्शरेखा
* Q इनपुट से गुणा करें।
             आउटपुट निहित है।

Answer 17

गैया , 5 बाइट्स

₵P÷ṫ×

इसे ऑनलाइन आज़माएं!

---

कैसे?

₵ P ÷ Full × पूर्ण कार्यक्रम।

Pi पी पुश पी।
  Input इनपुट द्वारा विभाजित।
   ṫ स्पर्शरेखा।
    × इनपुट द्वारा गुणा करें।

Answer 18

स्विफ्ट , 35 बाइट्स

संकलक चेतावनी के साथ:

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

यहाँ कोशिश करो!

संकलक चेतावनी के बिना, 40 बाइट्स :

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

Answer 19

एक्सेल, 16 बाइट्स

=A1*TAN(PI()/A1)

Answer 20

पर्ल, 14 + 16 = 30

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

कार्यक्रम के लिए 14 बाइट्स, और कमांड लाइन स्विच के लिए 16

Answer 21

प्रोलोग (एसडब्ल्यूआई) , 25 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह कोडगॉल्फ के लिए मेरा पहला सबमिशन है, आशा है कि मैं ठीक कर रहा हूं। एक समारोह के रूप में लिखा।

Answer 22

आईबीएम / लोटस नोट्स फॉर्मूला लैंग्वेज, 13 बाइट्स

a*@Tan(@Pi/a)

फ़ील्ड के माध्यम से लिया गया इनपुट उसी फॉर्म पर दिया गया है, जिस फॉर्मूले वाले फ़ील्ड का नाम है। नीचे दिखाए गए सभी परीक्षण मामलों का कोई TIO उपलब्ध नहीं है:

Answer 23

पॉवरशेल , 38 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह वास्तव में टिन पर क्या कहता है, लंबी [math]::। NET कॉल के कारण बस थोड़ी देर लगती है ।

Answer 24

रूबी , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 25

परी / जीपी , 14 बाइट्स

n->tan(Pi/n)*n

इसे ऑनलाइन आज़माएं!

Answer 26

सी # (मोनो सी # संकलक) , 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

दुर्भाग्य से, यह न तो एक पूर्ण कार्यक्रम है, न ही एक कार्य है। इसके बजाय यह एक स्निपेट है, जिसे यहां अनुमति नहीं है। हालाँकि, मुझे लगता है कि आप इसे n=>एक तीर फ़ंक्शन में बनाने के लिए शुरुआत में जोड़ सकते हैं (इसे एक चुटकी नमक के साथ लें, मुझे C # नहीं पता है) जो कि मान्य है।

— caird coinheringaahing

आप स्निपेट को एक में रख सकते हैं System.Func<T, T>, जो एक floatइनपुट के रूप में और दूसरा आउटपुट के रूप में लेगा । घोषणा इस तरह System.Func<float, float> f = n=>n*Math.Tan(Math.PI/n);दिखेगी : जहां पर बाइटकाउंट शुरू होगा n=>। मेरे उदाहरण में मैंने 2 बाइट्स बचाने के लिए आपके दो कोष्ठकों को छोड़ दिया;)

— इयान एच।

Answer 27

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