Berechnen Sie die Fläche eines regelmäßigen Polygons

19

Gegeben eine ganze Zahl n, wobei 3 <= n < 2^32, die Berechnung der Fläche eines regelmäßigen n-gon mit einem Apothema von 1; die Formel für die ist n * tan(π / n). Für diejenigen, die nicht wissen, was das Apothem ist:

Das Apothem eines regelmäßigen Polygons ist ein Liniensegment von der Mitte zum Mittelpunkt einer seiner Seiten.

nGeben Sie den Bereich des -gons als Gleitkomma mit mindestens 8 Dezimalstellen aus.

Testfälle

3
5.1961524227

6
3.4641016151

10
3.2491969623

20
3.1676888065

99
3.1426476062

1697
3.1415962425

15000
3.1415926995

Hinweis: Die obigen Testfälle enthalten 2 Stellen mehr, als Sie zur Ausgabe benötigen.

code-golf  math  number  geometry 
— Zach Gates
quelle

Antworten:

9

Mathematica, 16 Bytes

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

Probieren Sie es online!

Natürlich hat Mathematica dafür eingebaute Funktionen 

Area@*RegularPolygon
— J42161217
quelle
Area@RegularPolygonsollte sein Area@*RegularPolygon; wie es jetzt ist, kann es nicht in einer Variablen erfasst werden. Das heißt, f = Area@RegularPolygon; f[3]funktioniert nicht. Relevante
— Metadiskussion
@JungHwanMin ok, ich habe es behoben (obwohl ich es nicht als Antwort gepostet habe. Ich habe nur zum Spaß die eingebauten Funktionen gezeigt)
— J42161217
6

Eigentlich 5 Bytes

╦/Tß*

Probieren Sie es online!

Wie?

╦ / Tß * Volles Programm.

╦ Pi drücken.
 / Dividiere ^ durch die Eingabe.
  T Tangente.
   ß * Mit der Eingabe multiplizieren.
        Implizit ausgeben.

Alternative: ß╦/T*. o_O Schlägt tatsächlich Jelly !!!

— Mr. Xcoder
quelle
Eingebaute 2-Byte-Namen ...
— Erik der Outgolfer
Ja, ich weiß ... @EriktheOutgolfer 3-Byte-Einbauten in Pyth>. <
— Mr. Xcoder
3
+1 für " Tatsächlich schlägt Jelly !!! " Das Wortspiel wird nie alt. ;)
— Kevin Cruijssen
4

x87-Maschinencode, 11 Byte

D9 EB
DA 31
D9 F2
DD D8
DA 09
C3

Die obigen Codebytes definieren eine Funktion, die die Fläche eines regulären n-Gons mit einem Apothem von 1 berechnet. Für diese Berechnung werden x87-FPU-Anweisungen (die klassische Gleitkommaeinheit auf den x86-Prozessoren) verwendet.

In diesem Fall ist __fastcalldas Argument der Funktion ein Zeiger auf die im ECXRegister übergebene Ganzzahl . Das Ergebnis der Funktion ist ein Gleitkommawert, der oben im x87-Gleitkommastapel (Register ST0) zurückgegeben wird.

Probieren Sie es online!

Ungolfed Assembler-Mnemonik:

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

Wie Sie sehen, ist dies im Grunde nur eine einfache Berechnung der angegebenen Formel,
     result = n * tan (π / n).
Nur ein paar interessante Dinge weisen darauf hin:

  • Die x87-FPU verfügt über eine spezielle Anweisung zum Laden des konstanten Werts PI ( FLDPI). Dies wurde früher selten verwendet (und jetzt offensichtlich viel weniger), ist jedoch kürzer als das Einbetten einer Konstanten in Ihre Binärdatei und das Laden dieser.
  • Der x87-FPU-Befehl zum Berechnen der Tangente FPTANersetzt den Wert des Eingaberegisters (die Oberseite des FPU-Stapels) durch das Ergebnis, drückt jedoch auch eine Konstante 1.0 auf die Oberseite des FPU-Stapels. Dies geschieht aus Gründen der Abwärtskompatibilität mit dem 8087 (ich habe keine Ahnung, warum dies auf dem 8087 geschehen ist; wahrscheinlich ein Fehler). Das heißt, wir müssen diesen nicht benötigten Wert vom Stapel nehmen. Der schnellste und kürzeste Weg dazu ist ein einfacher FSTP st0, wie wir ihn hier verwenden. Wir hätten auch ein Multiplizieren und Popen durchführen können , da das Multiplizieren mit 1,0 das Ergebnis nicht ändert, aber dies sind auch 2 Bytes (also kein Gewinn in der Codegröße), die wahrscheinlich langsamer ausgeführt werden und möglicherweise unnötige Unbestimmtheit mit sich bringen das Ergebnis.

Obwohl ein moderner Programmierer oder Compiler den SSE-Befehlssatz (und einen neueren Befehlssatz) anstelle des alternden x87 verwenden würde, würde dies mehr Code zur Implementierung erfordern, da es in diesen neueren ISAs keinen einzelnen Befehl zur Berechnung einer Tangente gibt.

— Cody Gray
quelle
2

var'aq , 51 Bytes

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

Erläuterung

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

JavaScript (ES6), 24 Byte

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

Versuch es

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>
Erweitern Sie das Snippet

— Shaggy
quelle
1

Python 2 , 45 Bytes

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

Probieren Sie es online!

— Husnain Raza
quelle
2
— Mr. Xcoder
Bei solchen Herausforderungen mag ich es nicht, Lambda zu verwenden, um Bytes zu sparen, indem ich den Ausdruck einfach in die Fußzeile
— Simon
4
@ Simon warum? Funktionen sind eine gültige Übermittlung - Sie können entweder einen Wert ausgeben oder ihn von einer Funktion zurückgeben. Der Ausdruck in der Fußzeile ist nicht erforderlich.
— Stephen
1

Pyth , 9 Bytes

*.tc.n0Q2

Testsuite.

Wie?

* .tc.n0Q2 Vollständiges Programm. Q bedeutet Eingabe.

    .n0 Pi. 
   c geteilt durch:
       Q Die Eingabe.
 .t 2 Tangente.
* Q Mit dem Eingang multiplizieren.
             Implizit ausgeben.
— Mr. Xcoder
quelle
1

Perl, 14 + 16 = 30

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

14 Byte für das eigentliche Programm und 16 Byte für die Befehlszeilenoptionen

0

IBM / Lotus Notes Formula Language, 13 Byte

a*@Tan(@Pi/a)

Die Eingabe erfolgt über ein Feld mit dem Namen a auf demselben Formular wie das Feld mit der Formel. Kein TIO verfügbar, also Screenshot aller unten gezeigten Testfälle:

Bildbeschreibung hier eingeben

— ElPedro
quelle
0

C # (Mono C # -Compiler) , 24 Byte


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

Probieren Sie es online!

— Amit Gawande
quelle
3
Leider ist dies weder ein vollständiges Programm noch eine Funktion. Stattdessen ist es ein Ausschnitt, der hier nicht erlaubt ist. Ich denke jedoch, dass Sie n=>zu Beginn hinzufügen können , um daraus eine Pfeilfunktion zu machen (nehmen Sie dies mit einer Prise Salz, ich weiß nicht, C #), die gültig ist.
— Caird Coinheringaahing
Sie können das Snippet in a platzieren System.Func<T, T> , das ein floatals Eingabe und ein anderes als Ausgabe annehmen würde . Die Deklaration würde so aussehen System.Func<float, float> f = n=>n*Math.Tan(Math.PI/n);:, wo der bytecount beginnen würde n=>. In meinem Beispiel habe ich zwei Ihrer Klammern weggelassen, um 2 Bytes zu sparen;)
— Ian H.
0

RPNGolf 0,6 / 0,7 , 12 Bytes

tbp-1mBsdmcc

Mein erster Beitrag mit RPNGolf, meiner neuen Stack-basierten Sprache!

Dies ist ein vollständiges Programm, das eine Ganzzahl von der Standardeingabe liest und die Ausgabe auf die Standardausgabe druckt (ohne nachfolgende Newline).

Erläuterung:

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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.