शीट संगीत ASCII- कला जनरेटर


31

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

चुनौती

इस तरह एक इनपुट दिया:

8g 8Df 4cs 2C 1A

सबसे छोटा प्रोग्राम / फ़ंक्शन लिखें जो इस तरह से आउटपुट उत्पन्न करता है:

    /\                                         -o-
   | |
---|-|---------------------------------------------------|-|
   |/                                                    | |
---/|--------|\----b-*-----------------------------------|-|
  / |        | |    |                  o                 | |
-|--|--------|------|-----------------|------------------|-|
 | (| \      |      | |               |                  | |
-|--|--)----*-------|/---------|------|------------------|-|
  \ | /                        |      |                  | |
-----|-------------------------|-------------------------|-|
     |                         |
   *_/                      #-*-

नियम

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

    /\  
   | |
---|-|--
   |/   
---/|---
  / |   
-|--|---
 | (| \ 
-|--|--)
  \ | / 
-----|--
     |  
   *_/
^
Single column

नोट अपने प्रकार के आधार पर *या किसी oवर्ण से शुरू होना चाहिए ।

हर *या oवर्ण के अलग-अलग आठ स्तंभ होने चाहिए :

    /\                                         -o-
   | |
---|-|---------------------------------------------------|-|
   |/                                                    | |
---/|--------|\----b-*-----------------------------------|-|
  / |        | |    |                  o                 | |
-|--|--------|------|-----------------|------------------|-|
 | (| \      |      | |               |                  | |
-|--|--)----*-------|/---------|------|------------------|-|
  \ | /                        |      |                  | |
-----|-------------------------|-------------------------|-|
     |                         |
   *_/                      #-*-
   ↑        ↑        ↑        ↑        ↑        ↑        ↑
   8 columns of separation

उदाहरण में दिखाए अनुसार कर्मचारियों को दाएं से संरेखित टर्मिनेटर के साथ समाप्त होना चाहिए। टर्मिनेटर की बाईं पट्टी को अंतिम नोट से 8 कॉलम अलग किया जाना चाहिए।

इनपुट एक एकल स्ट्रिंग होगी जिसमें नोट्स होंगे (कम से कम एक, कोई खाली इनपुट नहीं), हर एक को व्हाट्सएप द्वारा अलग किया जाएगा (आप विचार कर सकते हैं कि हर नोट एक उचित होगा, इसलिए त्रुटियों की जांच करने की आवश्यकता नहीं है)। आप इनपुट को स्ट्रिंग्स के एक सरणी के रूप में भी ले सकते हैं, सरणी में प्रति तत्व एक नोट के साथ। प्रत्येक नोट के लिए, पहली चरित्र टिप्पणी लंबाई (के हर से हो जाएगा 1एक के लिए पूरे नोट / semibreve , साथ शुरू होता है o, 2एक के लिए आधा नोट / राग , के साथ शुरू होता o; 4एक के लिए तिमाही नोट / crotchet , के साथ शुरू होता *है, और 8एक के लिए आठवें नोट / योग्यता , के साथ शुरू होता है*)। दूसरा चरित्र टिप्पणी (तालिका देखें) हो जाएगा, और तीसरे, वैकल्पिक चरित्र होगा fया Fफ्लैट नोट्स के लिए और sया Sतेज नोट्स के लिए।

    ---    A (ledger line)
           G
--------   F
           E
--------   D
           C
--------   b
           a
--------   g
           f
--------   e
           d
    ---    c (ledger line)

जाहिर है, इनपुट को नोटों के मामले का सम्मान करना चाहिए, लेकिन आप fऔर sसंशोधक के मामले को चुन सकते हैं ।

नोट्स cऔर Aदो -(लेज़र लाइन) जोड़ना होगा , प्रत्येक पक्ष में एक, क्योंकि उन्हें कर्मचारियों का विस्तार करना होगा। नोट्स dऔर Gकर्मचारियों से बाहर हैं, लेकिन लेज़र लाइनों की आवश्यकता नहीं है।

नोट के बाईं ओर समतल या तीखे नोटों को जोड़ना bया जोड़ना होगा #

उपजी (यदि कोई हो) 4 ऊर्ध्वाधर सलाखों के साथ खींचा जाना चाहिए। bऊपर और नीचे के नोटों को नोट के बाईं ओर नीचे की ओर तने को खींचना चाहिए। aनीचे और नीचे से नोट के ऊपर और नीचे दाईं ओर के नोटों को खींचा जाना चाहिए। क्वैवर्स को हमेशा सही और बिल्कुल दिखाए गए झंडे को जोड़ना चाहिए, और अगर उनमें से कई एक पंक्ति में हैं, तो उन्हें बीम करने की आवश्यकता नहीं है।

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

-----|\----b-*------------
     | |    |             
-----|------|-------------
     |      | |           
----*-------|/---------|--
    ↑↑                 |  
----||------↑↑---------|--
    ||      ||         |
    ||      ||      #-*-
    |\      |\        ↑↑
    | Stem  | Note    | Stem
    Note    Stem      Note

हमेशा की तरह, आपका प्रोग्राम / फ़ंक्शन आउटपुट को सीधे आरेखित कर सकता है या एक स्ट्रिंग, ऐरे ऑफ स्ट्रिंग्स, मैट्रिक्स के अक्षर या किसी अन्य उचित प्रारूप को लौटा सकता है।

उपयोगी कड़ियाँ

यह , इसलिए प्रत्येक भाषा की जीत के लिए सबसे छोटा कार्यक्रम / कार्य हो सकता है!

बोनस: प्रसिद्ध धुनों के साथ उदाहरण लिखने की कोशिश करें और हर किसी को यह अनुमान लगाने की कोशिश करें कि यह कौन सा माधुर्य है!




... तो हम पत्र के मामले का उपयोग यह भी नहीं बता सकते हैं कि किस तरह से स्टेम को खींचना है?
नील

1
@ क्षमा करें, मुझे डर है कि आप नहीं कर सकते। मैंने उस नियम को नहीं बनाया, मैंने जाँच की कि : "तने आमतौर पर मध्य रेखा या उच्चतर पर नोटों के लिए नीचे की ओर इशारा करते हैं, और नीचे के लोगों के लिए"।
चार्ली

1
क्या हम इनपुट के रूप में, प्रत्येक स्ट्रिंग को एक ही नोट होने के साथ स्ट्रिंग की एक सरणी ले सकते हैं?
झबरा

जवाबों:


13

SOGL V0.12 , 178 175 174 173 172 171 बाइट्स

l9*6«+@*@¶¹┐∑:@┌ŗ4Ο"γ;]∑«;‽ΗmzΖH+īN D‼,ΨU‛y‚_○¤└yΨšI‘7n2∆╬5;{" -o-”;l3=?Jζ2%Ƨ#bWGk+;}Jz7m««:U+;W7«κArBb3>?Ζo*ŗ}a2\?┌@ŗ}ē9*LI+a╬5b1>?4┐∙b8=?"■QD³‘┼}e9*5+a4-8a>?5+;2-;G↕№}╬5

यह कोशिश करो! (θ उपयोग में आसानी के लिए जोड़ा गया; 171 बाइट्स के रूप में चलाने के लिए यह इनपुट स्टैक पर होने की उम्मीद करता है)

जहां तक ​​मैं इस काम को बता सकता हूं, लेकिन अगर आपको कोई समस्या है, तो मुझे बताएं।

स्पष्टीकरण:

पहला भाग: कैनवास निर्माण

l                                get the length of that array
 9*                              multiply by 9
   6«+                           add 12
      @*                         get that many spaces
        @¶                       push a space and a newline
          ¹                      put all the strings on the stack in an array
           ┐∑                    join with vertical bars
             :                   duplicate that string (which is a line with the ending barline but no staff)
              @┌ŗ                replace spaces with dashes (to make it a line with staff)
                 4Ο              encase 4 copies of the space lines in lines with the dashes
                   "...‘         push the G-clef without newlines
                        7n       split into an array of items of length 7
                          2∆╬5   at 1-indexed coordinates [2; -1] place the G-clef in the staff lines, extending the arrays size 
                              ;  get the input split on spaces back on top of the stack

दूसरा भाग: लूप, नोट हेड प्लेसमेंट

{                        loop over the input split on spaces
" -o-”                    push a template for a note head and leger lines
      ;                   get the input optop
       l3=?            }  if the length of the input is 3, then
           J                pop the last letter off from the input
            ζ               get its unicode point
             2%             modulo 2
               Ƨ#bW         get its index in "#b"
                   G        get the template ontop
                    k       remove its 1st letter
                     +      join the replaced input and the template
                      ;     get the input back ontop to be consisntent with how the if started

sidequest: parse the rest of the inputs
J                  pop the last letter off of the remaining input string (the note), leaving the note length as string on the stack below
 z                 push the lowercase alphabet
  7m               get its first 7 letters
    ««             put the first 2 at the end
      :            duplicate it
       U+          append it uppercased to the original
         ;W        get the notes letter ontop and get its 1-indexed index in that just created string
           7«κ     subtract it from 14
              A    save on variable A
               r   convert the note length to a number
                B  save on variable B

b3>?    }          if b>3 (aka if note length is either 4 or 8)
    Ζo*ŗ             replace "o" with "*"
         a2\?   }  if a divides by 2 (aka there isn't staff nor leger lines required)
             ┌@ŗ     replace "-" with " "

ē          push the value of variable E and after that increase it (default is user input number, which errors and defaults to 0)
 9*        multiply by 9
   LI+     increase by 11
      a    push variable a
       ╬5  at those positions (e*9+11, a) insert the note head template in the canvas

तीसरा भाग: झंडे और तने

b1>?                      if b (note length)>1 (aka if the stem is needed at all)
    4┐∙                   get an array of 4 vertical bars
       b8=?       }       if b==8 (aka if the flag is needed)
           "■QD³‘           push "\    |"
                 ┼          add verically-down-then-horizontally-right

e9*                       push e*9 (now e starts with 1 as it's been increased) (the X coordinate for the flag)
   5+                     add 5 to it
     a4-                  push a-4 (the Y coordinate, 4 less than the note head as arrays get inserted from the top-left corner)
        8a>?         }    if 8>a (aka if the flag needs to be rotated)
            5+              add 5 to the Y coordinate
              ;2-;          subtract 2 from the X coordinate
                  G         get the stem&flag or stem ontop
                   ↕№       reverse it vertically and mirror characters
                      ╬5  insert the array of the stem and maybe flag at those coordinates

आपका कोड लगभग सही है। एकमात्र नाइटपिक यह है कि 2bsआपके उदाहरण में नोट में नीचे की ओर इशारा करते हुए तना होना चाहिए।
चार्ली

@ करालोअल्जो तय
dimaima

महान! और स्पष्टीकरण के लिए धन्यवाद!
चार्ली

10

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

लगभग 90 बाइट्स निकालने के लिए धन्यवाद @shaggy

मुझे नोटों के बारे में कोई जानकारी नहीं थी ... अब तक, मुझे उम्मीद है कि यह सही है।

f=i=>i.map((v,p)=>(k[e=(w=q+12)*(l="AGFEDCbagfedc".search(v[1]))+p*9+12]="o*"[(s=v[0])>3|0],l<1|l>11&&(k[e-1]=k[e+1]="-"),(t=v[2])&&(k[e-2]="b#"[t>"f"|0]),--s&&[1,2,3,4].map(i=>(k[(b=l<8)?e+w*i-1:e-w*i+1]="|",s>6&&( b?k[e+w*4]="/":k[e-w*4+2]="\\",k[b?e+w*3+1:e-w*3+3]='|')))),k=[...`    /\\  ${s=" ".repeat(q=i.length*9)}  
   | |  ${s}    
---|-|--${l="-".repeat(q)+"|-|"}
   |/   ${t=s+"| |"}
---/|---${l}
  / |   ${t}
-|--|---${l}
 | (| \\ ${t}
-|--|--)${l}
  \\ | / ${t}
-----|--${l}
     |  ${s}   
   *_/  ${s}`])&&k.join``

console.log(f(["8g","8Df","4cs","2C","1A"]))
.as-console-wrapper { max-height: 100% !important; top: 0 }
.as-console-row:after { display: none !important; }

व्याख्या

f=i=>i.map((v,p)=>( // for each note

  k[e=(w=q+12)*(l="AGFEDCbagfedc".search(v[1]))+p*9+12]= // position in 1D array to set the note to
  "o*"[(s=v[0])>3|0], // note value (either o or *)

  l<1|l>11&&(k[e-1]=k[e+1]="-"), // add leger line

  (t=v[2])&&(k[e-2]="b#"[t>"f"|0]), // add sharp or flat

  --s&&[1,2,3,4].map(i=> // add the 4 stem lines
                     (k[(b=l<8)?e+w*i-1:e-w*i+1]="|", // durration over eigth note => add stem

                      s>6&&( // if to add a flag
                        b?k[e+w*4]="/":k[e-w*4+2]="\\", // add flag either on left or the right side

                        k[b?e+w*3+1:e-w*3+3]='|') // add the line after the flag
                     )
                    )
),
// template, extended to the final length with lines
k=[...`    /\\  ${s=" ".repeat(q=i.length*9)}  
   | |  ${s}   
---|-|--${l="-".repeat(q)+"|-|"}
   |/   ${t=s+"| |"}
---/|---${l}
  / |   ${t}
-|--|---${l}
 | (| \\ ${t}
-|--|--)${l}
  \\ | / ${t}
-----|--${l}
     |  ${s}   
   *_/  ${s}`])&&k.join``

मैं लगता है कि आप को सहेज कर कुछ बाइट्स बचा सकता है t[0]और t[2], और फिर बस करोq=t.length*9
स्टीफन

2
PPCG में आपका स्वागत है। बहुत अच्छा पहला जवाब :) एक अच्छा सा और अधिक गोल्फ है जो किया जा सकता है, हालांकि। मैंने इस पर एक त्वरित पास लिया और इसे 520 बाइट्स तक ले गया , जिससे आपको एक अच्छी शुरुआत मिलनी चाहिए।
झबरा

निश्चित रूप से कुछ की जगह + atob / btoa कुछ बाइट्स को
बचाएगी

1
@ शिवाय आपका बहुत बहुत धन्यवाद। मुझे बहुत कुछ सीखना है।
आर्क्स

आपका स्वागत है :) आपके पास एक भटका स्थान है s>6&&(जिसके बाद आप एक बाइट बचा सकते हैं। तुम भी बदल कर के साथ एक और बाइट बचा सकता है (w=q+12)के साथ w, repeat(q=i.length*9)के साथ repeat(w=i.length*9)और repeat(q)साथ repeat(w,w+=12)
झबरा

9

चारकोल , 180 171 168 163 बाइट्स

F⁵⁺⸿⸿×-⁺²⁷×⁸№θ ↑⁹←↙↓⁹J⁴¦⁹↑⁶↗¹↑²↖¹↓↙¹↓³↙²↓³ \M²↑(| ↘¹↙)↙¹↓²↙¹↑←_*F⪪θ «A⌕AGFEDCbagfedc§ι¹λJχλA⁺⁹χχ¿⁼³Lι§b#⁼§ι²s→P׳¬﹪λ²→P§o*›ι4¿›ι2¿›λ⁶«↗↑⁴¿›ι8«↘↘¹↓¹»»«↙↓⁴¿›ι8«↗↗¹↑¹

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

F⁵⁺⸿⸿×-⁺²⁷×⁸№θ ↑⁹←↙↓⁹

स्टैव को प्रिंट करें।

J⁴¦⁹↑⁶↗¹↑²↖¹↓↙¹↓³↙²↓³ \M²↑(| ↘¹↙)↙¹↓²↙¹↑←_*

फांक को प्रिंट करें।

F⪪θ «

प्रत्येक नोट के माध्यम से लूप।

A⌕AGFEDCbagfedc§ι¹λ

नोट का Y- समन्वय ज्ञात कीजिए।

JχλA⁺⁹χχ

यह वास्तव में डरपोक है: χएक चर है जो 10 में पूर्वनिर्धारित है, जो कि पहले नोट के आकस्मिक के एक्स-समन्वय है, अगर यह एक है। उस स्थिति में कूदने के बाद, 9 को इसमें जोड़ा जाता है, अगले नोट की स्थिति का प्रतिनिधित्व करता है।

¿⁼³Lι§b#⁼§ι²s→

एक होने पर आकस्मिक प्रिंट करें।

P׳¬﹪λ²→P§o*›ι4

यदि आवश्यक हो और नोट पर लेज़र लाइनों को प्रिंट करें। वास्तव में लाइन किसी भी y- समन्वय पर मुद्रित होती है, हालांकि इसे सीढ़ियों पर प्रिंट करने से निश्चित रूप से कोई प्रभाव नहीं पड़ता है।

¿›ι2

अर्धविराम के लिए ज्यादा कुछ नहीं करना है।

¿›λ⁶«

मध्य बिंदु के नीचे के नोटों के लिए,

↗↑⁴

तने को ऊपर की ओर खींचें,

¿›ι8«↘↘¹↓¹

और quavers के लिए झंडा।

»»«

मध्य बिंदु के ऊपर के नोटों के लिए,

↙↓⁴

तने को नीचे की ओर खींचे,

¿›ι8«↗↗¹↑¹

और quavers के लिए झंडा।


आपने SOGL को हरा दिया! :-)
चार्ली

@CarlosAlejo मुझे ऐसा होने की उम्मीद थी। लेकिन मुझे उम्मीद थी कि यह मुझे 20% तक भी हरा देगा।
द्विजिमा

@dzaima शायद यह एक शुद्ध ASCII- कला चुनौती थी, लेकिन यह भी एक तर्क हिस्सा है कि आउटपुट इनपुट पर निर्भर करता है बनाता है। बहरहाल, मुझे अभी भी आदत है कि प्रत्येक भाषा क्या बेहतर कर सकती है।
चार्ली
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.