एक प्रकार की महानता

24

परिचय

सभी ने साइन (पाप) , कोसाइन (कॉस) , टेंज़ेंट (टैन) , कॉटैंगेंट (खाट) , सेकेंट (सेक) , और कोसेकेंट (सीएससी) के बारे में सुना है । लगभग हर एंगल में उनके पास है।

बहुत कम ज्ञात, या याद किया जाता है, एक्ससेकेंट (एक्ससेक) , एक्सोससेंट (एक्स्कस) , वर्सिन (वर्सिन) , और कवर्साइन (सीवीएस) हैं । लगभग हर कोण के पास भी हैं। कुछ ऐसे भी हैं जो कम ही जाने जाते हैं, लेकिन हम सिर्फ इनसे चिपके रहेंगे।

मैंने कोण θ के लिए इनमें से एक दृश्य बनाया है, जो 45 ° है।

चुनौती

एक ऐसा प्रोग्राम बनाएं जो nडिग्री में, और आउटपुट में कोण का इनपुट लेता है :

  1. कोण की साइन n

  2. कोन का कोण n

  3. कोण की स्पर्शरेखा n

  4. कोण के सेकंड n

  5. निम्न में से कम से कम एक। इस सूची से प्रत्येक अतिरिक्त आइटम अधिकतम -25% के लिए, -5% बोनस अर्जित करेगा।

    • कोण का अत्यधिक n

    • कोण के cosecant n

    • कोण का बहिष्कार n

    • कोण का छंद n

    • कोण का आवरण n

    • कोण का अपंग n

यदि बोनस लागू करने के बाद आपका स्कोर एक दशमलव है, तो निकटतम पूर्ण संख्या में गोल करें।

इनपुट

आप अपने इनपुट को STDIN या फ़ंक्शन कॉल के माध्यम से स्वीकार कर सकते हैं। एक एकल तर्क, nपारित किया जाएगा।

n हमेशा एक पूर्ण पूर्णांक होगा जो 0 से अधिक है, लेकिन 90 से कम या इसके बराबर है।

उत्पादन

यहां 45 ° के साइन के लिए आउटपुट का एक उदाहरण है। सभी आउटपुट आइटम इस प्रारूप में होने चाहिए। वस्तुओं का क्रम मायने नहीं रखता।

sine: 0.70710678118

दशमलव के बाद सभी आइटमों की संख्या ठीक 4 होनी चाहिए (दस-हज़ारवाँ तक सटीकता)। नीचे गोलाई के कुछ उदाहरण दिए गए हैं।

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

कोई भी असंगत / अनिर्धारित परिणाम 0 के लिए डिफ़ॉल्ट होना चाहिए।

उदाहरण

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

स्कोरबोर्ड

आपके स्कोर बोर्ड पर दिखाई देने के लिए, यह इस प्रारूप में होना चाहिए:

# Language, Score

या यदि आपने एक बोनस अर्जित किया है:

# Language, Score (Bytes - Bonus%)

स्ट्राइकथ्रू समस्या का कारण नहीं होना चाहिए।

कोड स्निपेट दिखाएं

code-golf  math  trigonometry 
— Zach गेट्स
स्रोत
क्या आउटपुट का क्रम मायने रखता है?
— जकुबे
12
आगे पैदल सेना: "हर कोण उनके पास है" - सच नहीं है; उदाहरण के लिए 90 डिग्री के विषम गुणकों में स्पर्शरेखा नहीं होती है। (यह मुझे बहुत विचित्र लगता है कि आपको शून्य का आउटपुट देने के लिए किसी भी समसामयिक मूल्यों की आवश्यकता नहीं है। क्या आप वास्तव में ऐसे कार्यक्रम का उपयोग करेंगे, जो जानबूझकर इस तरह के भ्रामक उत्तर देता है?) साथ ही, मुझे यह जानने में दिलचस्पी होगी कि आप कॉस्मिक और कॉटैंगेंट के रूप में क्यों मानते हैं? धर्मनिरपेक्ष से अधिक अस्पष्ट होना; मेरे ए-स्तर की गणित कक्षाओं में हमने एक ही समय में उन तीनों के बारे में सीखा।
— हैमराइट
क्या कैपिटलाइज़ेशन फिक्स्ड लोअरकेस है? मुझे आउटपुट 'साइन,
— कॉसिन
फुल प्रोग्राम बनाम इनपुट को फंक्शन कॉल के माध्यम
— edc65
1
क्या एंगल इनपुट वास्तव में है greater than 0, इसलिए 0 की अनुमति नहीं है?
— edc65

जवाबों:

8

CJam, 94 89 85 81 80 बाइट्स

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

यह कोड 84 बाइट्स लंबा है और 5% बोनस ( कॉटेजेंट और कोसेकेंट ) के लिए योग्य है।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

"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#
— डेनिस
स्रोत
6

जूलिया, 162 - 10% = 144 बाइट्स

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
— एलेक्स ए।
स्रोत
क्या यह मुझे या आपके "अनफोल्डेड" संस्करण में एक अतिरिक्त लूप है?
— डेविड एरेन्बर्ग
आप अतिशयोक्तिपूर्ण और अपंग के बिना बेहतर होगा।
— lirtosiast
@DavidArenburg लंबे संस्करण में छोरों की संख्या समान है, यह केवल लघु संस्करण की तुलना में अलग तरह से लिखा गया है।
— एलेक्स ए।
@ThomasKwa मुझे पता है, लेकिन मैं वैसे भी जीतने वाला नहीं हूं। : पी
— एलेक्स ए।
5

पायथ, 66 - 10% = 59.4 बाइट्स

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

साइन, सेकंड और स्पर्शरेखा की गणना करता है। फिर, सह-कार्यों की गणना केवल सूत्र के माध्यम से की जाती है coF(x) = F(90 - x)।

— orlp
स्रोत
क्या यह अपरिभाषित के लिए 0 देता है?
— lirtosiast
@ThomasKwa ऐसा मत सोचो।
— orlp
1
फिर यह वर्तमान में अमान्य है।
— lirtosiast
5

गणितज्ञ (वर्तमान में अमान्य), १३४ १२१ १०४

बस मनोरंजन के लिए, निश्चित रूप से इसे बहुत नीचे रखा जा सकता है

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

और इसमें 5% बोनस (Cot और Csc) होना चाहिए, इसलिए 99 वर्णों पर होना चाहिए

उदाहरण आउटपुट:

उदाहरण आउटपुट

— WizardOfMenlo
स्रोत
क्या आपको अधिक फ़ंक्शन जोड़कर बेहतर स्कोर नहीं मिलेगा?
— गर्वित हैकेलर
@ प्राउड हैकेलर, मैं कोशिश कर सकता हूं, लेकिन शायद मैं लाभ पात्रों से अधिक खो दूंगा
— विजार्डऑफमेनो
4
क्या यह पूर्ण रूप से कार्यों के नाम लिखता है, या इसके लिए उपयोग करता 0है sec(90)?
— 15
@ थोमस कावा ऐसा नहीं होना चाहिए, जब मौका मिले तो मैं इसका परीक्षण करूंगा
— विजार्डऑफमेनो
मुझे वास्तव में संदेह है कि यह वास्तविक फ़ंक्शन नाम
— डेविड अर्नबर्ग
4

जावास्क्रिप्ट (ईएस 6), 173 (182 - 5%)

स्पष्टीकरण के बाद संशोधित संपादित करें , अब बोनस 5% है

संपादित महसूस किया कि कोण 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>
स्निपेट का विस्तार करें

— edc65
स्रोत
4

जावास्क्रिप्ट ईएस 6, 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
`
— Dendrobium
स्रोत
क्या आप अपने शीर्षक में "जावास्क्रिप्ट ES6" के बाद अल्पविराम जोड़ सकते हैं ताकि आपका स्कोर सही ढंग से पार्स हो जाए?
— जैच गेट्स
3

आर, 122 136 134 बाइट्स

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))),"")

उदाहरण उपयोग

> 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
— डेविड अर्नबर्ग
स्रोत
2
scan()/(180/pi)-> scan()*pi/180?
— lirtosiast
3

पर्ल, 182 177 (236 - 25%)

साथ चलाएं -n(1 बाइट बिना स्कोर के जोड़े गए)।

$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

कुछ भी आकर्षक नहीं। यह का लाभ लेता है -nअंतर्निहित इनपुट के लिए, $_करने के लिए डिफ़ॉल्ट तर्क के रूप में sinऔर cos, और तार के लिए barewords। "अपरिभाषित = 0" नियम टर्नरी ऑपरेटर का उपयोग करने में हार्डकोड किया गया है?: (यह केवल 90 ° के लिए लागू होता है)।

एक बात मैं learend कि जाहिरा तौर पर, आप नहीं कर सकते हैं (या नहीं कर सकता है फोन एक सबरूटीन नाम) s(या m, y, tr): sub s {print 1}; sपैदावार Substitution pattern not terminated at -e line 1।

— xebtl
स्रोत
किसी कारण से, आपका स्कोर भी अजीब हो जाता है।
— लीफ विलर्ट्स
क्या आप "पर्ल" के बाद अल्पविराम जोड़ सकते हैं ताकि आपका स्कोर सही ढंग से पार हो जाए?
— Zach गेट्स
3

पायथन 3, 282 (375 - 25%)

फ़्लोटिंग-पॉइंट त्रुटियों से त्रुटि हैंडलिंग कुछ जटिल हो गई; अर्थात्, cos(90)शून्य के बजाय बहुत कम संख्या में निकला।

यह कभी भी शीर्ष उत्तर नहीं हो सकता है, लेकिन मुझे लगता है कि यह गैर-गोल्फ भाषा में सबसे छोटा वैध ऑल-फंक्शन उत्तर हो सकता है जिसमें डिफ़ॉल्ट नाम स्थान में ट्रिगर फ़ंक्शन नहीं हैं । ;-)

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')

नमूना उत्पादन:

>>> 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
— टिम पेडरिक
स्रोत
'.4f'%(r)कम नहीं होगा?
— xebtl
@xebtl: धन्यवाद। मैं भूल जाता हूं कि% -फॉर्म अभी भी मौजूद है!
— टिम पेडरिक
3

पर्ल, 165 (193 - 15%)

मैं यह आसा नया उत्तर प्रस्तुत कर रहा हूं क्योंकि यह विचार दूसरे से काफी अलग है । कृपया मुझे बताएं कि क्या मेरे पहले प्रयास को प्रतिस्थापित करना अधिक उचित है।

$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

-n(1 बाइट जोड़ा) के साथ चलाएँ ।

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

चूँकि यह चार “सह” करता है, इसलिए मुझे लगता है कि यह 3 * 5% = 15% बोनस के लिए योग्य है।

— xebtl
स्रोत
3

पर्ल, 100 95 94 बाइट्स

वाह, lotta पर्ल जवाब।

$_=<>;printf"sine: %.4f\ncosine: %.4f\ntangent: %.4f\nsecant: %.4f\n",sin,cos,(sin)/cos,1/cos
— एक स्पैगेटो
स्रोत
हाँ, और आप इस सरल दृष्टिकोण :-) के साथ बहुत अच्छा कर रहे हैं। आप -nइसके बजाय (1 बाइट के लिए गिनती) का उपयोग करके कुछ बाइट्स को शेव कर सकते हैं $_=<>। हालाँकि, आपको डिग्रियों से रेडियन में बदलना होगा, और आप निर्धारित 90 ° केस को हैंडल नहीं करेंगे। (उत्तरार्द्ध के साथ, ऐसा लगता है कि आप शायद ही यहाँ जवाबों के बीच अकेले हैं।)
— xebtl
यह भी याद रखें कि कोड गोल्फ का पूर्वज पर्ल गोल्फ :-) था
— xebtl
मैं यहाँ थोड़ा भ्रमित हूँ ... यह रेडियंस का उपयोग करता है। क्या मुझे डिग्री का उपयोग करना चाहिए था?
— एक स्पेगेटो
2

हास्केल, 159 = 186 - 15% बाइट्स

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

मेरे चतुर नामकरण योजना को रखने के लिए कोई पूर्व-बातें नहीं हैं और जब से मुझे पता नहीं था कि कैसे छोटा किया जाए (\x->x-1) । (-1)बस एक संख्या है।

कृपया शिकायत करें यदि आप चाहते हैं कि मैं mapM_ putStrLnलाइनों को पहले से तैयार करूँ ( )।

— लीफ़ विलर्ट्स
स्रोत
धन्यवाद! एलेक्स ए और @orlp के लिए भी। उत्तरार्द्ध को शायद शुद्ध स्कोर को गोल करना चाहिए।
— लीफ़ विलर्ट्स
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.