introduzione

Tutti hanno sentito parlare di seno (sin) , coseno (cos) , tangente (abbronzatura) , cotangente (cot) , secante (sec) e cosecante (csc) . Quasi ogni angolo li ha.

Molto meno conosciuti o ricordati, sono exsecant (exsec) , excosecant (excsc) , versine (versin) e coversine (cvs) . Quasi ogni angolo ha anche quelli. Ci sono alcuni che sono ancora meno conosciuti, ma ci limiteremo a questi.

Ho creato una visualizzazione di questi per l'angolo θ, che è di 45 °.

La sfida

Crea un programma che accetta un input di un angolo n, in gradi, e produrrà:

1. il seno dell'angolo n

2. il coseno dell'angolo n

3. la tangente dell'angolo n

4. la secante dell'angolo n

5. almeno una delle seguenti. Ogni oggetto aggiuntivo da questo elenco guadagnerà un bonus del -5%, per un massimo del -25%.

   • esente di angolo n

   • cosecante di angolo n

   • excosecant di angolo n

   • angolo di inclinazione n

   • copertine d'angolo n

   • cotangente di angolo n

Se il tuo punteggio è un decimale dopo aver applicato un bonus, arrotonda per eccesso al numero intero più vicino.

Ingresso

È possibile accettare l'input tramite STDIN o una chiamata di funzione. nVerrà passato un singolo argomento .

n sarà sempre un numero intero maggiore di 0, ma inferiore o uguale a 90.

Produzione

Ecco un esempio dell'uscita per seno di 45 °. Tutti gli elementi di output devono essere in questo formato. L'ordine degli articoli non ha importanza.

sine: 0.70710678118

Tutti gli elementi devono avere esattamente 4 numeri dopo il decimale (precisione al decimilionesimo). Di seguito sono riportati alcuni esempi di arrotondamento.

0 -> 0.0000
1 -> 1.0000
0.2588190451 -> 0.2588
5.67128181962 -> 5.6713
10 -> 10.0000
12.4661204396 -> 12.4661

Qualsiasi risultato inesistente / indefinito dovrebbe essere impostato su 0.

Esempio

myprogram(60)

sine: 0.8660
cosine: 0.5000
tangent: 1.7321
secant: 2.0000
exsecant: 1.0000
cosecant: 1.1547
excosecant: 0.1547
versine: 0.5000
coversine: 0.1340
cotangent: 0.5774

tabellone segnapunti

Affinché il tuo punteggio appaia sul tabellone, dovrebbe essere in questo formato:

# Language, Score

O se hai guadagnato un bonus:

# Language, Score (Bytes - Bonus%)

Le barrature non dovrebbero causare problemi.

function getURL(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:getURL(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),useData(answers)}})}function getOwnerName(e){return e.owner.display_name}function useData(e){var s=[];e.forEach(function(e){var a=e.body.replace(/<s>.*<\/s>/,"").replace(/<strike>.*<\/strike>/,"");console.log(a),VALID_HEAD.test(a)&&s.push({user:getOwnerName(e),language:a.match(VALID_HEAD)[1],score:+a.match(VALID_HEAD)[2],link:e.share_link})}),s.sort(function(e,s){var a=e.score,r=s.score;return a-r}),s.forEach(function(e,s){var a=$("#score-template").html();a=a.replace("{{RANK}}",s+1+"").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SCORE}}",e.score),a=$(a),$("#scores").append(a)})}var QUESTION_ID=58283,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],answer_ids,answers_hash,answer_page=1;getAnswers();var VALID_HEAD=/<h\d>([^\n,]*)[, ]*(\d+).*<\/h\d>/;

body{text-align:left!important}table thead{font-weight:700}table td{padding:10px 0 0 30px}#scores-cont{padding:10px;width:600px}#scores tr td:first-of-type{padding-left:0}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id="scores-cont"><h2>Scores</h2><table class="score-table"><thead> <tr><td></td><td>User</td><td>Language</td><td>Score</td></tr></thead> <tbody id="scores"></tbody></table></div><table style="display: none"> <tbody id="score-template"><tr><td>{{RANK}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SCORE}}</td></tr></tbody></table>

CJam, 94 89 85 81 80 byte

"sine tangent secant"S/{"co"1$+}%rd90/_i33Yb@[P*2/__ms\mc@mt]_Wf#W%+?.{d": %.4f"e%N}

Il codice è lungo 84 byte e si qualifica per un bonus del 5% ( cotangente e cosecante ).

Provalo online nell'interprete CJam .

Come funziona

"sine tangent secant" e# Push that string.
S/                    e# Split it at spaces.
{"co"1$+}%            e# For each chunk, append a copy to the string "co", pushing
                      e# ["sine" "cosine" "tangent" "cotangent" "secant" "cosecant"].
rd90/                 e# Read a Double from STDIN and divide it by 90.
_i                    e# Push a copy and cast it to integer.
33Yb                  e# Push 33 in base 2, i.e., [1 0 0 0 0 1].
@                     e# Rotate the Double on top of the stack.
[                     e#
  P*2/                e# Multiply by Pi and divide by 2.
  __                  e# Push two copies of the result.
  ms                  e# Compute the sine of the topmost copy.
  \mc                 e# Swap and compute the cosine of the next copy.
  @mt                 e# Rotate and compute the tangent of the original.
 ]                    e#
 _Wf#                 e# Copy the array and raise all Doubles to the power -1.
                      e# This computes cosecant, secant and cotangent.
 W%                   e# Reverse their order.
 +                    e# Append to the original array.
 ?                    e# Select 33Yb if the integer part of the input divided by 90 is
                      e# (i.e., if the input is 90), the constructed array otherwise.
 .{                   e# For each function name and result:
   d                  e# Cast to Double (needed for 33Yb).
   ": %.4f"           e# Push a format string containing ": " and a 4-decimal float.
   e%                 e# Apply the formatting to the Double on the stack.
   N                  e# Push a linefeed.
 }                    e#

Julia, 162-10% = 144 byte

n->for z=zip(split("sine cosine tangent secant exsecant cosecant cotangent"),[sind,cosd,tand,secd,i->secd(i)-1,cscd,cotd]) @printf("%s: %.4f\n",z[1],z[2](n))end

Ungolfed:

function f(n)
    # Construct a vector of names
    s = split("sine cosine tangent secant exsecant cosecant cotangent")

    # Construct a vector of functions
    o = [sind, cosd, tand, secd, i -> secd(i) - 1, cscd, cotd]

    # Print each in a loop
    for z = zip(s, o)
        @printf("%s: %.4f\n", z[1], z[2](n))
    end
end

Pyth, 66-10% = 59,4 byte

j+V+Jc"sine secant tangent")+L"co"Jsmm%": %.4f"^.t.td7k^_1k3,Q-90Q

Calcola il seno, la secante e la tangente. Quindi, le co-funzioni vengono semplicemente calcolate tramite la formula coF(x) = F(90 - x).

Mathematica (non valido al momento), 134 121 104

Solo per divertimento, sicuramente si può giocare molto a golf

f[n_]:=(a={Sin,Cos,Tan,Sec,Cot,Csc};TableForm[N[#@n,4]&/@a,TableHeadings->{ToString[#]<>":"&/@a,None}])

E dovrebbe avere un bonus del 5% (Cot e Csc), quindi pari a 99 caratteri

Esempio di output:

JavaScript (ES6), 173 (182-5%)

Modifica revisionata dopo il chiarimento, ora il bonus è del 5%

Modifica realizzato che l'angolo non può essere 0

// TEST - redefine alert
alert=x=>O.innerHTML=x

r=(a=prompt(i=0))*(M=Math).PI/180,V=_=>[s=M.sin(r),c=M.cos(r),(f=a-90)&&s/c,c/s,f&&1/c,1/s][i++].toFixed(4);
alert(`sine
tangent
secant`.replace(/.+/g,h=>h+`: ${V()}
co${h}: ${V()}`))

/* More bonus, but too longer 
r=(a=prompt(i=0))*(M=Math).PI/180,V=_=>[s=M.sin(r),c=M.cos(r),1-c,1-s,(f=a-90)&&s/c,c/s,f&&1/c,1/s][i++].toFixed(4);
alert(`sine
versine
tangent
secant`.replace(/.+/g,h=>h+`: ${V()}
co${h}: ${V()}`))
*/

<pre id=O></pre>

Javascript ES6, 154 148 (198-25%)

(n=0)=>[S='sine',(O='co')+S,T='tangent',C='secant',X=O+C,O+T,V='ver'+S,O+V,'ex'+C,'ex'+X].map((q,i)=>q+': '+[s=Math.sin(n),c=Math.cos(n),t=s/c,e=1/c,o=1/s,1/t,1-c,1-s,e-1,o-1][i].toFixed(4)).join`
`

Ungolfed:

(n=0)=>          // function declaration, accepts number, defaults to 0
  [              // create array of trig function names
    S='sine',    // sine
    (O='co')+S,  // cosine
    T='tangent', // tangent
    C='secant',  // secant
    X=O+C,       // cosecant
    O+T,         // cotangent
    V='ver'+S,   // versine
    O+V,         // coversine
    'ex'+C,      // exsecant
    'ex'+X       // excosecant
  ].map((q,i)=>  // map over names
                 // append ": <value rounded to 4 decimals>" to function name:
    q+': '+[s=Math.sin(n),c=Math.cos(n),t=s/c,e=1/c,o=1/s,1/t,1-c,1-s,e-1,o-1][i].toFixed(4)
  ).join`        // add newline between each function
`

R, 122 136 134 byte

n=scan()*pi/180;write(paste0(c("sine","cosine","tangent","secant","versine"),sprintf(": %.4f",c(sin(n),r<-cos(n),tan(n),1/r,1-r))),"")

Esempio di utilizzo

> n=scan()*pi/180;write(paste0(c("sine","cosine","tangent","secant","versine"),sprintf(": %.4f",c(sin(n),r<-cos(n),tan(n),1/r,1-r))),"")
1: 60
2: 
Read 1 item
sine: 0.8660
cosine: 0.5000
tangent: 1.7321
secant: 2.0000
versine: 0.5000

Perl, 182 177 (236-25%)

Esegui con -n(1 byte aggiunto al punteggio non corretto).

$b=$_==90;$_/=57.296;$c=cos;$s=sin;sub f{printf"%s: %.4f\n",@_}$T=tangent;f$T,$b?0:$s/$c;f co.$T,$c/$s;$S=sine;f $S,$s;f co.$S,$c;$C=secant;f$C,$b?0:1/$c;f co.$C,1/$s;f ex.$C,$b?0:1-1/$c;f exco.$C,1/$s-1;$V=ver.$S;f$V,1-$c;f co.$V,1-$s

Nulla di bello. Sfrutta l' -ninput implicito, $_come argomento predefinito per sine cos, e le parole d'ordine per le stringhe. La regola "undefined = 0" è codificata nell'uso dell'operatore ternario ?:(si applica solo per 90 °).

Una cosa che ho learend è che a quanto pare, non si può avere (o non può chiamare ) una subroutine di nome s(o m, y, tr): sub s {print 1}; sle rese Substitution pattern not terminated at -e line 1.

Python 3, 282 (375-25%)

La gestione degli errori si è rivelata in qualche modo complicata da errori in virgola mobile; vale a dire, è cos(90)venuto fuori un numero molto piccolo invece di zero.

Non sarà mai la risposta migliore, ma mi piace pensare che potrebbe essere la risposta valida per tutte le funzioni più breve in un linguaggio non golfy che non ha le funzioni di attivazione nello spazio dei nomi predefinito . ;-)

import math as m
def p(q,r):print(q+':','%.4f'%r)
def a(n):
 n=n*m.pi/180
 C,S=round(m.cos(n),8),m.sin(n)
 A=S,1,0,C,1,S,C,0,C,S,1,C,0,1,S,1,C,-1,1,S,C,1,1,S,1
 def t():
  nonlocal A;u,v,w,x,y,*A=A;z=-1 if w>0 else 1
  try:return z*u/v+w,z*x/y+w
  except:return 0,0
 def q(y,x=''):J,K=t();p(x+y,J);p(x+'co'+y,K)
 q('sine');q('tangent');s='secant';q(s);q(s,'ex');q('versine')

Uscita campione:

>>> a(60)
sine: 0.8660
cosine: 0.5000
tangent: 1.7321
cotangent: 0.5774
secant: 2.0000
cosecant: 1.1547
exsecant: 1.0000
excosecant: 0.1547
versine: 0.5000
coversine: 0.1340

Perl, 165 (193-15%)

Sto presentando questa come una nuova risposta perché l'idea è abbastanza diversa dalla dall'altra . Per favore fatemi sapere se è più appropriato sostituire il mio primo tentativo.

$p=atan2 1,0;$b=$_-90;%h=qw(sine $s tangent $b?$s/$c:0 secant $b?1/$c:0 versine 1-$c);$_/=90/$p;sub e{$c=cos;$s=sin}e;sub f{eval"printf'$x$_: %.4f
',$h{$_}"for keys%h}f;$b=1;$_=$p-$_;e;$x=co;f

Esegui con -n(1 byte aggiunto).

Ungolfed:

# π/2
$p=atan2 1,0;

# trouble?
$b=$_-90;

# Construct a hash whose keys are the “base” function names,
# and whose values are the corresponding expressions in terms of sin and cos
%h=qw(sine $s tangent $b?$s/$c:0 secant $b?1/$c:0 versine 1-$c);

# Thanks to ‘-n’, input is in $_; convert to radians
$_/=90/$p;

# Compute sin and cos in a reusable way
sub e{$c=cos;$s=sin}
e;

sub f {
   eval "printf '$x$_: %.4f
', $h{$_}" 
      for keys %h
}

f;

# Now the “co” functions
# No trouble here
$b=1;

# x ← π/2 - x
$_=$p-$_;

e;
$x=co;
f

Dal momento che svolge le quattro funzioni "co", penso che si qualifichi per un bonus 3 * 5% = 15%.

Perl, 100 95 94 byte

Whoa, lotta perl risponde.

$_=<>;printf"sine: %.4f\ncosine: %.4f\ntangent: %.4f\nsecant: %.4f\n",sin,cos,(sin)/cos,1/cos

Haskell, 159 = 186-15% byte

s x=zipWith(\a b->a++": "++show b)(concatMap(\n->[n,"co"++n])$words"sine tangent versine secant")$map($(x*pi/180))[sin,cos,t,(1/).t,(1-).cos,(1-).sin,e.t,e.(1/).t]
e=sqrt.(+1).(^2)
t=tan

Nessun ex-cosa per mantenere il mio intelligente schema di denominazione e dal momento che non sapevo accorciare (\x->x-1).(-1)è solo un numero.

Si prega di lamentarsi se si desidera che prettify ( mapM_ putStrLn) le righe.