बैकस्टोरी [जो सच नहीं है]

एक पियानो इस तरह स्थापित किया गया है:

हालांकि, मेरे पियानो पर, सभी काली चाबियाँ टूट गई हैं!

मैं अभी भी अपने टूटे हुए पियानो पर कुछ राग बजाने में सक्षम होना चाहता हूं।

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

एक अर्धविराम क्या है?

पश्चिमी संगीत की सबसे छोटी दूरी एक अर्धविराम है। यदि आप पियानो के शीर्ष भाग को देखते हैं, तो आप देखते हैं कि आप आमतौर पर एक काली कुंजी से एक सफेद कुंजी या इसके विपरीत जा सकते हैं; हालांकि, बीच Bऔर Cऔर Eऔर Fवहाँ कोई काला कुंजी है।

राग क्या है?

इस चुनौती के उद्देश्यों के लिए, हम उन दोनों के बीच एक निश्चित संख्या के साथ नोटों के एक समूह के रूप में एक राग को परिभाषित करते हैं। उदाहरण के लिए, चलिए एक 4-3-3कॉर्ड पर शुरू करते हैं C(संगीत लोगों के लिए, यह F प्रमुख में V ⁷ कॉर्ड है)। हम शुरू करते हैं C। हम 4 semitones अप गिनती: C#, D, D#, E। अगले टिप्पणी है E, और हम 3 semitones अप गिनती के बाद: F, F#, G। अगले टिप्पणी है G, और हम 3 semitones अप गिनती के बाद: G#, A, Bb। तो, हम प्राप्त करते हैं C-E-G-Bb। वाह! लेकिन रुको ... Bbएक काली कुंजी है और वे टूट गए हैं ... हालांकि, अगर हम से शुरू करते हैं G, तो हम प्राप्त करते हैं G-B-D-F! वाह!

इनपुट

इनपुट को किसी भी उचित प्रारूप में पूर्णांकों की सूची के रूप में दिया गया है। यह जीवा का प्रतिनिधित्व करता है जैसा कि ऊपर वर्णित है।

उत्पादन

आउटपुट उन नोटों की एक सूची होनी चाहिए जिन पर मुझे केवल सफेद कुंजी का उपयोग करने की आवश्यकता हो सकती है। यह भी केवल 7 नोटों के सभी के लिए एक स्ट्रिंग हो सकता है क्योंकि सभी कीनेम एक वर्ण होंगे। आपको एक खाली आउटपुट होने के साथ-साथ उसे संभालने में सक्षम होना चाहिए।

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

input -> output // comments
4 3 -> C F G // this is a major triad
3 4 -> D E A // this is a minor triad
4 3 3 -> G // this is the major-minor seventh chord
3 3 3 -> [empty output] // this is the diminished-diminished seventh chord. All of them use black keys
4 4 -> [empty output] // this is an augmented triad
3 3 -> B // this is a diminished triad
1 -> B E // this is just a minor second
11 -> C F // this is just a major seventh

अन्य चश्मा

मानक Loopholes निषिद्ध
आप मान सकते हैं कि इनपुट में कम से कम एक पूर्णांक है
आप मान सकते हैं कि सभी पूर्णांक गैर-नकारात्मक हैं और 12 से कम हैं (क्योंकि पियानो हर 12 नोटों को दोहराता है)
आउटपुट किसी भी क्रम में हो सकता है

जीत का मानदंड

15 अप्रैल तक का सबसे कम वैध जमा स्वीकार किया जाएगा।

code-golf music

— HyperNeutrino
स्रोत

हम "गैर-नकारात्मक और 12 से कम" मान सकते हैं - क्या यह "सकारात्मक और 12 के बराबर या उससे कम नहीं" होना चाहिए?

— जोनाथन एलन

@JonathanAllan मूल रूप से कोई अंतर नहीं है; मेरी विधि एक परिपूर्ण यूनिसन के लिए अनुमति देती है, लेकिन एक परिपूर्ण ऑक्टेव नहीं; तुम्हारा उल्टा। सैद्धांतिक रूप से, आपका प्रतिबंध अधिक समझ में आता है, लेकिन मुझे लगता है कि मुझे शायद इसे बदलना नहीं चाहिए क्योंकि पहले से ही उत्तर हैं और यह चुनौती को मौलिक रूप से नहीं बदलता है।

— हाइपरनेत्रिनो

3

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

236ḃ2ṙÐ€7+\€Ṭ
+\ịþ¢Ạ€TịØA

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

कैसे?

236ḃ2ṙÐ€7+\€Ṭ - Link 1, white-note-offsets: no arguments
236ḃ2         - 236 in bijective base 2 [2, 2, 1, 2, 2, 1, 2] - semitones G->A, A->B ...
     ṙÐ€7     - rotate left by, mapped over [1,2,3,4,5,6,7] - i.e. as above for each
                    starting white key (1st one A->B,B->C,...; 2nd B->C,C->D,...; etc)
         +\€  - reduce €ach with addition - i.e. absolute number of semitones: [[2,3,5,7,8,10,12],[1,3,5,6,8,10,12],[2,4,5,7,9,11,12],[2,3,5,7,9,10,12],[1,3,5,7,8,10,12],[2,4,6,7,9,11,12],[2,4,5,7,9,10,12]]
            Ṭ - untruth (vectorises) - make lists with 1s at those indexes: [[0,1,1,0,1,0,1,1,0,1,0,1],[1,0,1,0,1,1,0,1,0,1,0,1],[0,1,0,1,1,0,1,0,1,0,1,1],[0,1,1,0,1,0,1,0,1,1,0,1],[1,0,1,0,1,0,1,1,0,1,0,1],[0,1,0,1,0,1,1,0,1,0,1,1],[0,1,0,1,1,0,1,0,1,1,0,1]]

+\ịþ¢Ạ€TịØA - Main link: list of semitone gap integers (even negatives will work)
+\          - reduce by addition - gets the absolute semitone offsets needed
    ¢       - last link (1) as a nilad
   þ        - outer product with:
  ị         -     index into - 7 lists, each with 1s for white and 0s for black keys hit
                      note that indexing is modular and all the lists are length 12
                      so any integer is a valid absolute offset, not just 0-11 inclusive
     Ạ€     - all truthy for €ach - for each get a 1 if all keys are white ones, else 0
       T    - truthy indexes - get the valid starting white keys as numbers from 1 to 7
        ị   - index into:
         ØA -     the uppercase alphabet

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

6

MATL , 31 बाइट्स

एक सुधार के लिए जोनाथन एलन को धन्यवाद ।

'BAGFEDC'"GYs12X\110BQX@YSYsm?@

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

व्याख्या

पैटर्न 2 2 1 2 2 2 1लगातार सफेद कुंजी के बीच अंतराल को निर्दिष्ट करता है। कार्यक्रम एक लूप का उपयोग करता है जो इस मूल पैटर्न में सभी चक्रीय बदलावों को लागू करता है, ताकि इनपुट की जीवा के संभावित सबसे कम नोट के रूप में प्रत्येक कुंजी का परीक्षण किया जा सके। प्रत्येक पारी के लिए, पैटर्न का संचयी योग प्राप्त होता है। उदाहरण के लिए, Bसंभावित न्यूनतम नोट के रूप में, पैटर्न को स्थानांतरित कर दिया गया है 1 2 2 1 2 2 2और इसकी संचयी राशि है 1 3 5 6 8 10 12।

अब, यह देखने के लिए कि क्या यह 4 3 3कॉर्ड का समर्थन कर सकता है, हम कॉर्ड अंतराल के संचयी योग की गणना करते हैं, जो है 4 7 10; इसे 1-आधारित मॉडुलो 12 के माध्यम से कम करें (एक अंतराल 14देना होगा 2); और जांचें कि क्या वे संख्याएं अनुमत मानों के सभी सदस्य हैं 1 3 5 6 8 10 12। इस उदाहरण में ऐसा नहीं है। अगर ऐसा होता, तो हम पत्र का उत्पादन करते B।

चक्रीय पारियों और आउटपुट पत्रों के बीच पत्राचार स्ट्रिंग द्वारा परिभाषित किया गया है 'BAGFEDC'। यह इंगित करता है कि 'B'(पहले चरित्र) द्वारा चक्रीय पारी से मेल खाती है 1; 'A'(दूसरा चरित्र) एक चक्रीय पारी से मेल खाती है 2आदि।

'BAGFEDC'  % Push this string
"          % For each character from the string
  G        %   Push input array
  Ys       %   Cumulative sum
  12X\     %   1-based modulo 12, element-wise (1,12,13,14 respectively give 1,12,1,2)
  110BQ    %   Push 110, convert to binary, add 1 element-wise: gives [2 2 1 2 2 2 1]
  X@       %   Push current iteration index, starting at 1
  YS       %   Cyclic shift to the right by that amount
  Ys       %   Cumulative sum
  m        %   Ismember. Gives an array of true of false entries
  ?        %   If all true
    @      %     Push current character
           %   End (implicit)
           % End (implicit)
           % Display (implicit)

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

5

गणितज्ञ, 110 बाइट्स (आईएसओ 8859-1 एन्कोडिंग)

±i_:=#&@@@Select["A#BC#D#EF#G#"~StringTake~{Mod[#,12,1]}&/@#&/@(Accumulate[i~Prepend~#]&/@Range@12),FreeQ@"#"]

एक ±पूर्णांक की सूची को इनपुट के रूप में पूर्णांक की सूची को परिभाषित करता है (पूर्णांक के आकार या संकेतों पर कोई प्रतिबंध नहीं, वास्तव में) और एक-वर्ण तार की सूची लौटाता है। उदाहरण के लिए, ±{3,4}रिटर्न {"A","D","E"}।

"A#BC#D#EF#G#"~StringTake~{Mod[#,12,1]}&/@#एक फ़ंक्शन है जो पूर्णांक के नामों की सूची को संबंधित नोट नामों में बदल देता है, सिवाय इसके कि #किसी भी काली कुंजी के लिए खड़ा है। यह प्रत्येक तत्व पर लागू होता है Accumulate[i~Prepend~#]&/@Range@12, जो नोट अंतराल की सूची इनपुट सूची से नोट मानों की एक सूची बनाता है, 1 से 12 तक प्रत्येक संभावित नोट के साथ शुरू होता है। हम ऐसे सभी नोट-नाम सूचियों को फ़िल्टर करते हैं जिनमें "#"उपयोग होता है Select[...,FreeQ@"#"], और फिर प्रत्येक शेष सूची में पहले नोट का उपयोग करके लौटें #&@@@।

— ग्रेग मार्टिन
स्रोत

अच्छा प्रस्तुत!

— HyperNeutrino

प्रश्न: क्या गणितज्ञ अपनी बाइट प्रणाली का उपयोग करता है? यह 110 वर्ण है लेकिन +/-प्रतीक के कारण UTF-8 में यह 111 बाइट्स है ।

— हाइपरनीट्रीनो

आप पूरी तरह से असाइनमेंट स्ट्रिप कर सकते हैं और सिर्फ एक फंक्शन को "इंपैक्टली रिटर्न" कर सकते हैं।

— wizzwizz4

@ wizzwizz4: मैंने पाया कि मुझे वैरिएबल का नाम देना पड़ा Accumulate[i~Prepend~#]&क्योंकि अन्यथा इसमें करंट क्लैश होता। हालांकि एक समाधान खोजने के लिए स्वतंत्र महसूस करें!

— ग्रेग मार्टिन

@ हीपरनेट्रिनो: आप सही कह रहे हैं कि यूटीएफ -8 मानक एन्कोडिंग है, लेकिन आईएसओ 8859-1 एन्कोडिंग में भी गणितज्ञ (आमतौर पर) कार्य कर सकते हैं। मैंने नोट किया है कि पोस्ट में।

— ग्रेग मार्टिन

3

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

(यह सुनिश्चित करने के बाद यह पोस्ट करना कि कोई मान्य सबमिशन है जो इस से कम है)

import numpy
s='C.D.EF.G.A.B'
def k(y):return lambda x:s[(x+y)%12]
for i in range(12):
    if s[i]!='.'and'.'not in map(k(i),numpy.cumsum(input())):print s[i]

बहुत ज्यादा सिर्फ तुच्छ समाधान। अलग-अलग लाइन पर प्रत्येक वर्ण के साथ पूर्णांक और आउटपुट की सूची के रूप में इनपुट।

-4 एक अनावश्यक चर को हटाकर बाइट्स