संगीत: इस राग में क्या है?

Question

इनपुट

किसी भी त्रिक जीवा का प्रतीक (देखें http://en.wikipedia.org/wiki/Chord_(music)#Triads )।

उत्पादन

दिए गए राग के नोट्स।

उदाहरण

इनपुट: AM आउटपुट:A C# E

इनपुट: C#m आउटपुट:C# E G#

इनपुट: Db+ आउटपुट:C# F A

इनपुट: C0 आउटपुट:C D# F#

बोनस

-50 यदि आप सातवें तार से भी निपट सकते हैं

-150 वास्तव में राग की आवाज बजाने के लिए

-150 मुद्रण योग्य वर्णों का उपयोग करके यह दिखाने के लिए कि पियानो पर कॉर्ड कैसे बजाया जाए; उदाहरण के लिए AM:

┌─┬─┬┬─┬─┬─┬─┬┬─┲┱─┬─┬─┲━┱┬─┲━┱─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ┃┃ │ │ ┃ ┃│ ┃ ┃ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ┃┃ │ │ ┃ ┃│ ┃ ┃ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ┃┃ │ │ ┃ ┃│ ┃ ┃ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┲┛┗┱┘ │ ┗┯┛└┲┛ ┃ └┬┘└┬┘└┬┘ │
│  │  │  │  │  ┃  ┃  │  │  ┃  ┃  │  │  │  │
└──┴──┴──┴──┴──┺━━┹──┴──┴──┺━━┹──┴──┴──┴──┘

एक गिटार पर कॉर्ड खेलने के लिए दिखाने के लिए मुद्रण योग्य पात्रों का उपयोग करने के लिए -100 ; उदाहरण के लिए AM:

x   o   o   o   o   o
┌───┬───┬───┬───┬───┐
│   │   │   │   │   │
├───┼───┼───┼───┼───┤
│   │   │   │   │   │
├───┼───┼───┼───┼───┤
│   │   █   █   █   │
├───┼───┼───┼───┼───┤
│   │   │   │   │   │

(देखें https://en.wikipedia.org/wiki/Box-drawing_character )

नियम

• परिणाम एक कमांड-लाइन प्रोग्राम या स्क्रिप्ट होना चाहिए।

• इनपुट और आउटपुट किसी भी रूप में हो सकता है, जब तक कि यह एक संगीत संकेतन मानक का अनुसरण करता है।

• एक गिटार या पियानो प्रतिनिधित्व को वैध माना जाता है अगर और केवल अगर इसमें तीन (ट्रायडिक) या चार (सातवें) आवश्यक नोट शामिल हैं और कुछ नहीं। एक ही नोट कॉर्ड में कई बार मौजूद हो सकता है।

• बाहरी पुस्तकालयों की अनुमति नहीं है, केवल ध्वनि पीढ़ी को छोड़कर (जिस स्थिति में #include, import... वर्ण संख्या में निर्देश नहीं जोड़े जाते हैं)।

• यह कोड गोल्फ है, सबसे छोटा कोड जीतता है!

संगीत सिद्धांत का एक छोटा सा ...

आधुनिक पश्चिमी तानवाला संगीत में, प्रत्येक सप्तक लगातार बारह नोटों से बना होता है, जिसे अक्सर नोट किया जाता है:

A A# B C C# D D# E F F# G G#

या:

La La# Si Do Do# Re Re# Mi Fa Fa# Sol Sol#

इस प्रणाली में, हम मानते हैं कि लगातार दो नोट (उदाहरण के लिए Aऔर A#, या Eऔर F) एक अर्द्धस्वर से अलग होती है। इसके अलावा, नोट "लूपिंग" की तरह हैं: तुरंत क्या होता G#है A।

एक कॉर्ड का गठन कुछ (2, 3, 4, कभी-कभी अधिक) द्वारा किया जाता है, ध्यान दें कि "एक साथ अच्छा लगता है"। उदाहरण के लिए, त्रिक chords में तीन अलग-अलग नोट होते हैं, और सातवें chords में चार अलग-अलग नोट होते हैं।

आइए चार त्रय चक्रों को परिभाषित करें :

• मेजर ट्रायड : इसमें कॉर्ड की जड़ (इस प्रश्न में, इनपुट के रूप में दिया गया नोट), रूट के लिए प्रमुख तीसरा (रूट से अधिक 4 सेमीटोन), और रूट के लिए सही पांचवां (मूल से 7 सेमीटोन अधिक है) ); यह 0-4-7 का प्रतीक हो सकता है

• मामूली त्रय , 0-3-7 का प्रतीक है

• संवर्धित त्रय , 0-4-8 का प्रतीक है

• निस्तेज त्रय , 0-3-6 का प्रतीक है

उदाहरण के लिए, यदि आप एक बनाना चाहते हैं तो सी प्रमुख त्रय , का उल्लेख किया C, CM, Cmaj, आप तीन विख्यात की आवश्यकता होगी:

• 0: जड़ , इस मामले में एC
• 4: मामूली तीसरा , मूल से 4 सेमी अधिक; यह एक हैE
• 7: सही पांचवां , जड़ से 7 सेमी अधिक: एG

यह वही है 0-4-7, जो 0-3-7, 0-4-8और 0-3-6उपर्युक्त अर्थों का उपयोग करता है! सातवें तार के लिए, निम्नलिखित पैटर्न का उपयोग करें:

आजके लिए इतना ही! अब, मुझे आश्चर्यजनक कोड के साथ विस्मित करना ... यदि आपके कोई प्रश्न हैं, तो नीचे कुछ टिप्पणियां जोड़ें।

Comments

यह गैर संगीतकारों के लिए पूर्णांक अंकन में जीवा के लिए सूत्र सहित एक स्पष्टीकरण जोड़ने के लायक हो सकता है। पूर्णांक संकेतन में सब कुछ को संदर्भित करता है। प्रमुख राग (उदाहरण AM): 0,4,7। लघु राग (उदाहरण C # m): 0,3,7। C कम हो गया (उदाहरण सह, या जैसा कि आप इसे C0 कहते हैं) 0,3,6 (ध्यान दें कि सही प्रतिनिधित्व C Eb Gb है, लेकिन इस चुनौती के लिए मुझे लगता है कि हम यह मान सकते हैं कि यह और CD # F # दोनों स्वीकार्य हैं।) सूत्र। संवर्धित जीवा के लिए (उदाहरण Db +) 0,4,8 है और आपका उदाहरण गलत है क्योंकि इसमें Db भी नहीं है। जैसा कि लिखा गया है कि यह एक B + है जो एक D # + या G + के बराबर है

— लेवल रिवर सेंट

इसके अलावा, सबसे छोटा कोड एक ही प्रकार के सभी गिटार तार के लिए एक ही राग के आकार के उपयोग के परिणामस्वरूप होगा, वर्जित। तो आब 11 वीं झल्लाहट में ए आकार वर्जित होगा। क्या एक नंबर लगाना ठीक है या हमें 11 फ़्रेच ड्रा करना है? सब सब में, यह सोचने के लिए बहुत सी चीजें हैं। आप बोनस को सरल बनाना चाहते हैं।

— लेवल रिवर सेंट

हम्म .. आपका संवर्धित राग अभी भी गलत है। सी # Db को enharmonic है, लेकिन Db+है Db F Aकोई डी # या वहाँ में जी। यह शायद आवश्यकता से थोड़ा अधिक सिद्धांत है, सूत्र महत्वपूर्ण हिस्सा थे। यदि आप वास्तव में विकिपीडिया में सूचीबद्ध सातवें chords के सभी आठ को शामिल करना चाहते हैं तो आपको इनपुट निर्दिष्ट करना चाहिए। मैं मानती हूं कि पियानो और गिटार का एससी-आर्ट आउटपुट लचीला है।

— लेवल रिवर सेंट

मुझे ऐसा लगता है कि मैंने यहां संगीत सिद्धांत के बारे में अधिक सीखा है जितना मैंने पाठों से सीखा है।

— केविन इवांस

इस साइट पर सबसे अच्छी समस्या!

— रे

Answer 1

बीबीसी बेसिक

Bbcbasic.co.uk पर एमुलेटर

Rev 1, 340 - 150 कीबोर्ड - 150 खेल = 40

यहां नवीनतम संस्करण है, जिसमें मैं केवल कुछ और पात्रों द्वारा लंबा करते हुए निम्नलिखित संवर्द्धन को शामिल करने में कामयाब रहा।

इनपुट रिटर्न को दबाने से पहले स्क्रीन पर आराम से संपादित किया जा सकता है (मैं सिंगल कीप्स पाने के लिए पहले GET $ का उपयोग कर रहा था, क्योंकि BBC बेसिक आपको स्ट्रिंग से एक भी कैरेक्टर को एक्सेस करने की अनुमति नहीं देता है जैसे कि स्ट्रिंग एक सरणी थी। अब मैं इसके बजाय उपयोग करता हूं। भारी MID $ स्ट्रिंग के भीतर से एक वर्ण की एक स्ट्रिंग निकालने के लिए कार्य करता है।

कीबोर्ड के दोनों किनारों के साथ-साथ E और F के बीच पूर्ण रेखा प्रदर्शित होती है।

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

यद्यपि प्रस्तुति बहुत बेहतर लगती है, निम्न कार्यक्रम वास्तव में पहले से ही पूरी तरह से गोल्फ है। (नीचे सुधार देखें।) जब एक IF स्टेटमेंट का उपयोग किया जाता है, तब आमतौर पर नई कथानक और कॉलोन विनिमेय होते हैं। उस स्थिति में सशर्त निष्पादित होने के साथ एक ही पंक्ति (कॉलनों द्वारा अलग) पर सभी बयान। नईलाइन के बाद कथन IF द्वारा नियंत्रित नहीं किए जाते हैं और हमेशा निष्पादित किए जाएंगे।

कार्यक्रम में 1 340 वर्ण घूमते हैं

  a$="C#D#EF#G#A#B0Mm+"
  INPUTx$
  r=INSTR(a$,LEFT$(x$,1))-1
  c=INSTR(a$,MID$(x$,2,1))
  IFc=2c=INSTR(a$,MID$(x$,3)):r=r+1
  t=(r+4-c MOD2)MOD12
  f=(r+c DIV2)MOD12
  v=1
  FORn=-1TO11
  c=1-(n<0ORn=4ORn=11)*5
  b$=MID$(a$,n+1,1)
  IFb$="#"c=11:b$=MID$(a$,n,1)+b$
  c$=MID$("   _______--|__",c,5)
  IFr=n ORt=n ORf=n c$=c$+b$:SOUNDv,-15,100+n*4,99:v=v+1
  PRINTc$
  NEXT

सुधार: आरटी रसेल का विंडोज के लिए बीबीसी बेसिक आपको कुछ नए कथानकों और कॉलनों को खत्म करने की अनुमति देता है, कुल 327 को नीचे ला रहा है, नीचे देखें। इसके अलावा यह सहेजने से पहले कीवर्ड को एकल वर्णों में बदल देता है, इसे 279 तक ले जाता है।

  a$="C#D#EF#G#A#B0Mm+"INPUTx$
  r=INSTR(a$,LEFT$(x$,1))-1c=INSTR(a$,MID$(x$,2,1))IFc=2c=INSTR(a$,MID$(x$,3))r=r+1
  t=(r+4-c MOD2)MOD12f=(r+c DIV2)MOD12v=1FORn=-1TO11c=1-(n<0ORn=4ORn=11)*5b$=MID$(a$,n+1,1)IFb$="#"c=11b$=MID$(a$,n,1)+b$
  c$=MID$("   _______--|__",c,5)IFr=n ORt=n ORf=n c$=c$+b$SOUNDv,-15,100+n*4,99v=v+1
  PRINTc$
  NEXT

आउटपुट Rev १

रेव 0, 337 - 150 कीबोर्ड - 150 खेल = 37

A$="C#D#EF#G#A#B0Mm+":X$=GET$:R=INSTR(A$,X$)-1:X$=GET$:IF X$="#"R=R+1:X$=GET$
C=INSTR(A$,X$):T=(R+4-C MOD2)MOD12:F=(R+C DIV2)MOD12:V=1:PRINT"______"
FORN=0 TO 11
C=1-(N=4)*12:B$=MID$(A$,N+1,1): IF B$="#" C=7: B$=MID$(A$,N,1)+B$
PRINT MID$("    __---|________",C,6);:IF(R-N)*(T-N)*(F-N)=0 PRINT B$;:SOUND V,-15,100+N*4,99:V=V+1
PRINT
NEXT

यह मेरे Arduino जवाब के लिए एक समान अवधारणा है, लेकिन मुझे हमेशा पता था कि मैं बीबीसी बेसिक के साथ उस बाइट की गिनती को हरा सकता हूं। केवल शार्प्स को पहचानता है, लेकिन B # को अमान्य मानता है, आपको C. लगाना चाहिए। यदि यह वास्तव में महत्वपूर्ण माना जाता है तो इसे ठीक किया जा सकता है।

मैंने गिटार के विचार को त्याग दिया और कीबोर्ड को बेहतर बनाने पर ध्यान केंद्रित किया। अब यह C से B तक चलता है, और मैंने कीबोर्ड के बाईं ओर और E और F के बीच की रेखा को जोड़ा है। इसकी लागत 28 वर्ण है। दाहिने हाथ की ओर ज्यादा नहीं होगा।

यहाँ कुछ नमूना आउटपुट है, एक # # कम कॉर्ड (जो इस उलट में एक बहुत अजीब ध्वनि है) और एक बी प्रमुख राग। ध्यान दें कि इनपुट स्क्रीन पर प्रतिध्वनित नहीं होता है। Arduino जवाब के अनुसार, स्क्रीन को देखने के लिए एंटीक्लॉकवाइज़ चालू करें।

अनप्लग्ड संस्करण

A$="C#D#EF#G#A#B0Mm+"                              :REM Note names and chord type names fit very conveniently in the same string.
X$=GET$                                            :REM Get a character 
R=INSTR(A$,X$)-1                                   :REM Root note = position of that char in A$. INSTR starts counting at 1, but we want 0, so subtract.
X$=GET$                                            :REM If the root note is natural, the next character will be the chord type. But...
IF X$="#"R=R+1:X$=GET$                             :REM If this char is # we need to increment the root, and get another char for chord type. 
C=INSTR(A$,X$)                                     :REM C encodes for chord type
T=(R+4-C MOD2)MOD12                                :REM even C means major third, odd C means minor third
F=(R+C DIV2)MOD12                                  :REM "Mm" gives C=14,15 meaning C DIV2=7 (perfect fifth.) C=13,16 give diminished and augmented: 6,8.
V=1                                                :REM V is the sound channel number ("voice")                             
PRINT"______"                                      :REM left side of keyboard for cosmetic reasons
FORN=0 TO 11                                       :REM at the start of each iteration initialise C to 1, to point to the 4 spaces/2 underscores in the string below for drawing white notes. 
  C=1-(N=4)*12                                     :REM if the note is E, add 12 so it points to the 6 underscores to draw the line between E and F. 
  B$=MID$(A$,N+1,1)                                :REM load B$ with the name of the current note.
  IF B$="#" C=7: B$=MID$(A$,N,1)+B$                :REM if the character encountered is a sharp, update C to point the characters for drawing a sharp. Find the previous character in A$ and join it to the beginning of B$ to complete the note name.
  PRINT MID$("    __---|________",C,6);            :REM print the key (6 characters.)
  IF(R-N)*(T-N)*(F-N)=0 PRINT B$;:SOUND V,-15,100+N*4,99:V=V+1  :REM if N is equal to R,T or F, print the note name beside the key, play the note and increment the channel number for the next note.  
  PRINT                                            :REM print a carriage return. It may be possible to golf this line out.
NEXT

Comments

कमांड लाइन से प्रोग्राम का उपयोग कैसे किया जाता है? (मैंने अपनी उबंटू मशीन पर बीबीसी बेसिक स्थापित किया)

— मथिउ रोडिक

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

— लेवल रिवर सेंट

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

— लेवल रिवर सेंट।

बीबीसी बेसिक लिनक्स पर भी चलता है, वे होस्ट ओएस के आधार पर अपने होम पेज पर कई वितरण प्रदान करते हैं। मैं सिर्फ प्रोग्राम को चलाने के लिए नहीं आया, न ही कोड को पास करने या प्रॉम्प्ट में चिपकाने से ...

— मैथ्यू रोडिक

मैंने सिर्फ नेपोलियन ब्रांडी बेसिक को डाउनलोड किया है, और यह वास्तव में शुरू करना मुश्किल है! आपको कोड को chords.nap नामक पाठ फ़ाइल में सहेजने की आवश्यकता है, फिर कमांड प्रॉम्प्ट पर LOAD "chords.nap" टाइप करें। यह कोड के लिए लाइन नंबर जोड़ता है (मूल बीबीसी बेसिक के लिए अधिक प्रामाणिक, कुछ और वर्ण जोड़ देगा) फिर आप RUN टाइप करते हैं और प्रोग्राम उस लाइन में SOUND स्टेटमेंट के साथ क्रैश हो जाता है, जिसमें त्रुटि संदेश "असमर्थित मूल V सुविधा" मिल गया।" आप वास्तव में आरटी रसेल के कार्यान्वयन के साथ एक गंभीर कार्यक्रम लिख सकते हैं यदि आप वास्तव में चाहते थे। लेकिन ब्रांडी बेसिक के साथ मैं इसके बारे में सोच भी नहीं सकता।

— लेवल रिवर सेंट।

Answer 2

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

इसके लायक क्या है, अगर आप एनार्मोनिक्स को अलग करना चाहते हैं, तो किसी भी संगीतमय अंतराल को एक कंप्यूटर प्रोग्राम में कई तरह के सही पांचवें और कई ओक्टेव्स के रूप में प्रतिनिधित्व किया जा सकता है। एक संवर्धित चौथा, उदाहरण के लिए, 6 परिपूर्ण पाँचवें और -3 सप्तक हैं, और एक कम पांचवें है -6 परिपूर्ण पाँचवें और 4 अष्टक।

हास्केल, 441 वर्ण

import Data.List

notes = "FCGDAEB"

fromNum x = [notes !! (mod x 7)] ++ if x < 0 then replicate (-(div x 7)) 'b' else replicate (div x 7) '#'

toNum (x:xs) = y + 7 * if isPrefixOf "b" xs then -length xs else length xs
    where Just y = elemIndex x notes

chord xs = unwords . map (fromNum . \x -> toNum (init xs) + x) $ case last xs of 'A' -> [0,4,8]; 'M' -> [0,4,1]; 'm' -> [0,-3,1]; 'd' -> [0,-3,-6]

main = getLine >>= putStrLn . chord

कुछ उदाहरण चालान:

jaspers:junk tswett$ ./chord
AM
A C# E
jaspers:junk tswett$ ./chord
C#m
C# E G#
jaspers:junk tswett$ ./chord
DbA
Db F A
jaspers:junk tswett$ ./chord
Cd
C Eb Gb
jaspers:junk tswett$ ./chord
A#M
A# C## E#
jaspers:junk tswett$ ./chord
Dbm
Db Fb Ab

Answer 3

Arduino

इनपुट / आउटपुट को COM पोर्ट के माध्यम से Arduino से / को भेजा / प्राप्त किया जाता है। एक उपयोगकर्ता टर्मिनल, या Arduino IDE में धारावाहिक मॉनिटर के माध्यम से इसके साथ बातचीत कर सकता है। जैसा कि आपने प्लेटफ़ॉर्म की मेरी पसंद से अनुमान लगाया होगा, मैं कॉर्ड के वास्तविक खेल को शामिल करने की योजना बना रहा हूं (हालांकि मैंने अभी तक ऐसा नहीं किया है।)

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

कॉर्ड बॉक्स 130 बाइट्स में आता है, जो इसके लायक होने के लिए बहुत लंबा है। इसलिए मैंने एक और तरीका आजमाया है, बस झल्लाहट संख्या टैब शैली को मुद्रित करना। वर्तमान में यह 81-100 = -19 के बोनस के लिए 81 बाइट्स है। यदि यह दृष्टिकोण वैध माना जाता है, तो मैं इस पर प्रयास कर सकता हूं और सुधार कर सकता हूं।

इस्तेमाल की जाने वाली तार 2 डी-स्ट्रिंग पर जड़ के साथ, तीसरी स्ट्रिंग पर पांचवें और पहली और चौथी पारी में तीसरे के साथ सभी डी-प्रकार के आकार हैं। 5 वें और 6 वें तार का उपयोग नहीं किया जाता है और मैं इसे कॉर्ड बॉक्स के दाईं ओर एक्स के साथ चिह्नित करता हूं (बाएं अधिक सामान्य होगा, लेकिन दाईं ओर चिह्नित उदाहरण पाए जा सकते हैं।)

क्योंकि कार्यक्रम एफ को सबसे कम नोट मानता है (कीबोर्ड के साथ संगतता के लिए जबकि इस कॉर्ड आकार के साथ अत्यधिक उच्च फ्रीट से बचने के लिए) उच्चतम कॉर्ड एक ई है (17 वें झल्लाहट पर रूट के साथ।) उदाहरण आउटपुट देखें।

गोल्फिंग के मामले में कीबोर्ड अधिक सफल है। यह उपरोक्त वर्णित कारणों के लिए CB के बजाय FE से चलता है। इसे स्क्रीन को 90% एंटिक्लॉकवाइज करके देखा जाना चाहिए, जब आप काले नोटों की रूपरेखा और सफेद नोटों के बीच सीमांकन को स्पष्ट रूप से देख सकते हैं ---। B a C के बीच की रेखा को ____कुछ और बाइट्स के साथ बढ़ाया जा सकता है ।

मैं आगे नोट खेलने की कोशिश करूंगा। यह दिलचस्प होगा क्योंकि, मेरा मानना ​​है कि Arduino Uno में 3 आंतरिक टाइमर हैं, एक बार में केवल एक नोट को टोन कमांड में निर्मित का उपयोग करके खेला जा सकता है। एक बाहरी लाइब्रेरी फ़ंक्शन है जो सभी हार्डवेयर टाइमर का उपयोग करता है (जो धारावाहिक को गड़बड़ कर देगा, लेकिन वैसे भी उस स्तर पर इसकी आवश्यकता नहीं होगी।) वैकल्पिक रूप से मैं सॉफ्ट में टोन का उत्पादन करने का प्रयास कर सकता हूं।

अगर मैं इसके साथ सफल हूं, तो मैं इसे नीचे गिरा दूंगा, लेकिन मुझे नहीं लगता कि यह कुल विजेता होगा।

अघोषित कोड

String p="F#G#A#BC#D#E -Mm+",y,d[]=
{"    ","---|"},n="\n";

void setup() {
  Serial.begin(9600);
  Serial.setTimeout(99999);
}

void loop(){
  char x[9]; int r,t,f,i,c=1;
  Serial.readBytesUntil(13,x,9);
  Serial.println(x);  
  r=p.indexOf(x[0]);
  if (x[1]==35|x[1]==98){c=2;r+=x[1]==35?1:-1;}
  f=p.indexOf(x[c])/2;
  t=4-p.indexOf(x[c])%2;

  //chord box
  y=n;for(i=24;i--;)y+=d[1]+(i%4?"":" \n");
  y[89]=y[107]='X'; y[t*4-10]=y[t*4+52]=y[f*4+14]=y[28]='O';
  Serial.print("\t "+String(r+6)+y);

  f+=r;t+=r;

  //tab style
  Serial.println(String(t+1)+n+String(r+6)+n
  +String(f-2)+n+String(t+3)+"\nX\nX\n");

  f%=12;t%=12;

  //piano
  for(i=0;i<12;i++){
    c=0;
    y=String(p[i]);
    if(y=="#") {c=1;y=p[i-1]+y;}      
    Serial.println(d[c]+"__"+((r-i&&t-i&&f-i)?"":y));
  }  
}

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

Comments

वास्तविक ध्वनि के लिए इंतजार नहीं कर सकता!

— मैथ्यू रोडिक

EM के लिए नोट्स सही हैं (EG # B), लेकिन वे आपके कीबोर्ड पर सही ढंग से संरेखित नहीं हैं। ऐसा लगता है कि आप सही रास्ते पर हैं, हालांकि!

— कैमरन टिंकर

@CameronTinker कृपया अपनी स्क्रीन 90 डिग्री एंटीलॉकवाइज झुकाएं और फिर से देखें। ध्यान दें कि कीबोर्ड F से E तक चलता है, C से B तक मेरे पोस्ट में वर्णित कारणों के लिए नहीं। आंतरिक "शून्य नोट" के रूप में एफ चुनना गिटार और कीबोर्ड आउटपुट दोनों के लिए एक समझौता था। बाईं ओर 3 काले नोट हैं, दाईं ओर 2 और आउटपुट नोट सही ढंग से संरेखित हैं। बी और सी के बीच विभाजन का विस्तार करने से यह स्पष्ट हो जाएगा, लेकिन लगभग 20 अतिरिक्त बाइट खर्च होंगे। क्रूड यह है, लेकिन मुझे अभी भी लगता है कि मेरा कीबोर्ड पांडूबियर की तुलना में अधिक पठनीय है।

— लेवल रिवर सेंट

मुझे नहीं पता कि मैं कैसे चूक गया! उसके लिए माफ़ करना। मैं एक पियानोवादक और मेरा पहला झुकाव है जब मैंने देखा कि कीबोर्ड सही नहीं था;)।

— कैमरन टिंकर

@MathieuRodic मुझे अब Arduino से आवाज़ें मिल रही हैं, लेकिन वे इतने गरीब हैं कि मुझे यकीन नहीं है कि मैं उन्हें पहचानने योग्य कॉर्ड कहूंगा। मेरे पास एक और कोशिश होगी, लेकिन Arduino के साथ कुछ चीजें हो रही हैं जो मुझे समझ नहीं आ रही हैं। वैसे भी मैंने बस बीबीसी बेसिक में एक उत्तर कीबोर्ड और ध्वनि के साथ पोस्ट किया है जो बहुत बेहतर लग रहा है। इसलिए मैं इस पोस्ट को बाद में अपडेट करूंगा

— लेवल रिवर सेंट

Answer 4

पायथन 3 - 315 चार

कोडगोल्फ में पहली बार! अभी मामूली, प्रमुख, कम और संवर्धित तार का समर्थन करता है।

z=["C","C#","D","D#","E","F","F#","G","G#","A","A#","B"];y=[1,2,4,5,6]
def q(a):print(z[a%12])
a=input();k=(ord(a[0])+3)%7;j=k;m=4;s=0;f=7;
for i in y:
    if(k>=i):j+=1
if('#'in a):j+=1
if('b'in a):j-=1
if('m'in a or'0'in a):m=3
if('+'in a or"aug"in a):f=8
if('0'in a or"dim"in a):f=6;m=3
if('ma'in a):m=4
q(j);q(j+m);q(j+f);

Comments

'C C# D D# E F F# G G# A A# B'.split(' ')कुछ बाइट्स को बचाने के लिए अपने शाब्दिक सरणी के बजाय का उपयोग करें ।

— वचर्जिन

if('#'in a):j+=1-> if'#'in a:j+=1= हर कथन के लिए 2 वर्ण कम। साथ ही yएक range()एक्सप्रेशन को बदलने से भी कुछ बचता है। स्वागत हे! (और याद रखें कि

— नए अंक

@wch मोर बाइट्स के साथ बचाया जा सकता है 'C C# D D# E F F# G G# A A# B'.split();)

— भूमिगत

आपने अपना स्कोर कैसे गिना? मुझे लगता है कि आपको एक-एक कर नई लाइनों को गिनना होगा। वैसे, चूंकि यह उत्तर केवल पायथन 3 में काम करता है, मैं आपके उत्तर को स्पष्ट रूप से बताने के लिए संपादित करूँगा। इसके अलावा, yस्टोर करने के लिए उपयोग करने के बजाय [1,2,4,5,6], आप सिर्फ y4 को ही क्यों छोड़ते हैं और लाइन को प्रतिस्थापित नहीं करते हैं for i in[1,2,4,5,6]:? वैसे भी, कोडगुल्फ़ में आपका स्वागत है और मुझे उम्मीद है कि आप यहाँ मज़े करेंगे।

— ace_HongKongIndependence

तुम भी लाइन 5 में चार के बजाय केवल एक ही स्थान के साथ इंडेंट करके 3 और

— चार्ट

Answer 5

पायथन 506 (यूनिकोड 1 चर के रूप में) -150 (ध्वनि) -150 (कीबोर्ड) = 206

ध्वनि बजाने के लिए, यह उपयोग करता है pygame.midi। ध्यान दें कि pygame.midi.get_default_output_id()विधि बहुत अच्छी तरह से काम नहीं करती है। तो अगर आप लाइन को बदलने की कोशिश कर सकते o=Output(get_default_output_id())करने के लिए o=Output(1), o=Output(2)आदि आम तौर पर सही मान 0 और 5 के बीच है।

c=input()
s='C D EF G A B'.index(c[0])+{'#':1,'b':-1,'':0}[c[1:-1]]
m='0mM+'.index(c[-1])
t=s+3+m//2
R=[list(x)for x in['┌─'+'─┬─'*13+'─┐']+['│'+'  │'*14]*5+['└─'+'─┴─'*13+'─┘']]
i=3
for d in[3,6,3,3,6]*2:q=slice(i-1,i+2);R[0][q]='┬─┬';R[1][q]=R[2][q]=R[3][q]='│ │';R[4][q]='└┬┘';i+=d
X=[2]+[1,2,1,2,3,1,2,1,2,1,2,3]*2
from pygame.midi import*
init()
o=Output(get_default_output_id())
for s in[s,t,t+3+m%2]:R[[5,3][s%12 in[1,3,6,8,10]]][sum(X[:s+1])]='o';o.note_on(s+60,127,1)
for r in R:print(''.join(r))

परिणाम

goooolf> python chords2.py
CM
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│ o│  │ o│  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
Cm
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││o│ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│ o│  │  │  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
Dm
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │ o│  │ o│  │ o│  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
D+
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │o││ ││o│ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │ o│  │  │  │  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
G+
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││o│ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │  │  │ o│  │ o│  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
Am
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │  │  │  │ o│  │ o│  │ o│  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
C#0
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │o││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │ o│  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
EbM
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││o│ │ │ ││ ││o│ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │  │  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘

Answer 6

जे - 82 चार

स्व-निहित, कंसोल इनपुट से पढ़ता है। यदि आपको स्टडिन की आवश्यकता है, तो फाइनल 1को ए में बदलें 3। कोई बोनस का दावा नहीं करता है, और केवल तीनों को कवर करता है।

+/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1

तेज नोट के बजाय उदाहरण के लिए C#आपको समतुल्य समतल नाम का उपयोग करना चाहिए Db। (इस के लिए ठीक एक सा की तुलना में अधिक से कोड बढ़ जाएगा।) Chords के चार प्रकार हैं 0, ह्रासमान के लिए mनाबालिग के लिए, Mप्रमुख के लिए, और +के लिए संवर्धित।

तर्क निम्नानुसार है: हम अंतिम चरित्र का उपयोग आधार में ऑफसेट को जोड़ने के लिए 0-3-6 करते हैं, जो तीसरे और पांचवें प्रकार का चयन करता है। इस बीच, हम नोट का उपयोग उस पैमाने को खोजने में करते हैं जहां से नोटों को खींचने के लिए पैमाने में है। ;:दोनों टिप्पणी शुरू में पैमाने में का अनुक्रमण के साथ संगत, और बाद में (द्वारा बनाता है &.) एक अंतरिक्ष में खींच लिया नोटों स्ट्रिंग अलग कर देता है।

उदाहरण का उपयोग:

   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
AM
A Ch E
   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
Ab0
Ab B D
   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
B+
B Eb G
   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
Em
E G B

Comments

क्या प्रत्यय "एच" "संगीत संकेतन मानकों" में से एक का पालन करता है?

— मैथ्यू रोडिक

@ मैथियोरोडिक मुझे लगता है कि यह एक ग्रे क्षेत्र है, इसलिए मैंने उन सभी को फ्लैटों तक पहुंचा दिया। कार्यक्षमता में कोई बदलाव नहीं। पता नहीं मैंने ऐसा पहले क्यों नहीं किया।

— एल्गोरिथमशार्क

Answer 7

जावास्क्रिप्ट, 224 चार

n=prompt();a="A0A#0B0C0C#0D0D#0E0F0F#0G0G#".split(0);x=1;r=a.indexOf(n[0]);n[1]=="#"&&(r++,x++);n[1]=="b"&&(r--,x++);s=r+4;l=r+7;(n[x]=="m"||n[x]==0)&&s++;s%=12;n[x]=="+"&&l++;n[x]==0&&l--;l%=12;alert(a[r]+" "+a[s]+" "+a[l])

यह मेरा पहला कोड गोल्फ है। मुझे लगता है कि यह छोटा हो सकता है, लेकिन मुझे बचाने के लिए कोई बाइट नहीं मिल सकती है।

समर्थन प्रमुख, mनाबालिग के लिए 0कम के लिए, +के लिए संवर्धित, या 37 से अधिक के लिए बाइट्स dim, aug।

Comments

n[m]==0बस हो सकता है !n[m]। उसी जगह पर लागू होता है। कुल आप 6 वर्ण आसानी से काट सकते हैं ।

— गौरांग टंडन

@GaurangTandon चूंकि nस्ट्रिंग है , इसलिए इसे n[m]==0कास्ट 0किया जाएगा "0", इसलिए यह इसके बराबर है n[m]=="0"। "0" == 0सच है, लेकिन !"0"गलत है।

— स्नैक

मैं सिर्फ इशारा कर रहा था क्योंकि मुझे इनपुट करने पर वही आउटपुट मिला AM। मैं गलत भी हो सकता हूं।

— गौरांग टंडन

Answer 8

पायथन ( 143 134 वर्ण)

n,a='A A# B C C# D D# E F F# G G#'.split(),input();m,i=ord(a[-1])-42,n.index(a[:-1])
print(n[i],n[(i+4-m//2)%12],n[(i-4+(-m//2))%12]) 

मेरी पहली गोल्फ चुनौती :), कुछ और बाइट्स का मुंडन किया जा सकता है पता नहीं है।
यहाँ उपयोग की गई संकेतनता है * aug / + maj /, min / - मंद
I कोड में स्थिर 42 होने के लिए एक बोनस बिंदु के लायक है: P

Comments

आप इस तरह से कुछ बाइट्स प्राप्त कर सकते हैं:n,q,a='A A# B C C# D D# E F F# G G#'.split(),[4,4,3,3],input();m,i=ord(a[-1])-42,n.index(a[:-1])

— मैथ्यू रोडिक

Answer 9

पायथन 3: 257 - 150 = 107

J समाधान को हरा देने के लिए बस 25 वर्ण बहुत लंबे हैं! ओह अच्छा। मुझे लगता है कि कुछ साफ-सुथरे विचार हैं।

I='AaBCcDdEFfGg'*2
Q='0123456789.,'*2
K="""-1#_2
-,#_0
-9#_.
____8
-6#_7
-4#_5
____3"""
r,*R,q=input()
r=I.find(r)+bool(R)
p=str.replace
for x in[0]+[8,4,7,3,6]['+Mm0'.find(q):][:2]:K=p(K,Q[x+r],I[x+r].upper())
for x in Q:K=p(K,x,' ')
print(p(K,' #','  '))

इनपुट उदाहरणों की तरह है, हालांकि आपको फ्लैट नामों के बजाय तीखे नामों का उपयोग करना होगा। (उदाहरण Gb F # होना चाहिए)

आउटपुट पियानो का एक एकल सप्तक है, जो ऊपर और बाईं ओर से देखा गया है, जिसमें नोट नाम सुपरिंपोज किया गया है। कल्पना का सिर्फ एक छोटा सा खिंचाव होना चाहिए।

$ echo C#m | python3 chords.py
-  _ 
-G#_ 
-  _ 
____ 
-  _E
-C#_ 
____ 

Comments

अच्छी नौकरी! हालाँकि, मुझे आउटपुट में खेलने के लिए नोट्स नहीं दिख रहे हैं? के लिए CM, हमें पढ़ने में सक्षम होना चाहिए C E G...

— मैथ्यू रोडिक

ओह, मुझे लगता है कि मुझे लगता है कि सवाल गलत है। आइए देखें कि क्या मैं इसमें काम कर सकता हूं ...

— pandubear

फिक्स्ड! बहुत लंबा ...):

— पाँडुबियर

आप को बदल नहीं सकता bool(R)के साथ R|0?

— मैथ्यू रोडिक

नाह, बिंदु यह है कि आर एक सूची है और bool(R)यदि खाली है तो 1 (सत्य) है और यदि खाली है तो 0 (गलत)। |ऑपरेटर सूचियों साथ काम नहीं करता ...

— pandubear

Answer 10

स्काला 537 चरस - 50

import java.util.Scanner
object C extends App{
val c=Map("M"->145,"m"->137,"+"->273,"0"->73,"7"->1169,"M7"->2193,"m7"->1161,"Mm7"->2185,"+7"->1297,"+M7"->2321,"07"->585,"7b5"->1097)
val n=List("A","A#","B","C","C#","D","D#","E","F","F#","G","G#")
val o=List("","Bb","Cb","B#","Db","","Eb","Fb","E#","Gb","","Ab")
val s=new Scanner(System.in).nextLine
val v=s indexWhere{c=>c!='#'&&c!='b'&&(c<'A'||c>'G')}
val (u,m)=s splitAt v
val x=n.indexOf(u)max o.indexOf(u)
val k=c(m)
for(i<-0 to 11)if((k&(1<<i))!=0)print(n((i+x)%12)+" ")
println}

Answer 11

हास्केल, 273 वर्ण

n(s,a)="CCDDEFFGGAABB"!!(s+1-a):["b#"!!a|" b b  b b b "!!s/=' ']
t p=[(s,a)|s<-[11,10..0],a<-[0,1],n(s,a)==p]!!0
m(s,d)=n(mod s 12,d-3)
c q=[n(a,x),m(a+d,d),m(a+d+e,e)]where
 (a,x)=t$init q;f=lookup(last q).zip"0mM+";Just d=f[3,3,4,4];Just e=f[3,4,3,4]
main=print.c=<<getLine

परिणाम

C0 ->["C","Eb","Gb"]   Cm ->["C","Eb","G"]    CM ->["C","E","G"]     C+ ->["C","E","G#"]    
C#0->["C#","F","G"]    C#m->["C#","F","G#"]   C#M->["C#","F","Ab"]   C#+->["C#","F","A"]    
D0 ->["D","F","Ab"]    Dm ->["D","F","A"]     DM ->["D","F#","A"]    D+ ->["D","F#","A#"]   
D#0->["D#","Gb","A"]   D#m->["D#","Gb","A#"]  D#M->["D#","G","Bb"]   D#+->["D#","G","B"]    
E0 ->["E","G","Bb"]    Em ->["E","G","B"]     EM ->["E","G#","B"]    E+ ->["E","G#","C"]    
F0 ->["F","Ab","B"]    Fm ->["F","Ab","C"]    FM ->["F","A","C"]     F+ ->["F","A","C#"]    
F#0->["F#","A","C"]    F#m->["F#","A","C#"]   F#M->["F#","A#","Db"]  F#+->["F#","A#","D"]   
G0 ->["G","Bb","Db"]   Gm ->["G","Bb","D"]    GM ->["G","B","D"]     G+ ->["G","B","D#"]    
G#0->["G#","B","D"]    G#m->["G#","B","D#"]   G#M->["G#","C","Eb"]   G#+->["G#","C","E"]    
A0 ->["A","C","Eb"]    Am ->["A","C","E"]     AM ->["A","C#","F"]    A+ ->["A","C#","F"]    
A#0->["A#","Db","F"]   A#m->["A#","Db","F"]   A#M->["A#","D","F"]    A#+->["A#","D","F#"]   
B0 ->["B","D","F"]     Bm ->["B","D","F#"]    BM ->["B","D#","Gb"]   B+ ->["B","D#","G"]