क्या यह मेजर स्केल (या समकक्ष) है?

Question

^{सैंडबॉक्स}

प्रमुख पैमाने (या आयोनियन स्केल) विशेष रूप से पश्चिमी संगीत में सबसे अधिक उपयोग किए जाने वाले संगीत पैमानों में से एक है। यह डायटोनिक तराजू में से एक है। कई संगीत तराजू की तरह, यह सात नोटों से बना होता है: आठवां सबसे पहले इसकी आवृत्ति को दोगुना कर देता है ताकि इसे उसी नोट का उच्च ऑक्टेव कहा जाए।

सात संगीत नोट हैं:

सी, डी, ई, एफ, जी, ए, बी , सी (उदाहरण के प्रयोजनों के लिए दोहराया)

एक प्रमुख पैमाना एक डायटोनिक पैमाना है। नोटों के पिछले उत्तराधिकार को एक बड़े पैमाने के रूप में लें (वास्तव में, यह पैमाना है सी मेजर) । एक बड़े पैमाने के नोटों के बीच अंतराल का क्रम है:

पूरा, पूरा, आधा, पूरा, पूरा, आधा

जहां "संपूर्ण" पूरे टोन (आकृति में लाल यू-आकार का वक्र) के लिए खड़ा है, और "आधा" एक अर्धविराम (आकृति में लाल टूटी हुई रेखा) के लिए खड़ा है।

इस मामले में, C से D तक एक संपूर्ण टोन मौजूद है , D से E एक संपूर्ण टोन मौजूद है , E से F तक आधा टोन मौजूद है , आदि ...

हमारे पास 2 घटक हैं जो नोटों के बीच की टोन दूरी को प्रभावित करते हैं। ये शार्प सिंबल (() और फ्लैट सिंबल (।) हैं।

तीव्र प्रतीक (Sharp) नोट में आधा स्वर जोड़ता है। उदाहरण। C से D तक हमने उल्लेख किया है कि एक संपूर्ण टोन मौजूद है, यदि हम C के बजाय C का उपयोग करते हैं तो C D से D तक आधा टोन मौजूद है।

सपाट प्रतीक (Flat) तीव्र प्रतीक के विपरीत होता है, यह नोट से आधे स्वर को घटाता है। उदाहरण: D से E तक हमने उल्लेख किया है कि एक संपूर्ण टोन मौजूद है, यदि हम D के बजाय D का उपयोग करते हैं तो D से E तक का टोन और आधा मौजूद है।

डिफ़ॉल्ट रूप से, नोट से नोट तक के लिए E to Fऔर B to Cजहां सिर्फ आधा टोन मौजूद है, को छोड़कर एक संपूर्ण टोन मौजूद है।

कुछ मामलों में नोट एनार्मोनिक पिचों का उपयोग करके एक मेजर स्केल के बराबर बनाया जा सकता है। इसका एक उदाहरण यह है C#, D#, E#, F#, G#, A#, B#, C#कि कहाँ E#और B#धार्मिक हैं लेकिन पैमाने एक मेजर स्केल के अनुक्रम का अनुसरण करते हैं।

---

चुनौती

एक पैमाने को देखते हुए, एक सत्य मूल्य का उत्पादन करें यदि यह एक मेजर स्केल या समकक्ष है, अन्यथा एक गलत मूल्य का उत्पादन करता है।

नियम

• मानक I / O विधि की अनुमति है
• मानक कोड-गोल्फ नियम लागू होते हैं
• आपको 8 वें नोट पर ध्यान देने की आवश्यकता नहीं है। मान लें कि इनपुट में केवल 7 नोट शामिल होंगे
• मान लें कि डबल फ्लैट (♭♭), डबल शार्प (♭♭) या नेचुरल साइन (don't) मौजूद नहीं है

---

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

C, D, E, F, G, A, B                 => true
C#, D#, E#, F#, G#, A#, B#          => true
Db, Eb, F, Gb, Ab, Bb, C            => true
D, E, Gb, G, A, Cb, C#              => true
Eb, E#, G, G#, Bb, B#, D            => true
-----------------------------------------------
C, D#, E, F, G, A, B                => false
Db, Eb, F, Gb, Ab, B, C             => false
G#, E, F, A, B, D#, C               => false 
C#, C#, E#, F#, G#, A#, B#          => false
Eb, E#, Gb, G#, Bb, B#, D           => false

Comments

@Abigail मूल रूप से हाँ। उनके पास एक ही स्वर है हालांकि वे अलग-अलग नोट हैं।

— लुइस फेलिप डी जेउस मुनोज़

और Cx (या C ##) = D

— SaggingRufus

Btw, पेंटाटोनिक तराजू में प्रत्येक अक्षर में से एक नहीं है: v

— लुइस फेलिप डी जेउस मुनोज़

@ नील क्रोमैटिक तराजू में अनूठे अक्षर नहीं होते हैं और मुझे यकीन है कि एक प्रकार का पैमाना है जो एक आरोही क्रम का अनुसरण नहीं करता है

— लुइस फेलिप डी जेउस मुनोज़

मैं इसे अपवित्र करने जा रहा हूं क्योंकि @ नील ने इसे बहुत धन्यवाद दिया है

— डेविड कॉनरेड

Answer 1

पर्ल 6 , 76 65 63 59 बाइट्स

फिल ब H को -4 बाइट्स धन्यवाद

{221222==[~] (.skip Z-$_)X%12}o*>>.&{13*.ord+>3+?/\#/-?/b/}

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

व्याख्या

*>>.&{ ... }  # Map notes to integers
  13*.ord     # 13 * ASCII code:  A=845 B=858 C=871 D=884 E=897 F=910 G=923
  +>3         # Right shift by 3: A=105 B=107 C=108 D=110 E=112 F=113 G=115
              # Subtracting 105 would yield A=0 B=2 C=3 D=5 E=7 F=8 G=10
              # but isn't necessary because we only need differences
  +?/\#/      # Add 1 for '#'
  -?/b/       # Subtract 1 for 'b'

{                           }o  # Compose with block
            (.skip Z-$_)        # Pairwise difference
                        X%12    # modulo 12
         [~]  # Join
 221222==     # Equals 221222

Comments

यदि आप एक जोड़ी अंतर और 12 modulo करने जा रहे हैं, तो आपको 105 को घटाने की आवश्यकता नहीं है; यह सिर्फ एक ऑफसेट है। -4 चरस

— फिल एच

@PhilH हां, बिल्कुल। धन्यवाद!

— nwellnhof

यह मेरे सापेक्ष मूल्यों को नोट करने का एक बहुत ही चतुर तरीका है, +1 मुझसे!

— सोक

Answer 2

Node.js v10.9.0 , 78 76 71 69 बाइट्स

a=>!a.some(n=>(a-(a=~([x,y]=Buffer(n),x/.6)-~y%61)+48)%12-2+!i--,i=3)

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

कैसे?

प्रत्येक नोट $n$ को $[-118,-71]$ में एक ऋणात्मक संख्या में बदल दिया जाता है :

[x, y] = Buffer(n) // split n into two ASCII codes x and y
~(x / .6)          // base value, using the ASCII code of the 1st character
- ~y % 61          // +36 if the 2nd character is a '#' (ASCII code 35)
                   // +38 if the 2nd character is a 'b' (ASCII code 98)
                   // +1  if the 2nd character is undefined

जो देता है:

  n   | x  | x / 0.6 | ~(x / 0.6) | -~y % 61 | sum
------+----+---------+------------+----------+------
 "Ab" | 65 | 108.333 |    -109    |    38    |  -71
 "A"  | 65 | 108.333 |    -109    |     1    | -108
 "A#" | 65 | 108.333 |    -109    |    36    |  -73
 "Bb" | 66 | 110.000 |    -111    |    38    |  -73
 "B"  | 66 | 110.000 |    -111    |     1    | -110
 "B#" | 66 | 110.000 |    -111    |    36    |  -75
 "Cb" | 67 | 111.667 |    -112    |    38    |  -74
 "C"  | 67 | 111.667 |    -112    |     1    | -111
 "C#" | 67 | 111.667 |    -112    |    36    |  -76
 "Db" | 68 | 113.333 |    -114    |    38    |  -76
 "D"  | 68 | 113.333 |    -114    |     1    | -113
 "D#" | 68 | 113.333 |    -114    |    36    |  -78
 "Eb" | 69 | 115.000 |    -116    |    38    |  -78
 "E"  | 69 | 115.000 |    -116    |     1    | -115
 "E#" | 69 | 115.000 |    -116    |    36    |  -80
 "Fb" | 70 | 116.667 |    -117    |    38    |  -79
 "F"  | 70 | 116.667 |    -117    |     1    | -116
 "F#" | 70 | 116.667 |    -117    |    36    |  -81
 "Gb" | 71 | 118.333 |    -119    |    38    |  -81
 "G"  | 71 | 118.333 |    -119    |     1    | -118
 "G#" | 71 | 118.333 |    -119    |    36    |  -83

हम इन मूल्यों के बीच युग्मक अंतर modulo $12$ गणना करते हैं।

2 नोटों के बीच सबसे कम संभव अंतर है $-47$ , इसलिए यह सुनिश्चित करने के लिए मॉडुलो को लागू करने से पहले $4\times12=48$ जोड़ना पर्याप्त है ताकि हमें एक सकारात्मक परिणाम मिल सके।

$12$'#'$36 \bmod 12 = 0$'b'$38 \bmod 12 = 2$

$a$$\text{NaN}$

$[ \text{NaN}, 2, 2, 1, 2, 2, 2 ]$

$i$$1$$2$

Comments

महान दृष्टिकोण, मेरे उत्तर की तुलना में बहुत अधिक दिलचस्प

— स्किड्सदेव

Answer 3

जावास्क्रिप्ट (Node.js) , 150 131 125 बाइट्स

l=>(l=l.map(x=>'C0D0EF0G0A0B'.search(x[0])+(x[1]=='#'|-(x[1]=='b')))).slice(1).map((n,i)=>(b=n-l[i])<0?2:b)+""=='2,2,1,2,2,2'

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

-19 बाइट्स लुइस फेलिप -6 बाइट्स की बदौलत
शैगी को धन्यवाद

Ungolfed:

function isMajor(l) {
    // Get tone index of each entry
    let array = l.map(function (x) {
        // Use this to get indices of each note, using 0s as spacers for sharp keys
        let tones = 'C0D0EF0G0A0B';
        // Get the index of the letter component. EG D = 2, F = 5
        let tone = tones.search(x[0]);
        // Add 1 semitone if note is sharp
        // Use bool to number coercion to make this shorter
        tone += x[1] == '#' | -(x[1]=='b');
    });
    // Calculate deltas
    let deltas = array.slice(1).map(function (n,i) {
        // If delta is negative, replace it with 2
        // This accounts for octaves
        if (n - array[i] < 0) return 2;
        // Otherwise return the delta
        return n - array[i];
    });
    // Pseudo array-comparison
    return deltas+"" == '2,2,1,2,2,2';
}

Comments

[...'C0D0EF0G0A0B']इसके बजाय 'C0D0EF0G0A0B'.split('')और कुछ बाइट्स को बचाने के +""बजाय.toString()

— लुइस फेलिप डी जेउस मुनोज

x[1]=='#'|-(x[1]=='b')इसके बजाय x[1]=='#'?1:(x[1]=='b'?-1:0)कुछ बाइट्स बचाने के लिए

— लुइस फेलिप डी जेउस मुनोज

@LuisfelipeDejesusMunoz ओह अच्छा धन्यवाद! मुझे विश्वास नहीं हो रहा है कि मैं सरणी विस्तार के बारे में भूल गया और एक खाली स्ट्रिंग जोड़ रहा हूं

— Skidsdev

"यदि डेल्टा नकारात्मक है, तो इसे 2 से बदलें" गलत लगता है। मुझे लगता है कि आपको अंतर modulo 12.

— nwellnhof

@nwellnhof मेरे परीक्षणों में, सभी प्रमुख पैमानों के साथ शुरू करने के लिए या तो सही डेल्टा थे, या, अगर वे एक सप्तक को फैलाते हैं, तो एक डेल्टा था -10 के बजाय 2. नकारात्मक डेल्टा फिक्स को प्रतिस्थापित करता है। मुझे नहीं लगता -10 % 12 == 2। हालांकि यह सोचने के लिए आया है कि यह कुछ मामलों में विफल हो सकता है ...

— स्किड्सदेव

Answer 4

डार्ट , 198 197 196 189 बाइट्स

f(l){var i=0,j='',k,n=l.map((m){k=m.runes.first*2-130;k-=k>3?k>9?2:1:0;return m.length<2?k:m[1]=='#'?k+1:m[1]=='b'?k-1:k;}).toList();for(;++i<7;j+='${(n[i]-n[i-1])%12}');return'221222'==j;}

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

पुराने पर्ल का ढीला पोर्ट 6 उत्तर /codegolf//a/175522/64722

f(l){
  var i=0,j='',k,
  n=l.map((m){
    k=m.runes.first*2-130;
    k-=k>3?k>9?2:1:0;
    return m.length<2?k:m[1]=='#'?k+1:m[1]=='b'?k-1:k;
  }).toList();
  for(;++i<7;j+='${(n[i]-n[i-1])%12}');
  return'221222'==j;
}

• # / B के लिए टर्नरी ऑपरेटरों का उपयोग करके -1 बाइट
• स्केल शिफ्ट के लिए टर्नरीज़ के बजाय इफ़ेट्स का उपयोग करके -1 बाइट
• -7 बाइट्स के लिए धन्यवाद @ केविन क्रूज़सेन

---

पुराना संस्करण :

डार्ट , 210 बाइट्स

f(l){var i=0,k=0,n={'C':0,'D':2,'E':4,'F':5,'G':7,'A':9,'B':11,'b':-1,'#':1},j='',y=[0,0];for(;++i<7;j+='${(y[0]-y[1])%12}')for(k=0;k<2;k++)y[k]=n[l[i-k][0]]+(l[i-k].length>1?n[l[i-k][1]]:0);return'221222'==j;}

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

Ungolfed:

f(l){
  var i=0,k=0,n={'C':0,'D':2,'E':4,'F':5,'G':7,'A':9,'B':11,'b':-1,'#':1},j='',y=[0,0];
  for(;++i<7;j+='${(y[0]-y[1])%12}')
    for(k=0;k<2;k++)
      y[k]=n[l[i-k][0]]+(l[i-k].length>1?n[l[i-k][1]]:0);

  return'221222'==j;
}

एक पूर्ण चरण 2 है, एक चौथाई है। मॉड 12 उस स्थिति में जब आप उच्च ऑक्टेव में जाते हैं। सभी नोटों के माध्यम से Iterates और ith नोट और i-1 नोट के बीच अंतर की गणना करता है। परिणाम का अनुमान लगाता है और 221222 (2 पूरे, 1 आधा, 3 पूर्ण) की अपेक्षा करनी चाहिए।

• 0 से k को असाइन नहीं करके -2 बाइट्स
• -4 बाइट्स को स्ट्रिंग के रूप में j का उपयोग करके और सूची में नहीं
• -6 बाइट्स लूप में अनावश्यक अव्यवस्था को हटाकर @ केविन क्रूज़सेन को धन्यवाद

Comments

मुझे डार्ट का पता नहीं है, लेकिन पार्ट्स जावा जैसे हैं। इसलिए: बदलने के i=1लिए i=0एक बाइट को कम for(;i<7;i++)करने के लिए बदल रहा है for(;++i<7;)। इसके अलावा, ब्रैकेट {}को उस लूप के चारों ओर हटाया जा सकता है, लूप j+=...के तीसरे भाग के अंदर रखकर for(;++i<7;j+='${(y[0]-y[1])%12}'):। और एक आखिरी बात से बदल रहा है return j=='221222';करने के लिए return'221222'==j;अंतरिक्ष से छुटकारा पाने के। -6 ( 210 बाइट्स ) इन संशोधनों के बाद।

— केविन क्रूज़सेन

धन्यवाद, छोरों के लिए उन चालों के बारे में पता नहीं था

— Elcan

Np। अपने नए 196-बाइट संस्करण में आप भी करने के लिए यह गोल्फ कर सकते हैं 189 बाइट्स बदलकर if(k>9)k--;if(k>3)k--;करने के लिए k-=k>3?k>9?2:1:0;और k+=m.length<2?0:m[1]=='#'?1:m[1]=='b'?-1:0;return k;करने के लिए return m.length<2?k:m[1]=='#'?k+1:m[1]=='b'?k-1:k;। :)

— केविन क्रूज़सेन

धिक्कार है, मुझे अभी भी बहुत कुछ सीखना है ऐसा लगता है, धन्यवाद!

— एलकॉन

खैर, मैं 2.5 साल से गोल्फ खेल रहा हूं, और यहां तक ​​कि मुझे हर समय गोल्फ खेलने के लिए टिप्स मिलते हैं। :) शुरू में खुद को कुछ याद करना बहुत आसान है, और समय के साथ आप गोल्फ के विभिन्न तरीकों के बारे में सोचते हैं। :) गोल्फिंग के लिए युक्तियाँ <सभी भाषाओं में> यदि आप अभी तक नहीं पढ़े हैं तो दिलचस्प हो सकता है। और जावा में गोल्फिंग के लिए कुछ टिप्स डार्ट में भी लागू हो सकते हैं, क्योंकि आपके जवाब में मैंने जो गोल्फ किया था, वह मेरे जावा ज्ञान पर आधारित था, क्योंकि यह पहली बार है जब मैं डार्ट देख रहा हूं। ;)

— केविन क्रूज़सेन

Answer 5

C (gcc) , -DA=a[i]+ 183 = 191 बाइट्स

f(int*a){char s[9],b[9],h=0,i=0,j=0,d;for(;A;A==35?b[i-h++-1]++:A^98?(b[i-h]=A*13>>3):b[i-h++-1]--,i++);for(;j<7;d=(b[j]-b[j-1])%12,d=d<0?d+12:d,s[j++-1]=d+48);a=!strcmp(s,"221222");}

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

पर्ल जवाब के आधार पर।

एक विस्तृत स्ट्रिंग के रूप में इनपुट लेता है।

Ungolfed:

int f(int *a){
	char s[9], b[9];
	int h, i, j;
	h = 0;
        for(i = 0; a[i] != NULL; i++){
		if(a[i] == '#'){
			b[i-h-1] += 1;
			h++;
		}
		else if(a[i] == 'b'){
			b[i-1-h] -= 1;
			h++;
		}
		else{
			b[i-h] = (a[i] * 13) >> 3;
		}
	}
	for(j = 1; j < 7; j++){
		int d = (b[j] - b[j-1]) % 12;
		d = d < 0? d + 12: d;
		s[j-1] = d + '0';
	}
	return strcmp(s, "221222") == 0;
}

Comments

170 बाइट्स

— सीलिंगकैट

Answer 6

[वुल्फराम भाषा (गणितज्ञ) + संगीत `पैकेज], 114 बाइट्स

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

मुझे लगा कि मैं कुछ वास्तविक संगीत ज्ञान का उपयोग करके इसे पूरी तरह से अलग तरीके से आज़माऊंगा। यह पता चला है कि गणितज्ञ का संगीत पैकेज नामांकित नोटों की मौलिक आवृत्ति को जानता है। पहले मैंने इनपुट स्ट्रिंग को नामित नोटों के अनुक्रम में परिवर्तित किया। अगला, मैं प्रत्येक क्रमिक नोट के अनुपात को लेता हूं और 2 से कम (ओक्टेव शिफ्ट के लिए खाता) में से किसी एक को दोगुना करता हूं। फिर मैं इन अनुपातों की तुलना इयानियन पैमाने के अनुपातों से करता हूं, जिनमें आधे नोटों के बीच 6% आवृत्ति अंतर और पूर्ण नोटों के बीच 12% अंतर है।

यहां खर्च किए गए बाइट्स में से आधे से अधिक इनपुट को नामित प्रतीकों में परिवर्तित करना है।

.06{2,2,1,2,2,2}+1==Round[Ratios[Symbol[#~~"0"]&/@StringReplace[# ,{"b"->"flat","#"->"sharp"}]]/.x_/;x<1->2x,.01]&

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

Answer 7

पायथन 3 , 175 136 134 114 112 बाइट्स

def f(t):r=[ord(x[0])//.6+ord(x[1:]or'"')%13-8for x in t];return[(y-x)%12for x,y in zip(r,r[1:])]==[2,2,1,2,2,2]

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

---

एक-लाइनर पायथन 3 कार्यान्वयन।

डिवीजन और मोडुलो का उपयोग करके गणना टोन के विचार के लिए @Ananauld का धन्यवाद।
@Jo King फॉर -39 बाइट्स के लिए धन्यवाद।

Comments

136 बाइट्स

— जो किंग

Answer 8

[अजगर] 269 202 बाइट्स

से सुधार Jo King:

p=lambda z:"A BC D EF G".index(z[0])+"b #".index(z[1:]or' ')-1
def d(i,j):f=abs(p(i)-p(j));return min(f,12-f)
q=input().replace(' ','').split(',')
print([d(q[i],q[i+1])for i in range(6)]==[2,2,1,2,2,2])

कोशिश करो!

परीक्षण ड्राइवर के साथ अपराजित:

tone = "A BC D EF G"   # tones in "piano" layout
adj = "b #"            # accidentals

def note_pos(note):
    if len(note) == 1:
        note += ' '
    n,a = note
    return tone.index(n) + adj[a]

def note_diff(i, j):
    x, y = note_pos(i), note_pos(j)
    diff = abs(x-y)
    return min(diff, 12-diff)

def is_scale(str):
    seq = str.replace(' ','').split(',')
    div = [note_diff(seq[i], seq[i+1]) for i in (0,1,2,3,4,5)]
    return div == [2,2,1,2,2,2]

case = [
("C, D, E, F, G, A, B", True),
("C#, D#, E#, F#, G#, A#, B#", True),
("Db, Eb, F, Gb, Ab, Bb, C", True),
("D, E, Gb, G, A, Cb, C#", True),
("Eb, E#, G, G#, Bb, B#, D", True),

("C, D#, E, F, G, A, B", False),
("Db, Eb, F, Gb, Ab, B, C", False),
("G#, E, F, A, B, D#, C", False),
("C#, C#, E#, F#, G#, A#, B#", False),
("Eb, E#, Gb, G#, Bb, B#, D", False),
]

for test, result in case:
    print(test + ' '*(30-len(test)), result, '\t',
          "valid" if is_scale(test) == result else "ERROR")

Comments

हां, मैं सफेद स्थान देखता हूं - फिर भी बहुत ज्यादा पीईपी -8 के साथ, मैं डरता हूं। मैं स्पष्ट रूप से कुछ याद किया; क्या एक निष्पादन लिंक यहाँ आवश्यक है?

— प्र्यून

हालाँकि, यदि आप लिंक चाहते हैं, तो 202 बाइट्स कुछ त्वरित गोल्फ के साथ। आप निश्चित रूप से एक अलग इनपुट प्रारूप को बदलकर कुछ और गोल्फ कर सकते हैं

— जो किंग

आह ... मैं भी प्रक्रिया मूल्य के रूप में अंतिम अभिव्यक्ति लौटाने के लिए पायथन का उपयोग कर रहा हूं। संकेत और संकेत के लिए धन्यवाद।

— प्रून

यदि आप किसी फ़ंक्शन को स्ट्रिंग की सूची में ले जाते हैं, तो आप 156 बाइट्स प्राप्त कर सकते हैं। इसके अलावा, TIO के लिंक सेक्शन में एक ऑटो फॉर्मैटर है जिसे आप उपयोग कर सकते हैं

— जो किंग

@JoKing, आप इस उत्तर को संपादित करने या अपना स्वयं का पोस्ट करने के लिए पूरी तरह से स्वागत करते हैं; लिंक के साथ टिप्पणी करने से सुधार एक स्तर से अलग हो जाते हैं।

— प्रॉन

Answer 9

रूबी , 109 बाइट्स

->s{(0..11).any?{|t|s.map{|n|(w="Cef;DXg<E=Fhi>G j8A d9B:")[(w.index(""<<n.sum%107)/2-t)%12]}*''=='CfDX<=h'}}

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