दो नोट नामों को देखते हुए, आपको एक प्रोग्राम लिखना है जो निर्धारित करता है कि इन दो नोटों द्वारा गठित अंतराल व्यंजन या असंगत है।

परिचय

पश्चिमी संगीत में, केवल 12 "भिन्न" स्वर हैं। उनके नाम, सबसे कम से लेकर उच्चतम तक क्रमबद्ध हैं, ये हैं C, C#, D, D#, E, F, F#, G, G#, A, A#, B:। अनुक्रम चक्रीय है, अर्थात यह एक के Cबाद दूसरे B, अनंत रूप से जारी है ।

दो स्वरों के बीच की दूरी को एक अंतराल कहा जाता है । किसी भी दो नोटों के बीच का अंतराल जो ऊपर की श्रृंखला में (जैसे C — C#या E — F) समीपवर्ती होता है, एक अर्धविराम कहलाता है । अधिक दूर के नोटों के बीच के अंतराल को पहले से दूसरे (जबकि संभवतः अनुक्रम के चारों ओर लपेटते हुए) प्राप्त करने के लिए आवश्यक सेमिटोन चरणों की संख्या के रूप में परिभाषित किया गया है। कुछ उदाहरण: D to E= 2 सेमीटोन, C to G= 7 सेमीटोन, B to D#= 4 सेमीटोन (यह अनुक्रम के चारों ओर लपेटता है)। ¹

अब, इन अंतरालों को दो श्रेणियों में विभाजित किया गया है: व्यंजन (सुखद ध्वनि अगर आप एक साथ दो नोट खेलते हैं) और असंगत (इतना नहीं)।

चलो व्यंजन के अंतराल को परिभाषित करते हैं: 0, 3, 4, 5, 7, 8 और 9 सेमीटोन।

उनमें से शेष असंगत हैं, अर्थात्: 1, 2, 6, 10 और 11 अर्धवृत्त।

चुनौती

निम्नलिखित करने के लिए एक "प्रोग्राम" (शब्द के सामान्य अर्थ में: एक फ़ंक्शन पूरी तरह से ठीक है) लिखें:

इनपुट के रूप में दो नोट नाम (ऊपर के क्रम से तार) लें। आप उन्हें अपनी पसंद के अनुसार ले सकते हैं (स्टैडिन से, तर्कों के रूप में, जो कुछ भी आप चाहते हैं, उन्हें अलग कर सकते हैं, यहां तक कि उन्हें वर्णों की सूची के रूप में लेने के लिए स्वतंत्र महसूस ["C","#"]कर सकते हैं। हो सकता है उन्हें 0 से 11 तक संख्या न दें और संख्याओं का उपयोग करें)।
आपके लिए वहां संगीत गीक्स हैं, नोटों को ओक्टेव के बिना निर्दिष्ट किया जाएगा। इस मामले में, यह भी कोई फर्क नहीं पड़ता कि नोट किस क्रम में आते हैं और कौन सा कम है और कौन सा अधिक है। अंत में, आपको ऊपर की सूची में किसी भी नाम को संभालने की आवश्यकता नहीं है। कोई अन्य एनर्जोनिक्स जैसे E#, कोई फ़्लैट, डबल-परिवर्तन और इतने पर नहीं।
कोई भी दो अलग-अलग मान चुनें। जब भी इनपुट में दो नोटों द्वारा गठित अंतराल व्यंजन हो, और दूसरा अगर वे नहीं हैं, तो आपके प्रोग्राम को उनमें से एक को आउटपुट करना होगा। ( Trueऔर हो सकता है False, लेकिन यहां तक कि π और ई अगर आप चाहते हैं :))
यह एक कोड-गोल्फ है। प्रत्येक भाषा में बाइट्स में सबसे छोटा प्रोग्राम जीत जाता है। मज़े करो!

उदाहरण और परीक्षण मामले

Note 1    Note 2    Output    Interval [semitones]
  C          D     Dissonant   2
  A#         A#    Consonant   0
  G          D     Consonant   7 (wraparound)
  D#         A     Dissonant   6
  F          E     Dissonant   11
  A          C     Consonant   3

मैं उनमें से अधिक नहीं जोड़ता क्योंकि इसमें कोई विशेष रूप से विश्वासघाती मामले नहीं हैं।

यह मेरी पहली चुनौती है, इसलिए किसी भी रचनात्मक आलोचना का गर्मजोशी से स्वागत है: यदि आपको थ्योरी स्पष्टीकरण सुस्त लगता है, तो बेझिझक सवाल पूछें। अंत में, मुझे मत बताओ कृपया है कि इस का एक शिकार है इस या इस । मैंने सुनिश्चित किया कि यह नहीं है। (उत्तरार्द्ध काफी समान है लेकिन अधिक जटिल है। मैंने सोचा कि थोड़ी सरल चुनौती देना लोगों के लिए जुड़ने में आसान होगा।)

¹ : मैंने जहाँ तक हो सके इस स्पष्टीकरण को सरल बनाने की कोशिश की। अंतराल के आसपास बहुत अधिक सिद्धांत है। कृपया इसे छोड़ने के लिए मुझे कोसें नहीं।

code-golf music

— Ramillies
स्रोत

12

जेली , 21 बाइट्स

इनपुट को दो तारों की सूची के रूप में लेता है। 0असंतुष्ट या 1व्यंजन के लिए लौटाता है ।

OḢ6×%21_Lµ€IA“¬ɠṘ’æ»Ḃ

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

OḢ6×%21_Lµ€IA“¬ɠṘ’æ»Ḃ   - main link
         µ€             - for each note             e.g. ["A#", "C"]
O                       -   convert to ASCII codes  -->  [[65, 35], 67]
 Ḣ                      -   keep the first element  -->  [65, 67]
  6×                    -   multiply by 6           -->  [390, 402]
    %21                 -   modulo 21               -->  [12, 3]
       _L               -   subtract the length     -->  [12, 3] - [2, 1] = [10, 2]
           IA           - absolute difference       -->  8
             “¬ɠṘ’      - the integer 540205
                  æ»    - right-shift               -->  540205 >> 8 = 2110
                    Ḃ   - isolate the LSB           -->  2110 & 1 = 0

के निर्माण

हमें पहले ध्यान देना चाहिए कि जिस फ़ंक्शन F की हम तलाश कर रहे हैं वह प्रशंसनीय है: किसी भी जोड़ी के नोट्स (A, B) के लिए , हमारे पास F (A, B) = F (B, A) है ।

चूंकि बहुत अधिक संभावित इनपुट नहीं हैं और इससे निपटने के लिए केवल 2 संभावित आउटपुट हैं, इसलिए यह एक साधारण हैश फ़ंक्शन एच को खोजने के लिए संभव होना चाहिए , जैसे कि - एच (ए) - एच (बी) | मूल्यों की एक सीमित श्रृंखला का उत्पादन करता है और अपेक्षित आउटपुट के संबंध में नोट्स (ए, बी) के सभी संभव जोड़े के लिए टकराव मुक्त है ।

हम फ़ंक्शंस H (mul, mod) के सेट का परीक्षण करने जा रहे हैं , जिसे निम्न रूप में परिभाषित किया गया है:

H(mul, mod)(s) = ((ORD(s[0]) * mul) MOD mod) - LEN(s)

ORD(s[0])नोट के पहले वर्ण का ASCII कोड कहां है और नोट LEN(s)की लंबाई है ( 2 यदि कोई है '#'और 1 यदि नहीं है तो)।

नीचे जेएस कोड का एक टिप्पणी संस्करण है जिसका उपयोग वैध जोड़े (मूल, मॉड) और परिणामी बिटकॉम्स के एक जोड़े को खोजने के लिए किया गया था । कई संभावित समाधान हैं, लेकिन * 6 % 21इस विधि के साथ सबसे छोटा है।

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

// all 12 notes
note = ['C','C#','D','D#','E','F','F#','G','G#','A','A#','B'];

// reference implementation that takes 2 notes
// and returns 0 for dissonant or 1 for consonant
F = (a, b) =>
  +!~[1, 2, 6, 10, 11].indexOf((note.indexOf(a) - note.indexOf(b) + 12) % 12)

for(mul = 1; mul < 100; mul++) {
  for(mod = 1; mod < 31; mod++) {
    // hash function
    H = s => s.charCodeAt() * mul % mod - s.length;

    table = {};

    // for all possible pairs of notes (a, b)
    if(note.every(a => note.every(b => {
      // compute the table index
      idx = Math.abs(H(a) - H(b));

      // and the expected result
      res = F(a, b);

      // if the slot is empty, store the correct value
      if(table[idx] === undefined) {
        table[idx] = res;
        return 1;
      }
      // else, make sure that the correct value is already there
      return table[idx] == res;
    }))) {
      // if all tests pass: translate the table into a binary mask
      for(n = 0, msk = 0; n < 31; n++) {
        msk |= (table[n] || 0) << n;
      }
      // and display the result
      console.log('mul ' + mul + ', mod ' + mod + ' --> ' + msk);
    }
  }
}

स्निपेट का विस्तार करें

— Arnauld
स्रोत

3

आप इन चीजों के साथ भी कैसे आते हैं? .. क्या आप इस तरह के 'एल्गोरिदम' को हाथ से या जानवर के बल से प्राप्त कर रहे हैं? और दूसरे प्रश्न के उत्तर की परवाह किए बिना: कैसे? ..?: एस " शाब्दिक पूर्णांक 540205; सही के साथ स्थानांतरित (ASCII कोड; 6 से गुणा; modulo 21; पहले रखें; लंबाई घटाएँ ...); बिटवाइड-एंड 1 "। आपके उत्तर मुझे हर बार प्रभावित करते रहते हैं ..

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

@KevinCruijssen मैंने मूल JS कोड जोड़ा है जिसका उपयोग इन मूल्यों को खोजने के लिए किया गया था।

— अरनुलद

अतिरिक्त स्पष्टीकरण के लिए धन्यवाद। मैं अभी भी पहले की तरह प्रभावित हूं, लेकिन आपने स्पष्ट किया कि आप इसके साथ कैसे आए। बहुत बुरा मैं केवल एक बार बढ़ सकता है।

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

9

APL (Dyalog) , 62 39 बाइट्स

उपयोग करता है ⎕IO←0; 0 व्यंजन है, 1 असंगत है। आधार नोट वर्णों की सूची को बाएं तर्क के रूप में और दाएं तर्क के रूप में शार्पों की सूची बनाता है।

{⎕A[|-/('C D EF G A '⍳⍺)+⍵=⍕#]∊'BCGKL'}

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

{… } अनाम फ़ंक्शन जहां ⍺बाएं तर्क है और ⍵सही तर्क है

⎕A[... ]∊'BCGKL' है एक lphabet, निम्नलिखित, स्ट्रिंग के एक सदस्य द्वारा अनुक्रमित?

⍕# रूट नेमस्पेस को प्रारूपित करें (पैना चरित्र की पैदावार)

⍵= क्या सही तर्क चार्ट (शार्प) उसी के बराबर हैं?

(… )+ निम्नलिखित जोड़ें:

'C D EF G A '⍳⍺ स्ट्रिंग में बाएं तर्क चार्ट के सूचकांक

-/ उन लोगों के बीच अंतर

| निरपेक्ष मूल्य

— Uriel
स्रोत

क्या आप हममें से उन लोगों के लिए स्पष्टीकरण जोड़ना चाहेंगे जो एपीएल से अपरिचित हैं?

— ड्रेकोनिस

@Draconis स्पष्टीकरण जोड़ा गया।

— आदम

9

MATL , 30 27 26 बाइट्स

,j'DJEFPGIALBC'&mQs]ZP7Mdm

दोनों नोटों को अलग-अलग लाइनों में इनपुट करता है। 0व्यंजन के लिए आउटपुट , 1असंगति के लिए।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

11 वर्ण का तार

DJEFPGIALBC

नोट और असंगत अंतराल, दोनों को एन्कोड करता है।

कार्यक्रम पहले उपरोक्त स्ट्रिंग में इनपुट वर्णों के 1-आधारित सूचकांकों को ढूंढता है । जैसे कोई नॉन-शार्प इनपुट Dदेगा 1, Eदेगा 3, ..., Cदेगा 11। इन संख्याओं को 1 × 1 संख्यात्मक सारणी भी माना जा सकता है। जैसे एक तेज इनपुट C#1 × 2 सरणी देगा [11 0], जिसका अर्थ है कि Cस्थिति में पाया गया था 11और# गया था नहीं मिला था।

उस पत्र को देखें JPIL कभी भी इनपुट में मौजूद नहीं होंगे। अभी के लिए वे केवल इतना है कि उदाहरण के लिए ध्यान दें, प्लेसहोल्डर के रूप में उपयोग किया जाता है Eहै दो ऊपर semitones D। लेकिन वे असंगत अंतराल को परिभाषित करने के लिए भी उपयोगी होंगे।

1 × 1 या 1 × 2 सरणी की पहली प्रविष्टि में संख्याएं सेमीटोन में पिच को नोट करने के लिए अनुरूप हैं, न कि तेज प्रतीकों (अभी तक) की गिनती। ध्यान दें कि इन नंबरों द्वारा परिभाषित पैमाने पर शुरू नहीं होता हैC ; लेकिन इससे कोई फर्क नहीं पड़ता क्योंकि हम केवल अंतराल चाहते हैं, यानी नोटों के बीच अंतर । प्राप्त संख्याओं को घटाना अंतराल या 12 मिनट का अंतराल देना होगा। लेकिन पहले हमें तेज प्रतीक पर विचार करने की आवश्यकता है।

तीखे नोटों पर विचार करने के लिए, एक गोल्फ का तरीका (MATL में) 1पहले प्राप्त किए गए 1 × 1 या 1 × 2 सरणी के प्रत्येक प्रविष्टि को जोड़ना है और फिर सरणी (2 बाइट्स) का योग करें। इस प्रकार गैर-तीखे नोटों की वृद्धि होती है 1और तीखे नोटों द्वारा 2। यह तीखे नोटों को गैर-तीखे नोटों की अपेक्षा 1 सेमीटोन अधिक बनाता है। हम सभी नोटों में एक अतिरिक्त अर्धविराम भी जोड़ रहे हैं, लेकिन इससे उनके बीच का अंतराल नहीं बदलता है। तो अब ध्यान दें Dपिच संख्या दे देंगे 2, D#दे देंगे 3, ..., Cदे देंगे 12, C#दे देंगे 13।

कर्कश अंतराल होते हैं 1, 2, 6, 10, या 11। इनमें एक मोडुलो -12 समरूपता है : दो नोटों के बीच का अंतराल असंगत है यदि और केवल यदि रिवर्स ऑर्डर में नोटों के साथ अंतराल, मोडुलो 12, असंगत है।

यदि हम स्ट्रिंग के लगातार अंतर की गणना करते हैं तो हमें 'DJEFPGIALBC'संख्यात्मक वेक्टर मिलता है

6 -5 1 10 -9 2 -8 11 -10 1

जिसमें कुछ नकारात्मक मूल्यों के अलावा, असंगत अंतराल भी शामिल है, जो न तो उपयोगी होगा और न ही हानिकारक। ध्यान रखें कि यह JPILस्ट्रिंग में अतिरिक्त अक्षरों का विकल्प है 'DJEFPGIALBC'जो असंगत अंतराल के माध्यम से (लगातार अंतर के माध्यम से) परिभाषित करता है।

यह देखने के लिए कि क्या दो इनपुट नोट असंगत हैं, हम उनके पिच नंबर का पूर्ण अंतर लेते हैं । उदाहरण के लिए, Cऔर क्रमशः D#संख्या 12और 3क्रमशः दे देंगे , और पूर्ण अंतर है 9। वास्तविक अंतर होगा -9, और वास्तविक अंतराल होगा 3( -9मॉडुलो 12 के रूप में प्राप्त )। लेकिन ऊपर वर्णित समरूपता के लिए धन्यवाद, हम 9इसके बजाय विचार कर सकते हैं 3। चूंकि 9निरंतर अंतर के वेक्टर में मौजूद नहीं है, इसलिए नोट व्यंजन हैं।

— लुइस मेंडो
स्रोत

2

मुझे उसी तरह से पसंद है कि कैसे आपने एक ही स्ट्रिंग में नोटों और असंगत अंतरालों को एन्कोड किया।

— celtschk

8

जावास्क्रिप्ट (ईएस 6), 68 64 बाइट्स

सिंटेक्स में करीने से नोट को दो तार के रूप में लेता है (a)(b)। 0असंतुष्ट या 1व्यंजन के लिए लौटाता है ।

a=>b=>488055>>(g=s=>'C D EF G A'.search(s[0])-!s[1])(a)-g(b)+9&1

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

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

let f =

a=>b=>488055>>(g=s=>'C D EF G A'.search(s[0])-!s[1])(a)-g(b)+9&1

console.log(f('C' )('D' )) // 0 (Dissonant)
console.log(f('A#')('A#')) // 1 (Consonant)
console.log(f('G' )('D' )) // 1 (Consonant)
console.log(f('D#')('A' )) // 0 (Dissonant)
console.log(f('F' )('E' )) // 0 (Dissonant)
console.log(f('A' )('C' )) // 1 (Consonant)

स्निपेट का विस्तार करें

प्रारूपित और टिप्पणी की गई

a => b =>                       // given the two notes 'a' and 'b'
  488055 >>                     // 19-bit lookup bitmask: 1110111001001110111
    (g = s =>                   // we use g() to convert a note 's' into a semitone index
      'C D EF G A'.search(s[0]) // position of the note: -1 for 'B' (not found) to 9 for 'A'
      - !s[1]                   // subtract 1 semitone if the '#' is not there
    )(a)                        // compute the result for 'a'  --> [ -2 ...  9]
    - g(b)                      // subtract the result for 'b' --> [-11 ... 11]
    + 9                         // add 9                       --> [ -2 ... 20]
  & 1                           // test the bitmask at this position (0 if negative or > 18)

— Arnauld
स्रोत

7

जेली , 26 बाइट्स

i@€ØAo.SḤ’d5ḅ4µ€ạ/“¢£©½¿‘ċ

दो नोट्स (पात्रों की सूची के रूप में) की सूची लेने और 0व्यंजन के लिए और 1असंतुष्ट के लिए एक विवादास्पद लिंक ।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट में सभी इनपुट देखें।

कैसे?

i@€ØAo.SḤ’d5ḅ4µ€ạ/“¢£©½¿‘ċ - Link: list of lists of characters, notes
              µ€           - for €ach note in notes: (call the resulting list x)
   ØA                      -   yield the uppercase alphabet
i@€                        -   first index of c in ^ for €ach character, c
                           -     ...note '#' is not there so yields 0 (A->1, B->2,...)
      .                    -   literal one half
     o                     -   or (vectorised)  - e.g. "C#" -> [3, 0] -> [3, 0.5]
       S                   -   sum
        Ḥ                  -   double - that is ...  C C#  D D#  E  F F#  G G#  A A#  B
                                                 ->  6  7  8  9 10 12 13 14 15  2  3  4
         ’                 -   decrement         ->  5  6  7  8  9 11 12 13 14  1  2  3
           5               -   literal five
          d                -   divmod                (e.g. 9 -> [1,4] or 11 -> [2,1])
             4             -   literal four
            ḅ              -   convert from base     (e.g. [1,4] -> 8 or [2,1] -> 9)
                                                 ->  4  5  6  7  8  9 10 11 12  1  2  3
                 /         - reduce x with:
                ạ          -   absolute difference   (e.g. ["G#", "A"] -> [12, 1] -> 11)
                  “¢£©½¿‘  - code-page indices = [1, 2, 6, 10, 11]
                         ċ - count occurrences (1 if in the list, 0 if not)

— जोनाथन एलन
स्रोत

5

जेली , 31 बाइट्स

O_65ị“¢[ḋṃ’b⁴¤+L$€Ḣ€ạ/e“cṾ’b12¤

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

मट्ठा 32 बाइट बहुत लंबा है

व्याख्या

O_65ị“¢[ḋṃ’b⁴¤+L$€Ḣ€ạ/e“cṾ’b12¤  Main link
O                                Cast each character to an int using Python `ord`
 _65                             Subtract 65 (A is 0, G is 7)
     “¢[ḋṃ’b⁴¤                   [2, 3, 5, 7, 9, 10, 0]
     “¢[ḋṃ’                      37058720
           b                     Digits in base
            ⁴                    16
    ị                            Index into this list; this creates the gaps for sharps
                 €               For each sublist
              +L$                Add the length to each element (Sharpens sharp notes)
              +                  Add
               L                 Length
                   €             For each sublist
                  Ḣ              Take the first element
                    ạ/           Absolute difference between the two (unoctaved) pitches # It's convenient that every interval's inverse (?) has the same consonance/dissonance
                      e          Is the semitone difference in
                       “cṾ’b12¤  [1, 2, 6, 10, 11]?
                       “cṾ’      25178
                           b     base
                            12   12

— HyperNeutrino
स्रोत

अरे, यह बहुत अच्छा जवाब है! मैं सोच रहा था कि क्या कोई समरूपता का उपयोग करता है, और आपने किया। और मुझे नोटों के नाम के साथ-साथ संख्याओं के मिलान के लिए आपकी विधि पसंद है! +1।

— रामलीज

सेमिटोन अंतर सममित हो सकता है लेकिन आपको अभी भी डफ परिणाम प्राप्त होते हैं - उदाहरण के लिए "G#", "A"(डिस्सेंटेंट) एक अंतर उत्पन्न करता है 11जिसमें अंदर नहीं है[1,2,6] ।

— जोनाथन एलन

@JonathanAllan ओह उह अच्छी तरह से यह शर्मनाक है; मुझे लगा कि पूर्ण अंतर तय हो गया है कि… ._ lol को ठीक करेगा

— HyperNeutrino

1

@JonathanAllan ने कुछ अतिरिक्त बाइट्स (3 IIRC) के लिए तय किया

— HyperNeutrino

4

मैथेमेटिका, 55 बाइट्स

function                                                  arguments        bytes

FreeQ[1|2|6|10|11]@Abs[#-#2&@@Sound`PitchToNumber/@#]&    [{"C","F#"}]     55

Sound`PitchToNumberइनपुट पर आंतरिक अंतर्निहित (दो तारों की सूची) को मैप करें , पूर्ण अंतर लें, फिर असंगत अंतराल संख्याओं के लिए पैटर्न मैच।

सिर्फ मनोरंजन के लिए (गैर-प्रतिस्पर्धात्मक)

यहां कुछ छोटे कार्य हैं जो प्रतिबंध का उल्लंघन करते हैं "आप किसी अन्य नाम को नोटों को निर्दिष्ट नहीं कर सकते हैं।" अल्पविकसित Music`पैकेज में पूर्वनिर्धारित नोट स्थिरांक (जैसे A4 = 440.) और फ़ंक्शन HertzToCents(जिसे गोल्फ किया जा सकता है) है। स्ट्रिंग्स के बजाय, हम नोट कॉन्स्टेंट का उपयोग तर्कों के रूप में करेंगे, लेकिन प्रत्येक फ़ंक्शन के लिए एक अलग प्रारूप में दिया जाएगा।

FreeQ[1|2|6|10|11]@Abs@@Round[.01HertzToCents@#]&         [{C3,Fsharp3}]   50+9=59
FreeQ[1|2|6|10|11]@Abs@Round[17Log[#2/#]]&                [C3,Fsharp3]     43+9=52
FreeQ[1|2|6|10|11]@Abs@Round[17Log@#]&                    [C3/Fsharp3]     39+9=48

पैकेज आयात <<Music`;में 9 बाइट्स लगते हैं।

यह फ़ंक्शन स्ट्रिंग (जैसे "F#") को एक नोट कॉन्स्टेंट (जैसे ) में परिवर्तित करता है Fsharp3:

Symbol[StringReplace[#,"#"->"sharp"]<>"3"]&                                44

एक सप्तक से बड़े अंतराल को स्वीकार करने के लिए, के Abs[…]साथ बदलें Mod[…,12]।

कुछ अंतरालों को असंगत क्यों माना जाता है? एक अंतराल दो आवृत्तियों का अनुपात है। यदि अनुपात में एक "सरल" अंश और हर है, तो यह अधिक व्यंजन हो जाता है। में 5-सीमा ट्यूनिंग , अनुपात केवल रूढ़ अंक के पूर्णांक शक्तियों में से कम किया जा सकता है पर निर्भर करता या बराबर स्वभाव में 5 पर कोई अंतराल के बराबर, सप्तक के अलावा, एक है सिर्फ अंतराल ; वे केवल 2 के 12 वें मूल की शक्तियों का उपयोग करते हुए निकट सन्निकटन हैं।

हार्ड-कोडिंग के बजाय, जो अंतराल संख्याएं असंगत हैं, हम अंतराल के एक तर्कसंगत अनुमान को पा सकते हैं और फिर यह निर्धारित कर सकते हैं कि क्या इसके अंश और भाजक "सरल" हैं (इसका अर्थ है कि भाजक 5 से कम है और अनुपात 7 विभाजित नहीं है)।

यह तालिका उस प्रक्रिया के प्रत्येक चरण को दिखाती है।

Table[
  Module[{compoundInterval,simpleInterval,rationalApprox,denomLeq5,div7,consonant},
    compoundInterval = Power[2, i/12];
    simpleInterval   = 2^Mod[Log2[compoundInterval], 1];
    rationalApprox   = Rationalize[N@simpleInterval, 1/17];
    denomLeq5        = Denominator[rationalApprox]<=5;
    div7             = Denominator[rationalApprox]>1 && rationalApprox\[Divides]7;
    consonant        = FreeQ[1|2|6|10|11][Mod[i,12]];

    InputForm/@{
      i, simpleInterval, rationalApprox, 
      denomLeq5, div7, denomLeq5 && !div7,
      consonant
    }
  ], {i, 0, 12}
]

i   sInterval  ratio   denomLeq5  div7       den&&!div  | consonant?

0   1          1       True       False      True       | True
1   2^(1/12)   17/16   False      False      False      | False
2   2^(1/6)    9/8     False      False      False      | False
3   2^(1/4)    6/5     True       False      True       | True
4   2^(1/3)    5/4     True       False      True       | True
5   2^(5/12)   4/3     True       False      True       | True
6   Sqrt[2]    7/5     True       True       False      | False
7   2^(7/12)   3/2     True       False      True       | True
8   2^(2/3)    8/5     True       False      True       | True
9   2^(3/4)    5/3     True       False      True       | True
10  2^(5/6)    7/4     True       True       False      | False
11  2^(11/12)  11/6    False      False      False      | False
12  1          1       True       False      True       | True

तर्कसंगत सन्निकटन 1/17अंतराल के भीतर निहित है क्योंकि यह सबसे बड़ी दहलीज है जो सभी 12 समान टेम्पर्ड अंतरालों के बीच अंतर करता है। हम पैटर्न के साथ तर्कसंगत संख्याओं से मेल खाते हैंRational[a_,b_]a_~_~b_ पहले (या सिर्फ ) , और उसके बाद ही पूर्णांकों के साथ मेल खाते हैं _।

यह निम्नलिखित बल्कि छोटे समारोह में समाप्त होता है जो निर्धारित करता है कि एक मनमाना आवृत्ति अनुपात (1 से अधिक) व्यंजन या असंगत है।

Rationalize[#,1/17]/.{a_~_~b_:>b<=5&&!a∣7,_->True}&       [Fsharp3/C3]     51+9=60

— hftf
स्रोत

1

भगवान, मुझे मत बताओ मेथेमेटिका भी के लिए अंतर्निहित है इस डी: ...

— Ramillies

3

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

FreeQ[{1,2,6,10,11},Min@Mod[Differences[Min@Position["C|C#|D|D#|E|F|F#|G|G#|A|A#|B"~StringSplit~"|",#]&/@{#,#2}],12]]&

इनपुट फॉर्म

[ "एक #", "डी"]

आउटपुट

True->Consonant  
False->Dissonant

धन्यवाद @JonathanFrech -16 बाइट्स

— J42161217
स्रोत

बस एक टिप्पणी: यदि आप उत्पादन तार की जरूरत नहीं है Consonantऔर Dissonant। आप उनके बजाय किसी भी दो मूल्यों का उत्पादन कर सकते हैं (0/1, ... जो भी हो)। कि कुछ बाइट्स बचा सकता है।

— रामलीज

1

क्या आप इसे छोड़ नहीं सकते If[...,0,1]और परिभाषित नहीं कर सकते True->Consonant; False->Dissonant?

— जोनाथन फ्रेच

1

StringCases["CC#DD#EFF#GG#AA#B",_~~"#"...]- 42 बाइट्स

— celtschk

1

इसके अलावा, 2 बाइट्स की जगह बचाया जा सकता है {1,2,6,10,11}के साथ1|2|6|10|11

— celtschk

1

@Skyler नीचे उत्तर देखें।

— hftf

3

चारकोल , 30 बाइट्स

≔B#A#G#FE#D#Cζ§”o∧⌈ς”⁻⌕ζ⮌θ⌕ζ⮌η

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। व्यंजन 1 के लिए आउटपुट, असंगति के लिए 0। स्पष्टीकरण:

≔B#A#G#FE#D#Cζ                  Store reversed note names in z
                        θ       First input
                       ⮌        Reversed
                     ⌕ζ         Find index in z
                            η   Second input
                           ⮌    Reversed
                         ⌕ζ     Find index in z
                     ⁻          Subtract
               ”o∧⌈ς”           Compressed string 100111011100
              §                 Circularly index
                                Implicitly print

— नील
स्रोत

जिज्ञासा से बाहर, वहाँ एक ख़तरनाक कारण ग्लिफ़ ⌕ζ"सूचकांक खोजने" के लिए प्रयोग किया जाता है?

— जोनाह

@ जोनाह ζवह चर है जिसे पहले सौंपा गया था।

— नील

2

जे, 68 बाइट्स

[:e.&1 2 6 10 11[:(12| -~/)(<;._1',C,C#,D,D#,E,F,F#,G,G#,A,A#,B')i.]

व्याख्या

एक सीधा, सुपर गोल्फ नहीं जे में कार्यान्वयन:

इनपुट बॉक्सिंग आइटम के रूप में दिया जाता है (कट का उपयोग करके उत्पादित), क्रम में।
नोटों की श्रेणी में उनके सूचकांक खोजें: (<;._1',C,C#,D,D#,E,F,F#,G,G#,A,A#,B')i.]
दूसरे से पहले घटाएँ: -~/
12 से विभाजित होने पर शेष भाग लें: 12|
जांचें कि क्या यह असंगत नोटों में से एक है: e.&1 2 6 10 11

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

— जोनाह
स्रोत

2

/// , 90 88 बाइट्स

/^/"\///^\/\///C^D/##"E/DD"F/E#"G/FD"A/GD"B/AD"#,#/,"B#^B/#"A#/#"A^G#^G^F#/#"F^E^D#^D/#/

इसे ऑनलाइन आज़माएं! (एक बार में सभी परीक्षण मामले)

कोड के बाद इनपुट डालें।
के साथ नोट नाम अलग करें ,B#प्रत्येक टेस्ट केस में ।
उत्पादन ,व्यंजन के लिए है,,# असंगति के लिए।
दोहरे-परिवर्तन ( ##) या E#कुछ विशेष मामलों में समर्थन। अन्यथा उत्पादन ,व्यंजन के लिए है,#, असंगति के लिए (मॉडुलो 12 समरूपता के लिए धन्यवाद)
एक बार में कई परीक्षण मामलों को संभाल सकते हैं (यदि यथोचित रूप से अलग किया गया)
लोअरकेस अक्षर बिल्कुल मुद्रित होते हैं।

— user202729
स्रोत

2

सी (जीसीसी) , 91 बाइट्स

g(char*s){return (s[1]&1|2**s&15)*4/5;}f(char*x,char*y){return (1952220<<g(x)>>g(y))&2048;}

फोन: f("A#", "D")

प्रतिलाभ की मात्रा:

व्यंजन: 2048
अपभ्रंश: ०

बोनस: फ़ंक्शन असंवेदनशील है।

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

— celtschk
स्रोत

क्या दोनों return (एस में दो अनावश्यक स्थान नहीं हैं ?

— जोनाथन फ्रीच

आप कोशिश कर सकते हैं g(char*s){s=(s[1]&1|2**s&15)*4/5;}f(char*x,char*y){x=1952220<<g(x)>>g(y)&2048;}और अच्छा समाधान!

— कीउ गण

1

पायथन 2, 125 117 83 78 77 बाइट्स

a,b=map("C C#D D#E F F#G G#A A#B".index,input())
print chr(abs(a-b))in""

जहां "" अंत में वास्तव में अक्षर होते हैं"\x02\x04\x0c\x14\x16"

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

(+3 क्योंकि मैं सूची के साथ शुरू करने के लिए 11 या 22 भूल गया)

जोनाथन फ्रेच से -8 बाइट्स और पायथन 2 पर स्विच करना ।

जोनाथन फ्रेच के सुझावों के साथ -34 बाइट्स और strइसके बजाय इंडेक्स इंडेक्स का उपयोग करनाlist ।

-4 बाइट्स इनलाइनिंग से iऔर नील ने स्ट्रिंग सुझाव को उलट दिया (केवल -2 वास्तव में, जैसे मैं भूल गया था() एक जनरेटर के आसपास )

-5-बाइट्स अन-इनलाइनिंग iऔर इनपुट प्रारूप को बदलने से

जोनाथन फ्रेच से -1 बाइट्स map()और बिना प्रिंट के।

प्रारूप में एक पंक्ति में इनपुट लेता है:

'C','C#'

Trueअसंगत है, Falseव्यंजन है।

पुरानी व्याख्या:

i='C C#D D#E F F#G G#A A#B'.index
a,b=input()
print abs(i(a)-i(b))in[2,4,12,20]

पाइथन str.indexएक मेल खाने वाले सबस्ट्रिंग के सबसे कम (पॉजिटिव) इंडेक्स को लौटाता है, इसलिए "ABACABA".index("A") == 0और "ABACABA".index("BA") == 1। इस वजह से, हम नोट नामों को समान रूप से एक स्ट्रिंग में रख सकते हैं, और जब तक (उदाहरण के लिए) Aपहले आता है A#, साझा Aकी जाने वाली समस्या नहीं होगी।

i='C C#D D#E F F#G G#A A#B'.index

iअब एक ऐसा फ़ंक्शन है जो सूचकांक को 'C C#D D#E F F#G G#A A#B'उसके तर्क (एक नोट नाम) को लौटाता है, जो 2 * है (नोट से ऊपर जाने वाले सेमीटोन की संख्या C)

a,b=input()

पायथन 2 का input()(ज्यादातर) पायथन 3 के बराबर है eval(input()), इसलिए प्रारूप के एक वैध इनपुट के साथ 'C#','F'(उदाहरण के लिए), a='C#'औरb='F'

print abs(i(a)-i(b))in[2,4,12,20]

यदि स्ट्रिंग में पहले नोट और दूसरे नोट के बीच की गड़बड़ी 2, 4, 12 या 20 नहीं है (चूंकि नोट का नाम 2 वर्णों में दर्शाया गया है), तो अंतराल असंगत है, प्रिंट सही है, अन्यथा यह व्यंजन है झूठा छापना।

— pizzapants184
स्रोत

चूंकि इनपुट प्रारूप सख्त नहीं है, आप eval(input())(15 बाइट्स) के बजाय (13 बाइट्स) का उपयोग कर सकते हैं input().split()।

— जोनाथन फ्रीच

101 बाइट्स

— जोनाथन फ्रेच

98 बाइट्स

— जोनाथन फ्रेच

79 बाइट्स

— जोनाथन फ्रेच

1

आप एक एम्टी-स्ट्रिंग के बजाय यूनिकोड वर्ण ( ) का उपयोग कर सकते हैं ।

— जोनाथन फ्रेच

1

सी (जीसीसी) , 115117 120 बाइट्स

g(char*a){a=*a-65+!!a[1]*(7-*a/70-*a/67);}f(x,y)char*x,*y;{x="(pP$HL<lt<X"[g(x)]*32+"=ZukW-^h1F6"[g(x)]>>g(y)&1;}

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

व्यंजन और असंतुष्ट के लिए 1/0 लौटें। शुद्ध सी। के साथ स्ट्रिंग हेरफेर करना हमेशा दिलचस्प होता हैf("A#", "C")

— कीउ गण
स्रोत

0

पॉवरशेल , 107 बाइट्स

param($a,$b)[math]::abs(($x=-split'C C# D D# E F F# G G# A A# B').indexof($b)-$x.indexof($a))-in1,2,6,10,11

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

Trueअसंतुष्ट और के लिए आउटपुटFalse व्यंजन के ।

तार के रूप में इनपुट $aऔर $b, दो नोट लेता है । -splitबड़े पैमाने पर एक ऑपरेशन करता है , जो व्हाट्सएप पर विभाजित होता है, नोट्स की एक सरणी बनाने के लिए, उस में संग्रहीत करता है $x। .indexof $bउस सरणी में ढूँढता है , के इंडेक्स को घटाता है $a, और उसके बाद absolute मान लेता है। जाँचता है कि क्या वह संख्या -inअसंगत श्रेणी है।

— AdmBorkBork
स्रोत

0

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

lambda a,b,f='C C#D D#E F F#G G#A A#B'.find:3142>>(f(a)-f(b))/2%12&1

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

आउटपुट: 1असंगत है, 0व्यंजन है।

— लिन
स्रोत

0

एसक्यूएल, 582 बाइट्स

एसक्यूएल फिडल

मेरे पास अभी भी इस पर कुछ करने के लिए गोल्फ है, लेकिन मैं इसे पूरी तरह से तोड़ने से पहले इसे यहाँ नीचे उतरना चाहता था।

यदि इनपुट एक पत्र प्रारूप में है, तो उन अक्षरों को एक तालिका में मानों के साथ रखना ठीक है, है ना?

CREATE TABLE N(N char(2),v int)
Insert Into N values('A',1),('A#',2),('B',3),('C',4),('C#',5),('D',6),('D#',7),('E',8),('F',9),('F#',10),('G',11),('G#',12);
CREATE TABLE D(D char(9),v int) 
Insert Into D values('C',0),('D',1),('D',2),('C',3),('C',4),('C',5),('D',6);
CREATE FUNCTION I(@A char(2),@B char(2))
RETURNS char(9) as
BEGIN
DECLARE @E int=(SELECT v from N where n=@A),@F int=(SELECT v from N where n=@B)
DECLARE @C char(9) = (SELECT case D when 'D' then 'Dissonant' when 'C' then 'Consonant' END from D where v in(abs(@e-@f),12-abs(@e-@f)))
RETURN isnull(@C,'NotANote')
END

— phroureo
स्रोत

0

पर्ल 5 , 106 बाइट्स

("C,C#,D,D#,E,F,F#,G,G#,A,A#,B,"x2)=~/$F[0],(.*?)$F[1],/;$r=(1+($1=~y/,//))%12;say(grep/$r/,(0,3..5,7..9))

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

असंगत के लिए झूठे, व्यंजन के लिए सही।

— Xcali
स्रोत

राजद्रोह या असंगति?

परिचय

चुनौती

उदाहरण और परीक्षण मामले

जेली , 21 बाइट्स

के निर्माण

APL (Dyalog) , 62 39 बाइट्स

MATL , 30 27 26 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 68 64 बाइट्स

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

प्रारूपित और टिप्पणी की गई

जेली , 26 बाइट्स

कैसे?

जेली , 31 बाइट्स

व्याख्या

मैथेमेटिका, 55 बाइट्स

सिर्फ मनोरंजन के लिए (गैर-प्रतिस्पर्धात्मक)

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

चारकोल , 30 बाइट्स

जे, 68 बाइट्स

व्याख्या

/// , 90 88 बाइट्स

सी (जीसीसी) , 91 बाइट्स

पायथन 2, 125 117 83 78 77 बाइट्स

सी (जीसीसी) , 115117 120 बाइट्स

पॉवरशेल , 107 बाइट्स

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

एसक्यूएल, 582 बाइट्स

पर्ल 5 , 106 बाइट्स