चलो संगीत बनाओ!

Question

बहुत सारे लोग मनोरंजन और मनोरंजन के लिए संगीत बजाना पसंद करते हैं। दुर्भाग्य से, संगीत कभी-कभी बहुत मुश्किल होता है। यही कारण है कि आप यहाँ हैं!

कार्य

यह आपका काम है कि इससे जूझ रहे लोगों के लिए संगीत पढ़ना बहुत आसान बना दें। आपको एक प्रोग्राम या फ़ंक्शन लिखने की ज़रूरत है जो इनपुट के रूप में एक म्यूज़िकल स्टाफ लेता है, और उस स्टाफ पर लिखे गए नोट्स के नाम आउटपुट करता है।

स्टाफ, फांक, और नोट्स

एक संगीत स्टाफ , या स्टैव, पांच क्षैतिज रेखाएं हैं, इनबेटइन जो चार स्थान हैं। प्रत्येक पंक्ति या स्थान एक अलग नोट (पिच) का प्रतिनिधित्व करता है, जो कि फांक पर निर्भर करता है।
वहाँ से चुनने के लिए कुछ अलग-अलग संगीत क्लीफ़ हैं, लेकिन हम केवल अब के लिए एक के साथ काम करेंगे: तिगुना फांक । तिगुना फांक पर, नोटों को कर्मचारियों पर निम्नानुसार दर्शाया गया है:

पंक्तियां
एफ ----------
D ----------
बी ----------
जी ----------
इ ----------

रिक्त स्थान  
   ----------  
इ
   ----------  
सी
   ----------  
ए
   ----------  
एफ
   ----------

इनपुट का प्रारूपण

इनपुट एक स्ट्रिंग के रूप में दिया जाएगा, इस प्रकार है:

---------------

---------------

---------------

---------------

---------------

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

इस स्टाफ पर उपयुक्त -या पात्र के स्थान पर नोट रखे जाते हैं o। नोट्स को सेमीिटोन (एक नोट और उसके आसन्न नोटों के बीच लगभग आधा आवृत्ति अंतर) द्वारा पिच में (तेज) या कम (सपाट) उठाया जा सकता है। यह वर्णों द्वारा #और bक्रमशः के स्थान पर दर्शाया जाएगा o। प्रत्येक टिप्पणी ठीक दो से अगले से अलग किया जाएगा -वर्ण, और पहले ध्यान दें हमेशा के पहले "कॉलम" को उत्पन्न होगा -और (स्थान) वर्ण।

नोट नामों को आउटपुट करते समय, आपके कार्यक्रम को हमेशा A B C D E F Gकर्मचारियों पर दिए गए नोट के अनुरूप बड़े अक्षरों ( ) का उपयोग करना चाहिए । तेज ( #) और सपाट ( b) नोटों के लिए, आपके कार्यक्रम को नोट के अनुरूप पत्र में क्रमशः #और जोड़ना होगा b। एक प्राकृतिक नोट के लिए जो तेज या सपाट नहीं है, इसके स्थान (स्पेस) को जोड़ा जाना चाहिए।

उदाहरण

इनपुट:

--------------------- o--
                  ओ     
--------------- ओ --------
            ओ           
--------- ख --------------
      ओ                 
--- ओ --------------------
ओ                       
------------------------

* इस उदाहरण में सभी "खाली स्थान" पर ध्यान दें वास्तव में (अंतरिक्ष चरित्र) है।
इस मामले में (एक साधारण एफ प्रमुख पैमाने पर), आपके कार्यक्रम को इसका उत्पादन करना चाहिए:

FGA Bb CDEF

ध्यान दें कि आउटपुट के पात्रों के बीच रिक्ति ठीक उसी तरह से ऊपर दिखाई जानी चाहिए, जैसा कि कर्मचारियों पर नोट्स के साथ सही ढंग से फिट होने के लिए। सभी नोट नामों के बीच दो देखते हैं (स्थान) वर्ण, के बीच छोड़कर Bbऔर C। bयहाँ से एक की जगह (स्थान) वर्ण।

एक अन्य उदाहरण
इनपुट:

------------------------
                     ओ  
------------------ # -----
               #        
------------ ओ -----------
         ओ              
------ # -----------------
   #                    
ओ -----------------------

आउटपुट:
E F# G# A B C# D# E

सौभाग्य
इनपुट के लिए एक और उदाहरण :

---------------------
oooo           
---------------------
         ओ              
---------------------

--------------- ओ - o--

---------------------

आउटपुट:
E E E C E G G

नियम

• नोट कभी भी ई फ्लैट अप की पाँच लाइन स्टाफ रेंज में दिए जाएंगे F शार्प (चुनौतियों को छोड़कर, नीचे देखें)
• कोई भी नोट तेज या सपाट हो सकता है, न कि केवल सामान्य रूप से संगीत में देखे जाने वाले (जैसे कि B # वास्तव में सिर्फ C के रूप में खेला जा रहा है, B # इनपुट में अभी भी हो सकता है)
• आप मान सकते हैं कि प्रति 3 कॉलम में एक ही नोट होगा (इसलिए इसमें कोई कॉर्ड या ऐसा कुछ भी नहीं होगा, और कोई भी टाँग नहीं होगी)
• आप मान सकते हैं कि अंतिम नोट बिना किसी नोट के दो कॉलम के बाद होगा
• आप यह मान सकते हैं कि कर्मचारियों की अंतिम पंक्ति के बाद भी एक ही नई लाइन चरित्र होगी
• इनपुट को एसटीडीआईएन (या भाषा समकक्ष) या फ़ंक्शन पैरामीटर के रूप में लिया जाना चाहिए
• आउटपुट होना चाहिए STDOUT (या भाषा के बराबर) या एक वापसी परिणाम के रूप में यदि आपका कार्यक्रम एक फ़ंक्शन है
• मानक खामियों और अंतर्निहित इन्स की अनुमति है! संगीत प्रयोग करने और आसपास बजाने के बारे में है। अपनी भाषा के साथ आगे बढ़ें और मज़े करें (हालाँकि पहचानें कि खामियों का फायदा उठाना शायद सबसे दिलचस्प कार्यक्रम नहीं होगा)
• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कार्यक्रम है

बोनस चुनौतियों

• -10% यदि आपका प्रोग्राम कर्मचारियों की शीर्ष पंक्ति (G, G #, Gb) के ऊपर स्थान को सफलतापूर्वक संसाधित कर सकता है।
• -10% यदि आपका प्रोग्राम कर्मचारियों की निचली पंक्ति (डी, डीबी, डीबी) के नीचे की जगह को सफलतापूर्वक संसाधित कर सकता है
• इन मामलों में आपका कार्यक्रम शुरू और अंत में एक अतिरिक्त पंक्ति इनपुट के रूप में ले जाएगा; इन पंक्तियों को अन्य नौ पंक्तियों के समान ही माना जाना चाहिए

Comments

हां, मुझे एहसास है कि एक मेरे सवाल से काफी मिलता-जुलता है। हालाँकि, उस एक को केवल एक ही उत्तर मिला। मैं अधिक भाषाओं को शामिल करने के लिए कुछ सरल बनाने की उम्मीद कर रहा था। और वास्तव में, मेरा मानना ​​है कि चुनौती में विपरीत, नोट्स को कर्मचारियों में परिवर्तित करना शामिल है।

— MC MCT

Answer 1

CJam ( 40 37 * 0.8 = 29.6 अंक)

qN/z3%{_{iD%6>}#_~'H,65>=@@=+'oSerS}%

ऑनलाइन डेमो

वास्तव में कुछ पूर्व-परिभाषित चर इंगित करने के लिए धन्यवाद, जिनके बारे में मैं भूल गया था।

Comments

बहुत साफ़! आप अंतरिक्ष वर्णों के लिए S का उपयोग करके कुछ बाइट्स शेव कर सकते हैं। इसके अतिरिक्त, आप 13 को D.

— MC youT

Answer 2

रूबी, 106 बाइट्स * 0.8 = 84.8

->s{a=' '*l=s.index('
')+1
s.size.times{|i|s[i].ord&34>33&&(a[i%l,2]='GFEDCBA'[i/l%7]+s[i].tr(?o,' '))}
a}

परीक्षण कार्यक्रम में अपराजित

f=->s{a=' '*l=s.index('
')+1                                 #l = length of first row, initialize string a to l spaces
  s.size.times{|i|                   #for each character in s
  s[i].ord&34>33&&                   #if ASCII code for ob#
   (a[i%l,2]=                        #change 2 bytes in a to the following string
   'GFEDCBA'[i/l%7]+s[i].tr(?o,' '))}#note letter, and copy of symbol ob# (transcribe to space if o)
a}                                   #return a



t='                        
---------------------o--
                  o     
---------------o--------
            o           
---------b--------------
      o                 
---o--------------------
o                       
------------------------

'

u='                        
------------------------
                     o  
------------------#-----
               #        
------------o-----------
         o              
------#-----------------
   #                    
o-----------------------

'

v='                     
---------------------
o  o  o     o        
---------------------
         o           
---------------------

---------------o--o--

---------------------

'

puts f[t]
puts f[u]
puts f[v]

Answer 3

जावास्क्रिप्ट (ईएस 6), 144 बाइट्स - 20% = 115.2

f=s=>(n=[],l=s.indexOf(`
`)+1,[...s].map((v,i)=>(x=i%l,h=v.match(/[ob#]/),n[x]=h?"GFEDCBAGFED"[i/l|0]:n[x]||" ",h&&v!="o"?n[x+1]=v:0)),n.join``)

व्याख्या

f=s=>(
  n=[],                      // n = array of note letters
  l=s.indexOf(`
`)+1,                        // l = line length
  [...s].map((v,i)=>(        // iterate through each character
    x=i%l,                   // x = position within current line
    h=v.match(/[ob#]/),      // h = character is note
    n[x]=                    // set current note letter to:
      h?"GFEDCBAGFED"[i/l|0] //     if it is a note, the letter
      :n[x]||" ",            //     if not, the current value or space if null
    h&&v!="o"?n[x+1]=v:0     // put the sharp/flat symbol at the next position
  )),
  n.join``                   // return the note letters as a string
)

परीक्षा

कर्मचारियों के ऊपर एक लाइन जोड़ना याद रखें जो अन्य लाइनों की सटीक लंबाई है क्योंकि इस समाधान में कर्मचारियों के ऊपर और नीचे की लाइनों को पार्स करना शामिल है।

f=s=>(n=[],l=s.indexOf(`
`)+1,[...s].map((v,i)=>(x=i%l,h=v.match(/[ob#]/),n[x]=h?"GFEDCBAGFED"[i/l|0]:n[x]||" ",h&&v!="o"?n[x+1]=v:0)),n.join``)

<textarea id="input" style="float:left;width:200px;height:175px">                        
---------------------o--
                  o     
---------------o--------
            o           
---------b--------------
      o                 
---o--------------------
o                       
------------------------
                        </textarea>
<div style="float:left">
  <button onclick="results.innerHTML=f(input.value)">Test</button>
  <pre id="results"></pre>
</div>