इस नोट की आवृत्ति क्या है?

21

त्वरित संगीत रिफ्रेशर:

पियानो कीबोर्ड में 88 नोट होते हैं। प्रत्येक सप्तक पर, 12 नोट हैं, C, C♯/D♭, D, D♯/E♭, E, F, F♯/G♭, G, G♯/A♭, A, A♯/B♭और B। हर बार जब आप 'सी' मारते हैं, तो पैटर्न एक सप्तक को दोहराता है।

यहाँ छवि विवरण दर्ज करें

एक नोट को विशिष्ट रूप से 1) अक्षर से पहचाना जाता है, जिसमें कोई शार्प या फ़्लैट शामिल है, और 2) ऑक्टेव, जो 0 से 8 तक की संख्या है। कीबोर्ड के पहले तीन नोट हैं, A0, A♯/B♭और B0। इसके बाद ऑक्टेव 1 C1, C♯1/D♭1, D1, D♯1/E♭1, E1, F1, F♯1/G♭1, G1, G♯1/A♭1, A1, A♯1/B♭1और पूर्ण क्रोमैटिक स्केल आता है B1। इसके बाद ऑक्टेवस 2, 3, 4, 5, 6, और 7. पर एक पूर्ण क्रोमैटिक स्केल आता है, अंतिम नोट एक है C8।

प्रत्येक नोट 20-4100 हर्ट्ज रेंज में एक आवृत्ति से मेल खाती है। A0लगभग 27.500 हर्ट्ज पर शुरू करने के साथ , प्रत्येक संबंधित नोट दो, या मोटे तौर पर 1.059% 3 की बारहवीं जड़ पिछले नोट है। एक अधिक सामान्य सूत्र है:

यहाँ छवि विवरण दर्ज करें

जहाँ n नोट की संख्या है, A0 के साथ 1. (अधिक जानकारी यहाँ )

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक नोट का प्रतिनिधित्व करने वाले स्ट्रिंग में लेता है, और उस नोट की आवृत्ति को प्रिंट या वापस करता है। हम #तीखे चिन्ह के लिए एक पाउंड चिन्ह (या युवा के लिए हैशटैग) और bसपाट प्रतीक के लिए एक लोअरकेस का उपयोग करेंगे। सभी इनपुट्स (uppercase letter) + (optional sharp or flat) + (number)बिना व्हाट्सएप के दिखेंगे । यदि इनपुट कीबोर्ड की सीमा के बाहर है (A0 से कम, या C8 से अधिक), या अमान्य, अनुपलब्ध या अतिरिक्त वर्ण हैं, तो यह एक अमान्य इनपुट है, और आपको इसे हैंडल करने की आवश्यकता नहीं है। आप यह भी सुरक्षित रूप से मान सकते हैं कि आपको ई #, या सीबी जैसे कोई भी अजीब इनपुट नहीं मिलेगा।

शुद्धता

चूंकि अनंत परिशुद्धता वास्तव में संभव नहीं है, हम कहेंगे कि सच्चे मूल्य के एक प्रतिशत के भीतर कुछ भी स्वीकार्य है। अधिक विस्तार में जाने के बिना, एक प्रतिशत दो के 1200 मूल, या 1.0005777895 है। आइए इसे और अधिक स्पष्ट करने के लिए एक ठोस उदाहरण का उपयोग करें। मान लीजिए कि आपका इनपुट A4 था। सटीक इस नोट के मूल्य 440 हर्ट्ज है। एक बार जब प्रतिशत फ्लैट है 440 / 1.0005777895 = 439.7459। एक बार तेज होने के कारण 440 * 1.0005777895 = 440.2542, 439.7459 से अधिक लेकिन 440.2542 से छोटा कोई भी संख्या गिनती के लिए सटीक है।

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

A0  --> 27.500
C4  --> 261.626
F#3 --> 184.997
Bb6 --> 1864.66
A#6 --> 1864.66
A4  --> 440
D9  --> Too high, invalid input.
G0  --> Too low, invalid input.
Fb5 --> Invalid input.
E   --> Missing octave, invalid input
b2  --> Lowercase, invalid input
H#4 --> H is not a real note, invalid input.

ध्यान रखें कि आपको अमान्य इनपुट को संभालना नहीं है। यदि आपका कार्यक्रम दिखावा करता है कि वे वास्तविक इनपुट हैं और एक मूल्य को प्रिंट करता है, तो यह स्वीकार्य है। यदि आपका प्रोग्राम क्रैश हो जाता है, तो यह भी स्वीकार्य है। एक के मिलने पर कुछ भी हो सकता है। इनपुट और आउटपुट की पूरी सूची के लिए, इस पृष्ठ को देखें

हमेशा की तरह, यह कोड-गोल्फ है, इसलिए मानक कमियां लागू होती हैं, और बाइट्स जीत में सबसे छोटा जवाब होता है।

code-golf  music 
— DJMcMayhem
स्रोत
9
"एच # 4 -> एच असली नोट नहीं है, अमान्य इनपुट है।" यूरोप में छोड़कर।
— लुइ
6
@Lui यूरोप के बारे में यह क्या है जैसे कि पूरा यूरोप उपयोग करता है H? Hअर्थ बी केवल AFAIK है जो जर्मन भाषी देशों में उपयोग किया जाता है (जहां Bबी बी का मतलब है।) क्या ब्रिटिश और आयरिश कॉल बी को स्पेन और इटली में सी या तिवारी कहा जाता है, जैसा कि दो रे मि सोल सोल सी में है।
— लेवल रिवर सेंट
3
मैंने पहले एक वाइला पर B a2 खेला है, यह पूरी तरह से उचित नोट है और बिल्कुल भी अजीब नहीं है।
— नील
3
@steveverrill Hजर्मनी, चेक गणराज्य, स्लोवाकिया, पोलैंड, हंगरी, सर्बिया, डेनमार्क, नॉर्वे, फिनलैंड, एस्टोनिया और ऑस्ट्रिया में विकिपीडिया के अनुसार उपयोग किया जाता है । (मैं स्वयं फिनलैंड के लिए भी इसकी पुष्टि कर सकता हूं।)
— पुरकाकूदरी
6
@ नील यह शायद सिर्फ आकस्मिक था। ;)
— बीकर

जवाबों:

21

जाप, 41 37 35 34 बाइट्स

मैं अंत में ¾अच्छा उपयोग करने का मौका है ! :-)

55*2pU¬®-1¾ª"C#D EF G A B"bZ /C} x

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

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

          // Implicit: U = input string, C = 12
U¨    }  // Take U, split into chars, and map each item Z by this function:
-1¾       //  Subtract 1.75 from Z. This produces NaN for non-digits.
ª"..."bZ  //  If the result is falsy (NaN), instead return the index of Z in this string.
          //  C produces 0, D -> 2, E -> 4, F -> 5, G -> 7, A -> 9, B -> 11.
          //  # -> 1, and b -> -1, so we don't need to calculate them separately.
/C        //  Divide the index by 12.
x         // Sum.
2p        // Take 2 to the power of the result.
55*       // Multiply by 55.

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

सभी वैध परीक्षण मामले ठीक आते हैं। यह अमान्य है जहाँ यह अजीब हो जाता है ...

input --> output       (program's reasoning)
A0  --> 27.5           (Yep, I can do that for you!)
C4  --> 261.625565...  (Yep, I can do that for you!)
F#3 --> 184.997211...  (Yep, I can do that for you!)
Bb6 --> 1864.6550...   (Yep, I can do that for you!)
A#6 --> 1864.6550...   (Yep, I can do that for you!)
A4  --> 440            (Yep, I can do that for you!)
D9  --> 9397.27257...  (Who says that's too high?)
G0  --> 24.49971...    (I've heard that note before.)
Fb5 --> 659.25511...   (Wait, Fb isn't supposed to be a note?)
E   --> 69.295657...   (I'm gonna guess that the missing octave is 1¾.)
b2  --> 61.735412...   (I assume that b means Cb...)
H#4 --> 261.625565...  (H# is C!)
— ETHproductions
स्रोत
13
+ + :) का उपयोग करने के लिए
— अनातोलीग
1
क्या यह वास्तव में 38 बाइट्स नहीं है ?
— पैट्रिक रॉबर्ट्स
@PatrickRoberts यह UTF-8 में 38 बाइट्स है, लेकिन Japt ISO-8859-1 एन्कोडिंग का उपयोग करता है , जिसमें प्रत्येक वर्ण बिल्कुल एक बाइट है।
— ETHproductions
8

पायथ, 46 44 43 42 39 35 बाइट्स

*55^2tsm.xsdc-x"C D EF GbA#B"d9 12z

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

कोड अब ETHproductions के Japt उत्तर के लिए एक समान एल्गोरिथ्म का उपयोग करता है , इसलिए इसके लिए उसे श्रेय दिया जाता है।

व्याख्या

                                            implicit: z = input
       m                          z         for each character in input:
          sd                                  try parsing as number
        .x                                    if that fails:
               "C D EF GbA#B"                   string "C D EF GbA#B"
              x              d                  find index of character in that
             -                9                 subtract 9
            c                   12              divide by 12
      s                                     sum results
     t                                      decrement
   ^2                                       get the correct power of 2
*55                                         multiply by 55 (frequency of A1)

पुराना संस्करण (42 बाइट्स, 39 w / पैक्ड स्ट्रिंग)

*55^2+tsezc+-x"C D EF G A B"hz9-}\#z}\bz12

व्याख्या

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

— PurkkaKoodari
स्रोत
यह दिलचस्प है। पायथ कैसे पैक करता है तार?
— लुइस मेंडो
@LuisMendo आप डॉक्स में उस पर जानकारी पा सकते हैं । मूल रूप से, यह डेटा को परिवर्तित करने के लिए सबसे छोटा आधार ढूंढता है और फिर परिणाम को आधार 256 में एन्कोड करता है।
— पुरकाकूदरी
7

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

2^((Import[".mid"~Export~Sound@SoundNote@#,"RawData"][[1,3,3,1]]-69)/12)440.&

स्पष्टीकरण :

इस फ़ंक्शन का मुख्य विचार नोट के तार को अपने रिश्तेदार पिच में बदलना है, और फिर इसकी आवृत्ति की गणना करना है।

मैं जिस विधि का उपयोग करता हूं वह ध्वनि को मिडी पर निर्यात करता है और कच्चे डेटा को आयात करता है, लेकिन मुझे संदेह है कि अधिक सुरुचिपूर्ण तरीका है।

परीक्षण के मामले :

f=%; (* assign the function above to f *)
f["A4"]    (* 440.    *)
f["A5"]    (* 880.    *)
f["C#-1"]  (* 8.66196 *)
f["Fb4"]   (* 329.628 *)
f["E4"]    (* 329.628 *)
f["E"]     (* 329.628 *)
— njpipeorgan
स्रोत
2
आमतौर पर मैं गणितज्ञ बिल्डिंस को देखकर दुखी होता हूं जो तुच्छ रूप से समस्याओं को हल करते हैं, लेकिन यह वास्तव में इसे करने के लिए एक बहुत प्रेरित तरीका है।
— राबर्ट फ्रेजर
4

MATL , 56 53 50 49 48 बाइट्स

Hj1)'C D EF G A B'=f22-'#b'"G@m]-s+ 12/G0)U+^55*

वर्तमान रिलीज़ (10.1.0) का उपयोग करता है , जो इस चुनौती से पहले है।

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

व्याख्या

H                   % push 2
j1)                 % get input string. Take first character (note)
'C D EF G A B'=f    % find index of note: 1 for C, 3 for D...
22-                 % subtract 22. This number comes from three parts:
                    % 9; 1 for 0-based indexing; 12 to subtract 1 octave
'#b'"G@m]-s         % For loop. Gives 1 if input contains '#', -1 if 'b', 0 otherwise
+                   % add to previous number. Space needed to separate from next literal
12/                 % divide by 12
G0)                 % push input and get last character (octave)
U+                  % convert to number and add to previous number
^                   % raise 2 (that was initially pushed) to accumulated number 
55*                 % multiply by 55 (=27.5*2). Implicitly display
— लुइस मेंडो
स्रोत
3

जावास्क्रिप्ट ईएस 7, 73 70 69 बाइट्स

x=>[...x].map(c=>t+=c-1.75||"C#D EF G A B".search(c)/12,t=0)&&2**t*55

उसी तकनीक का उपयोग करता है जैसे मेरा जाप उत्तर ।

— ETHproductions
स्रोत
3

रूबी, ६ ९ ६५

->n{2**((n.ord*13/8%12-n.size+(n=~/#/?7:5))/12.0+n[-1].to_i)*55/4}

परीक्षण कार्यक्रम में अपराजित

f=->n{
  2**(                    #raise 2 to the power of the following expression:
   (
     n.ord*13/8%12-       #note name C..B maps to number 0..11 calculated from the ascii code of n[0] 
     n.size+(n=~/#/?7:5)  #Correction for flat: length of n is 1 more for flat (or sharp) than for natural. Then apply correction for sharp
                          #now we have a number 3..14 for C..B (so 12 for A, will be a whole number when divided)
   )/12.0+                #divide by 12 to convert into a fraction of an octave

  n[-1].to_i              #add the octave number, last character in n
  )*                      #end of power expression, now we have A0=2,A1=4,A2=4 etc

  55/4                    #multiply to get correct frequency, this is shorter than 13.75 or 440/32                      
}

#complete octave test case
puts %w{A0 A#0 Bb0 B0 C1 C#1 Db1 D1 D#1 Eb1 E1 F1 F#1 Gb1 G1 G#1 Ab1 A1 A#1}.map{|e|[e,f[e]]}

#test case per OP
puts %w{A0 C4 F#3 Bb6 A#6}.map{|e|[e,f[e]]}

उत्पादन

A0
27.5
A#0
29.13523509488062
Bb0
29.13523509488062
B0
30.867706328507758
C1
32.70319566257483
C#1
34.64782887210901
Db1
34.64782887210901
D1
36.70809598967595
D#1
38.890872965260115
Eb1
38.890872965260115
E1
41.20344461410875
F1
43.653528929125486
F#1
46.2493028389543
Gb1
46.2493028389543
G1
48.999429497718666
G#1
51.91308719749314
Ab1
51.91308719749314
A1
55.0
A#1
58.27047018976123
A0
27.5
C4
261.6255653005986
F#3
184.9972113558172
Bb6
1864.6550460723593
A#6
1864.6550460723593
— स्तर नदी सेंट
स्रोत
2

ईएस 7, 82 बाइट्स

s=>55*2**(+s.slice(-1)+("C D EF G A B".search(s[0])+(s[1]<'0')-(s[1]>'9')-21)/12)

उम्मीद के मुताबिक "बी # 2" के इनपुट पर 130.8127826502993 रिटर्न।

संपादित करें: @ उपयोगकर्ता81655 के लिए 3 बाइट्स का धन्यवाद सहेजा गया।

— नील
स्रोत
@ user81655 2*3**3*2फ़ायरफ़ॉक्स के ब्राउज़र कंसोल में 108 है, जो इससे सहमत है 2*(3**3)*2। यह भी ध्यान दें कि वह पृष्ठ यह भी कहता है कि ?:उसकी तुलना में उच्च पूर्वता है =लेकिन उनके पास वास्तव में समान पूर्वता (विचार a=b?c=d:e=f) है।
— नील
आह अच्छा। मेरा फ़ायरफ़ॉक्स ऐसा नहीं है **कि मैं कभी भी इसका परीक्षण नहीं कर पाया। मुझे लगता ?:है कि =हालांकि इसकी तुलना में एक उच्च पूर्वता है क्योंकि आपके उदाहरण aमें टर्नरी के परिणाम पर सेट किया गया है, बजाय इसके bबाद, फिर टर्नरी को निष्पादित करना। अन्य दो असाइनमेंट टर्नरी में संलग्न हैं, इसलिए वे एक विशेष मामला है।
— user81655
@ user81655 e=fटर्नरी के अंदर कैसे है ?
— नील
विचार करें a=b?c=d:e=f?g:h। यदि वे एक ही मिसाल थे और पहली टर्नरी बाद में समाप्त हो =गई e, तो यह एक अमान्य बाएं हाथ के असाइनमेंट में त्रुटि का कारण होगा।
— user81655
@ user81655 लेकिन यह भी एक समस्या होगी अगर ?:किसी =भी तरह से अधिक पूर्वता थी । अभिव्यक्ति को समूह की जरूरत है जैसे कि वह था a=(b?c=d:(e=(f?g:h)))। आप ऐसा नहीं कर सकते हैं यदि उनके पास एक ही पूर्वता नहीं है।
— नील
2

सी, 123 बाइट्स

float d(char*s){int n=*s++,m=(n*12+(n<67?90:6))/7,o=*s++,a=o^35?o^98?0:-1:1;return exp((m+(a?*s++:o)*12+a)/17.3123-37.12);}

उपयोग:

#include <stdio.h>
#include <math.h>

float d(char*s){int n=*s++,m=(n*12+(n<67?90:6))/7,o=*s++,a=o^35?o^98?0:-1:1;return exp((m+(a?*s++:o)*12+a)/17.3123-37.12);}

int main()
{
    printf("%f\n", d("A4"));
}

गणना की गई मान हमेशा सटीक मान से लगभग 0.8 सेंटीमीटर कम होती है, क्योंकि मैं फ्लोटिंग-पॉइंट संख्याओं से अधिक से अधिक अंक काटता हूं।

कोड का अवलोकन:

float d(char*s){
    int n=*s++,        // read the letter
        m=(n*12+       // multiply by 12/7 to convert from A...G to 0...11
        (n<67?90:6)    // if A or B, add 1 octave; also add some fix-up rounding value
        )/7,

        o=*s++,        // read next char: the octave digit or accidental

        a=o^35?o^98?0:-1:1; // if accidental, convert it into +1 or -1; else 0

        return exp((m+ // I adjusted the factors to use exp instead of pow
            (a?*s++:o) // if was accidental, now read the octave digit
            *12+a)/
            17.3123-   // a more exact value is 17.3123404447
            37.12);    // a more exact value is 37.1193996632
}
— anatolyg
स्रोत
1

आर, 157 150 141 136 बाइट्स

f=function(x){y=strsplit(x,"")[[1]];55*2^(as.double(y[nchar(x)])-1+(c(10,12,1,3,5,6,8)[LETTERS==y[1]]-switch(y[2],"#"=9,"b"=11,10))/12)}

इंडेंट और न्यूलाइन्स के साथ:

f=function(x){
     y=strsplit(x,"")[[1]]
     55 * 2^(as.double(y[nchar(x)]) - 1 + 
         (c(10,12,1,3,5,6,8)[LETTERS==y[1]] - 
         switch(y[2],"#"=9,"b"=11,10))/12)
     }

उपयोग:

> f("A0")
[1] 27.5
> f("C8")
[1] 4186.009
> sapply(c("C4","Bb6","A#6","A4"),f)
       C4       Bb6       A#6        A4 
 261.6256 1864.6550 1864.6550  440.0000
— plannapus
स्रोत
1

पायथन, 97 95 बाइट्स

def f(n):a,*b,c=n;return 2**(int(c)+('C@D@EF@G@A@B'.find(a)-(21,(22,20)['#'in b])[b>[]])/12)*55

Pietu1998 (और अन्य ') के आधार पर 'C@D@EF@G@A@B'कुछ रिक्त चार या अन्य के लिए स्ट्रिंग में नोट के सूचकांक की तलाश के पुराने दृष्टिकोण । मैं बिना शर्त के नोट स्ट्रिंग को पार्स करने के लिए चलने योग्य अनपैकिंग का उपयोग करता हूं। मैंने रूपांतरण अभिव्यक्ति को सरल बनाने के लिए अंत में थोड़ा बीजगणित किया। पता नहीं अगर मैं अपना दृष्टिकोण बदले बिना इसे छोटा कर सकता हूं।

— Ogaday
स्रोत
1
मुझे लगता है कि b==['#']छोटा किया जा सकता है '#'in b, और not bकरने के लिए b>[]।
— ज़गारब
अच्छा अंक! मेरे परीक्षण सूट के लिए काम करता है, धन्यवाद। मुझे लगता है कि मैं पायथन में निष्पक्ष रूप से सशर्त गोल्फ में सुधार कर सकता हूं, धन्यवाद।
— ओगडेय
1

वोल्फ्राम भाषा (गणितज्ञ), 69 बाइट्स

ToExpression@("Music`"<>StringReplace[#,{"b"->"flat","#"->"sharp"}])&

संगीत पैकेज का उपयोग करना , जिसके साथ एक अभिव्यक्ति के रूप में केवल एक नोट दर्ज करना इसकी आवृत्ति का मूल्यांकन करता है, जैसे:

 In[1]:= Eflat3
Out[1]:= 155.563

पैकेज को आयात करने से बचने के लिए बाइट्स बचाने के लिए <<Music, मैं पूरी तरह से योग्य नामों का उपयोग कर रहा हूं Music`Eflat3:। हालांकि, मुझे अभी भी प्रश्न के इनपुट प्रारूप के bसाथ flatऔर उसके #साथ प्रतिस्थापित करना होगा sharp, जो मैं एक सरल के साथ करता हूं StringReplace।

— vasilescur
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.