संगीत अंतराल सॉल्वर

Question

संगीत सिद्धांत में, एक अंतराल दो पिचों के बीच का अंतर है। प्रत्येक पिच को आधे चरणों की संख्या (सी और सी # के बीच का अंतर) या पूरे चरणों (सी और डी के बीच का अंतर) द्वारा परिभाषित किया गया है। एक पूरा चरण दो आधे चरणों के समान है। यहां सभी डिफ़ॉल्ट अंतरालों और उनके द्वारा प्रतिनिधित्व किए जाने वाले आधे चरणों की एक सूची दी गई है:

0     Perfect Unison
2     Major Second
4     Major Third
5     Perfect Fourth
7     Perfect Fifth
9     Major Sixth
11    Major Seventh
12    Perfect Octave

डिफ़ॉल्ट अंतराल पर 3 भिन्नताएं हैं, मामूली , कम , और संवर्धित ।

• एक मामूली अंतराल एक प्रमुख अंतराल से एक आधा कदम कम है, लेकिन एक सही अंतराल नहीं है। तो आपके पास एक छोटा दूसरा (1), एक मामूली तीसरा (3), एक मामूली छठा (8), और एक छोटा सातवां (10) है। इसमें कोई मामूली चौथी, छोटी पाँचवीं, छोटी जेल या मामूली सप्तक जैसी कोई बात नहीं है क्योंकि ये सभी पूर्ण अंतराल हैं।

• एक छोटा या पूर्ण अंतराल की तुलना में एक कम अंतराल एक आधा कदम कम है । घटता हुआ दूसरा (0), घटा हुआ तीसरा (2), घटा हुआ चौथा (4), घटा हुआ पाँचवाँ (6), घटा हुआ छठा (7), घटा हुआ सातवाँ (9) और घटा हुआ सप्तक (11)।

• एक संवर्धित अंतराल एक प्रमुख या पूर्ण अंतराल की तुलना में एक आधा कदम अधिक है। हमारे पास ऑगमेंटेड यूनिसन (1), ऑगमेंटेड सेकंड (3), ऑगमेंटेड थर्ड (5), ऑगमेंटेड फोर्थ (6), ऑगमेंटेड पांचवां, (8), ऑगमेंटेड सिक्स्थ (10) और ऑगमेंटेड सेन्थ (12) हैं।

चुनौती:

आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो कई आधे चरण या पूरे चरण लेता है और फिर इस अंतराल के मान्य अंग्रेजी विवरणों में से एक को प्रिंट करता है । इससे कोई फर्क नहीं पड़ता कि आप कौन सा विवरण चुनते हैं, जब तक कि यह आईओ तालिका से पूरी तरह मेल नहीं खाता। आप इसे एक स्ट्रिंग के रूप में ले सकते हैं

"5w" == 5 whole steps
"3h" == 3 half steps

या एक संख्या और एक स्ट्रिंग / चार के रूप में।

5, "w" == 5 whole steps
3, "h" == 3 half steps.

आप मान सकते हैं कि हर इनपुट 0 और 12 आधे चरणों के बीच होगा।

IO तालिका

यहां सभी स्वीकार्य आउटपुट के लिए आधे-चरणों की संख्या की मैपिंग एक पूरी सूची है।

0       Perfect unison, Diminished second   
1       Minor second, Augmented unison  
2       Major second, Diminished third  
3       Minor third, Augmented second   
4       Major third, Diminished fourth  
5       Perfect fourth, Augmented third     
6       Diminished fifth, Augmented fourth  
7       Perfect fifth, Diminished sixth 
8       Minor sixth, Augmented fifth        
9       Major sixth, Diminished seventh 
10      Minor seventh, Augmented sixth      
11      Major seventh, Diminished octave    
12      Perfect octave, Augmented seventh   

यहाँ कुछ नमूना I / O है:

5w      Minor Seventh
5h      Augmented Third
12h     Perfect Octave
12w     UNDEFINED
1w      Diminished third
2h      Major Second

Comments

परिमाण ? ....

— कैलक्यूलेटरफैनलाइन

@CatsAreFluffy मेरी खराब वर्तनी ने अच्छी चुनौतियों को लिखने की मेरी क्षमता को कम कर दिया है। ಠ_

— जेम्स

अभी भी एक अच्छी चुनौती है, और अधिक संपादन के साथ! : P

— R

Answer 1

रूबी, रेव बी 138 बाइट्स

->n,s{i=12-n-n*(s<=>?h)
[a='Augmented','Major','Minor',d='Diminished',a,'Perfect',d][i%7]+' '+%w{seventh fifth third unison}[i%7/4+i/7*2]}

न दोहराने से 5 बाइट बचीं Augmented/Diminished। के उपयोग से 1 बाइट बची ?h।

रूबी, रेव ए 144 बाइट्स

->n,s{i=12-n-n*(s<=>'h')
%w{Augmented Major Minor Diminished Augmented Perfect Diminished}[i%7]+' '+%w{seventh fifth third unison}[i%7/4+i/7*2]}

यह विचार बुनियादी अंतराल (केवल सातवीं पाँचवीं तीसरी और केवल एकजुट) की संख्या को कम करना है और इस तथ्य का लाभ उठाना है कि सातवें और पांचवें का तिहाई और जेलों के बीच एक समान संबंध है।

चार प्रकार के सातवें / तीसरे और 3 प्रकार के पांचवें / एकसमान हैं इसलिए सूचकांक चर iको आधे चरण की संख्या के 12 शून्य पर सेट किया जाता है, ताकि अभिव्यक्ति का पहला शब्द i%7/4 + i/7*2सही ढंग से बुनियादी अंतराल के प्रकार का चयन करेगा।

परीक्षण कार्यक्रम में अपुष्ट

f=->n,s{                 #n = number of steps. s= step size, w or h
  i=12-n-n*(s<=>'h')     # i=12-n. If s is later in the alphabet than 'h' subtract again for whole steps
  %w{Augmented Major Minor Diminished Augmented Perfect Diminished}[i%7]+
  ' '+%w{seventh fifth third unison}[i%7/4+i/7*2]
}

-1.upto(12){|j|
puts f[j,'h']
}  

0.upto(6){|j|
puts f[j,'w']
}

उत्पादन

Diminished unison
Perfect unison
Augmented unison
Diminished third
Minor third
Major third
Augmented third
Diminished fifth
Perfect fifth
Augmented fifth
Diminished seventh
Minor seventh
Major seventh
Augmented seventh

Perfect unison
Diminished third
Major third
Diminished fifth
Augmented fifth
Minor seventh
Augmented seventh

अपरिभाषित व्यवहार इनपुट्स: फ़ंक्शन diminished union-1 हाफस्टेप के लिए सही उत्तर देता है , लेकिन 12 से अधिक इनपुट के लिए विफल रहता है। उदाहरण के लिए, यह perfect unison14 आधे चरणों के लिए आउटपुट करता है, क्योंकि एल्गोरिथ्म 12 के बजाय 14 के चक्र पर आधारित है।

Answer 2

पायथन 2, 149 बाइट्स

def f(n,c):n*=1+(c>'h');print(n-6)%13%2*"Diminished"or"Augmented",'octave seventh sixth fifth fourth third second unison'.split()[71056674174>>3*n&7]

सबसे पहले, पूरे चरणों को आधा चरणों में बदल दिया जाता है।

फिर, Diminishedबनाम Augmentedमुद्रित किया जाता है। nइसके अलावा आसन्न के लिए ये वैकल्पिक n=5और n=6वही देते हैं, जो पहले एक सीमा modulo एक विषम संख्या में उन्हें डालकर प्राप्त किया जाता है।

अंत में, दूरी को मुद्रित किया जाता है, तीन-बिट लुकअप तालिका के माध्यम से गणना की जाती है। यह करने से छोटा है int('6746543230210'[n])।

Answer 3

पायथन 2.7, 155 बाइट्स

s='second unison third fourth sixth fifth seventh octave Diminished Augmented'.split()
def f(n,c):x=0xDE9CB87561430>>[4,8][c>'h']*n;print s[x%2+8],s[x/2%8]

Answer 4

रेटिना, 153 बाइट्स

\ D +
$ *
डब्ल्यू (*।) | ज
$ 1 $ 1
^ 1 * $
$ .0
^ [02,479] | 11
$ कम हो गया
^ \ घ
संवर्धित $ 0
10 | 7
छठा
1 1
सप्टक
12 | 9
सातवाँ
8
पांचवां
4 | 6
चौथा
5 | 2
तीसरा
1
सामंजस्य
\ घ
दूसरा

इनपुट नंबर को पहले यूनीरी में बदल दिया जाता है, उसके बाद यदि दोगुना किया जाता है wऔर किसी अक्षर को हटा दिया जाता है, तो केवल एकरी नंबर छोड़ दिया जाता है। यह संख्या फिर दशमलव में बदल जाती है। अंत में, अंतिम आउटपुट के निर्माण के लिए कुछ खोज और प्रतिस्थापित किया जाता है।

उदाहरण चलता है:

6w => 111111w => 111111111111 => 12 => संवर्धित 12 => संवर्धित सातवाँ
7h => 1111111h => 1111111 => 7 => घटा 7 => घटा छठा
3w => 111w => 111111 => 6 => संवर्धित 6 => संवर्धित चौथा
0h => h => => 0 => कम 0 => कम दूसरा

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

Answer 5

विटसी , 166 बाइट्स

खैर, यह निश्चित रूप से आगे गोल्फ हो सकता है।

WW2M1+*a+mZ
'dehsinimiD'
'roniM'
'rojaM'
'tcefreP'
'detnemguA'
'dnoces '
'htruof '
'htxis '
'evatco '
6m1m
6m2m
6m3m
6m5m
7m1m
7m4m
7m5m
8m1m
8m2m
8m3m
8m5m
9m1m
9m4m

यह संभव वस्तुओं की न्यूनतम मात्रा को परिभाषित करके काम करता है, फिर उन वस्तुओं को विधि सिंटैक्स के माध्यम से बुलाता है।

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

Answer 6

जावास्क्रिप्ट 189 बाइट्स

a=>(n='sutsftfxFvxov'[N=parseInt(a)*(a.slice(-1)>'v'?2:1)])&&((N>5?N+1:N)%2?'Augmented ':'Dimished ')+'unison,second,third,fourth,fifth,sixth,seventh,octave'.split`,`['ustfFxvo'.indexOf(n)]



 F=
  a=>
    (n='sutsftfxFvxov' //using the right side of the possible answers
                       //set n = the letter representing
                       //unison, first, second ...

       //set N to 12 for 12h, but 24 for 12w
       [N=parseInt(a)*(a.slice(-1)>'v'?2:1)])

  &&   //if we were out of range (12w) we'll return undefined


    (
      (N>5?N+1:N)%2?  //get Aug or Dim (right side goes)
                      //DADADAADADADA
                      //     ^^ makes this a pain
       'Augmented ':'Dimished '
     )
     +
            //turn n (which is u for unison, x for sixth, etc
            //into it's full name
       'unison,second,third,fourth,fifth,sixth,seventh,octave'
         .split`,`
     ['ustfFxvo'.indexOf(a)]

Answer 7

जावा, 225 224 बाइट्स

इन तारों को पैक करने का एक बेहतर तरीका है, लेकिन मेरे पास कोई विचार नहीं है।

(i,s)->{String A="Augmented",M="Major",m="Minor",P="Perfect",D="Diminished",d=" Second",f=" Fourth",a=" Sixth",C=" Octave";String[]o=new String[]{D+d,m+d,M+d,A+d,P+f,A+f,D+a,m+a,M+a,A+a,D+C,P+C};i*=s=='w'?2:1;return o[i-1];}

इंडेंट:

static BiFunction<Integer, Character, String> interval = (i,s) -> {
    String A="Augmented",M="Major",m="Minor",P="Perfect",D="Diminished",
            d=" Second",f=" Fourth",a=" Sixth",C=" Octave";
    String[] o = new String[] {D+d,m+d,M+d,A+d,P+f,A+f,D+a,m+a,M+a,A+a,D+C,P+C};
    i *= s=='w' ? 2 : 1;
    return o[i-1];
};

Comments

मेरा मानना है कि आप को बदल कर इसे छोटा कर सकते हैं if(s=='w')i*=2;के साथi*=s=='w'?2:1;

— श्री लोक

@Mrublic आप सही हैं।

— CAD97