Dato un numero intero, ndove 3 <= n < 2^32, calcola l'area di un normale n-gon con un apotema di 1; la formula per cui è n * tan(π / n). Per quelli che non sanno cos'è l'apotema:
nEmette l'area del -gon come punto mobile con non meno di 8 cifre decimali.
3
5.1961524227
6
3.4641016151
10
3.2491969623
20
3.1676888065
99
3.1426476062
1697
3.1415962425
15000
3.1415926995
Nota: i casi di test sopra riportati includono 2 cifre in più di quelle necessarie per l'output.
Risposte:
N[Tan[Pi/#]#,9]&
ovviamente matematica ha incorporato per questo
Area@*RegularPolygon
╦/Tß*
╦ / Tß * Programma completo.
╦ Premere Pi.
/ Dividi ^ per l'input.
T Tangente.
ß * Moltiplicare per l'input.
Uscita implicita.
Alternativa: ß╦/T*. o_O In realtà batte Jelly !!!
D9 EB
DA 31
D9 F2
DD D8
DA 09
C3
I byte di codice sopra definiti definiscono una funzione che calcola l'area di una normale n-gon con un apotema di 1. Utilizza queste istruzioni FPU x87 (la classica unità a virgola mobile sui processori x86) per eseguire questo calcolo.
Seguendo una convenzione di chiamata standard x86 basata sul registro (in questo caso __fastcall), l'argomento della funzione è un puntatore all'intero, passato nel ECXregistro. Il risultato della funzione è un valore in virgola mobile, restituito nella parte superiore dello stack in virgola mobile x87 (registro ST0).
Mnemonici di assemblaggio non golfati:
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
Come puoi vedere, questo è fondamentalmente solo un semplice calcolo della formula data,
risultato = n * tan (π / n)
Solo un paio di cose interessanti portano alla luce:
FLDPI). Questo veniva usato raramente, anche nel passato (e ovviamente molto meno ora), ma ha dimensioni più ridotte rispetto all'incorporamento di una costante nel tuo binario e al caricamento.FPTANsostituisce il valore del registro di input (la parte superiore dello stack FPU) con il risultato, ma spinge anche un costante 1,0 nella parte superiore dello stack FPU. Questo viene fatto per la retrocompatibilità con l'8087 (non ho idea del perché ciò sia stato fatto sull'8087; probabilmente un bug). Ciò significa che dobbiamo eliminare questo valore non necessario dallo stack. Il modo più rapido e breve per farlo è semplice FSTP st0, come usiamo qui. Avremmo anche potuto fare un moltiplicare e pop , poiché la moltiplicazione per 1.0 non cambierà il risultato, ma questo è anche 2 byte (quindi nessuna vincita nella dimensione del codice), probabilmente verrà eseguito più lentamente e potrebbe introdurre indeterminazione non necessaria in il risultato.Sebbene un programmatore o compilatore moderno userebbe il set di istruzioni SSE (e successive), piuttosto che l'invecchiamento x87, ciò richiederebbe più codice da implementare, poiché non esiste una singola istruzione per calcolare una tangente in questi ISA più recenti.
cat(). 5 byte in meno.
απ/ÆT³*
απ / ÆT³ * Programma completo
απ Push Pi.
/ Diviso per l'ingresso.
TangT Tangente.
³ * Moltiplicato per l'ingresso.
Uscita implicita.
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>*.tc.n0Q2
* .tc.n0Q2 Programma completo. Q significa input.
.n0 Pi.
c Diviso per:
Q L'input.
.t 2 Tangente.
* Q Moltiplicare per l'input.
Uscita implicita.
₵P÷ṫ×
₵ P ÷ ṫ × Programma completo.
₵ P Premere Pi.
÷ Diviso per l'ingresso.
ṫ tangente.
× Moltiplicare per l'input.
perl -MMath::Trig -ple'$_*=tan(pi/$_)'
14 byte per il programma corretto e 16 per le opzioni della riga di comando
f(X,Y):-X is Y*tan(pi/Y).
Questa è la mia prima presentazione a codegolf, spero che vada bene. Scritto come una funzione.
param($n)$n*[math]::tan([math]::pi/$n)Fa esattamente quello che dice sulla scatola, richiede solo un po 'più di tempo a causa delle lunghe [math]::chiamate .NET.
n=>all'inizio per renderlo una funzione freccia (prendilo con un pizzico di sale, non conosco C #) che è valido.
System.Func<T, T>, che richiederebbe un floatinput e un altro come output. La dichiarazione sarebbe simile a questa System.Func<float, float> f = n=>n*Math.Tan(Math.PI/n);:, da dove inizierebbe il Bytecount n=>. Nel mio esempio ho omesso due delle tue parentesi per salvare 2 byte;)
tbp-1mBsdmcc
Il mio primo post con RPNGolf, il mio nuovo linguaggio basato sullo stack!
Questo è un programma completo che legge un numero intero dall'input standard e stampa l'output sull'output standard (senza una nuova riga finale).
Spiegazione:
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
Area@RegularPolygondovrebbe essereArea@*RegularPolygon; com'è ora, non può essere catturato in una variabile. Cioè,f = Area@RegularPolygon; f[3]non funziona. Meta discussione pertinente