दल Segno और डा कापो दो बहुत अधिक इस्तेमाल किया संगीत की शर्तें हैं। उनका अर्थ है " संकेत से " (𝄋) और " शुरुआत से " क्रमशः।

कोड़ा (also) का विचार भी है , जो संगीत के एक टुकड़े का बहुत अंत है। यह टुकड़ा के "मुख्य अनुभाग" के बाद खेला जाता है।

उदाहरण के लिए, एक डीएस अल कोडा ( दाल सेग्नो अल कोडा ), का अर्थ है " सेग्नो पर जाएं , जब तक आपको कोड़ा में जाने के लिए नहीं कहा जाता है, तब तक खेलें और फिर वहां कूदें।"

विवरण

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

इनपुट

आपका कोड इनपुट के रूप में या तो नोट्स या सिग्नल्स के अनुक्रम के रूप में लेना चाहिए (यहां कुछ भी लेकिन एक नोट के रूप में परिभाषित किया गया है), एक स्ट्रिंग में रिक्त स्थान द्वारा अलग किया गया।

नोट्स के किसी भी कर रहे हैं a, b, c, d, e, f, या g, एक वैकल्पिक साथ #या bसंलग्न (इस चुनौती के प्रयोजनों के लिए, वहाँ कोई लय है)।
ए C(कैपिटल सी) एक कोडिंग अंकन का प्रतिनिधित्व करता है । हमेशा या तो शून्य या दो कोडा अंकन होंगे; पहला कोडा मार्किंग दर्शाता है कि कहां से कूदना है, और दूसरा यह दर्शाता है कि कहां कूदना है।
एक S(पूंजी एस) एक साइनो अंकन का प्रतिनिधित्व करता है । हमेशा या तो शून्य या एक साइनो मार्किंग होगी।
एक F(पूंजी एफ) एक ठीक अंकन का प्रतिनिधित्व करता है । यह टुकड़े के अंत को "ओवरराइड करता है" - उस पर अधिक। हमेशा या तो शून्य या एक ठीक अंकन होगा।
पाठ के निम्नलिखित सटीक तारों में से कोई भी प्रतिनिधित्व करता है:
- D.S. al fine: साइनो पर जाएं और टुकड़े के अंत तक या ठीक अंकन (यदि यह मौजूद है) तक खेलें ।
- D.S. al coda: साइनो पर जाएं , कोड़ा तक खेलते हैं , फिर दूसरे कोडा को चिह्नित करें और टुकड़े के अंत तक खेलें।
- D.C. al fine: शुरुआत में जाएं, अंत तक या ठीक अंकन तक खेलें ।
- D.C. al coda: शुरुआत में जाएं, कोड़ा तक खेलें , फिर दूसरे कोडा के निशान पर जाएं और टुकड़े के अंत तक खेलें।
हमेशा शून्य से न्यूनतम और प्रत्येक स्ट्रिंग में अधिकतम एक स्ट्रिंग होगी। एक टुकड़े में कई al fineएस या एकाधिक al codaएस कभी नहीं होंगे ।

उत्पादन

आपका कोड समान स्ट्रिंग प्रारूप में आउटपुट होना चाहिए: रिक्त स्थान द्वारा अलग किए गए नोट्स की एक सूची।

आप हमेशा मान सकते हैं कि आउटपुट एक या अधिक वर्णों के लंबे होने का अंत करेगा।

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

में: a# bb c b a
बाहर:a# bb c b a

में: a S b D.S. al fine c
बाहर:a b b c

में: a S b C c D.S. al coda d C e
बाहर:a b c b e

में: a b F c d D.C. al fine e f
बाहर:a b c d a b

में: a b D.C. al fine c d F e f
बाहर:a b a b c d

में: a b C c d D.C. al coda e f C g g#
बाहर:a b c d a b g g#

में: a b D.C. al coda c d C e f C g g#
बाहर:a b a b c d g g#

में: a b S c d C D.C. al coda C D.S. al fine e f F g
बाहर:a b c d a b c d c d e f

में: a S b C c D.S. al coda C d D.S. al fine e F f
बाहर:a b c b d b c d e

में: a b C c d D.C. al coda e f F g g# C gb a# D.C. al fine
बाहर:a b c d a b gb a# a b c d e f

में: a F b C D.C. al coda C D.C. al fine
बाहर:a b a b a

में: C a S b D.C. al coda C c D.S. al fine d
बाहर:a b c b c d

में: a S b D.S. al coda C C c D.C. al fine
बाहर:a b b c a b c

में: a F C b C D.C. al coda D.C. al fine
बाहर:a b a a

नियम

अंकन हमेशा एक तार्किक क्रम में दिखाई देगा। अर्थात्, एक के Sबाद कभी नहीं होगा D.S.और हमेशा एक से पहले होगा, आदि।
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाएगा।

code-golf music

— Doorknob
स्रोत

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

x=>eval('n=(" "+x).replace(/D.{11}|[CSF]/g,d=>({C:4,S:5,F:6}[d]|(d[2]<"S")*2+(d[8]<"f"))).split` `;for(i=c=f=o="";v=n[++i];v<9?v<4?(n[i]=7,i=0,s=n.indexOf`5`,v==0?f=i=s:v==1?c=i=s:v==2?f=1:c=1):v==4&c?c=!(i=n.indexOf("4",i+1)):v==6&f?i=n:0:o+=v+" ");o')

व्याख्या

बेहतर गोल्फ हो सकता है लेकिन मैं अभी के लिए कर रहा हूँ।

x=>
  eval(`                                  // use eval to enable for loop without return
    n=(" "+x)                             // n = array of [ "", ...notes/commands ]
                                          // empty first element means f and c can be set
                                          //     to i (always true) in the cases below
      // DS fine => 0, DS coda => 1, DC fine => 2, DC coda => 3, C => 4, S => 5, F => 6
      .replace(/D.{11}|[CSF]/g,d=>({C:4,S:5,F:6}[d]|(d[2]<"S")*2+(d[8]<"f")))
      .split\` \`;
    for(
      i=                                  // i = position in note array
      c=                                  // c = look out for coda if true
      f=                                  // f = look out for fine if true
      o="";                               // o = output string
      v=n[++i];                           // v = note/command
      v<9?                                // if not a note
        v<4?(                             // if DS/DC
          n[i]=7,                         // change it to NOP
          i=0,                            // reset i here to save doing it in DC cases
          s=n.indexOf\`5\`,
          v==0?f=i=s:                     // case: D.S. al fine
          v==1?c=i=s:                     // case: D.S. al coda
          v==2?f=1:                       // case: D.C. al fine
          c=1                             // case: D.C. al coda
        ):
        v==4&c?c=!(i=n.indexOf("4",i+1)): // case: C
        v==6&f?i=n:                       // case: F
        0                                 // case: S
      :o+=v+" "                           // add the note
    );o                                   // return the output
  `)

परीक्षा

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

var solution = x=>eval('n=(" "+x).replace(/D.{11}|[CSF]/g,d=>({C:4,S:5,F:6}[d]|(d[2]<"S")*2+(d[8]<"f"))).split` `;for(i=c=f=o="";v=n[++i];v<9?v<4?(n[i]=7,i=0,s=n.indexOf`5`,v==0?f=i=s:v==1?c=i=s:v==2?f=1:c=1):v==4&c?c=!(i=n.indexOf("4",i+1)):v==6&f?i=n:0:o+=v+" ");o')

<input type="text" id="input" value="a b C c d D.C. al coda e f F g g# C gb a# D.C. al fine" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

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

— user81655
स्रोत

संगीतमय कूदता है