संगीत बॉक्स बनाना

Question

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

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

यह एक खाली संगीत बॉक्स है, जिसकी लंबाई 3 है:

.......
.......
.......

जैसा कि आप देख सकते हैं, लाइनें 7 वर्ण लंबी हैं, और चूंकि संगीत बॉक्स की लंबाई 3 है, हमारे पास 3 लाइनें हैं। यहां केवल .एस हैं, चूंकि संगीत बॉक्स खाली है। चलो इसमें कुछ संगीत डालते हैं!

सबसे पहले, हम संगीत बॉक्स बनाते हैं। इस उदाहरण में, इनपुट होगा CDAG.DAG।

लंबाई CDAG.DAG8 है, इसलिए हमें लंबाई 8 के संगीत बॉक्स की आवश्यकता है:

.......
.......
.......
.......
.......
.......
.......
.......

फिर, हम इनपुट को पढ़ते हैं, एक बार में एक वर्ण, और Oअपने संबंधित स्थान पर रखते हैं।

पहला वर्ण है C, और प्रत्येक नोट का स्थान इसके बराबर है (मैंने स्पष्टता के लिए रिक्त स्थान जोड़े):

 A B C D E F G
 . . . . . . .
 . . . . . . .
 (and so on)

यदि इनपुट चरित्र ए है ., तो हम सिर्फ एक खाली लाइन प्रिंट करते हैं.......

तो, Cसाथ 3 अक्षर होगा। आइए इसे अपने संगीत बॉक्स में सबसे ऊपर रखें:

..O....
.......
.......
.......
.......
.......
.......
.......

हम सभी अन्य वर्णों के लिए इस प्रक्रिया को दोहराएंगे (कोष्ठक में पाठ सिर्फ आपको नोट दिखाने के लिए है, आपको इसका उत्पादन नहीं करना चाहिए):

..O.... (C)
...O... (D)
O...... (A)
......O (G)
....... (.)
...O... (D)
O...... (A)
......O (G)

संगीत बक्से कैसे काम करते हैं, इस वजह से, अगर हम अपने आउटपुट में O, .और <insert newline here>जैसे कि किसी स्पेस का उपयोग करते हैं, तो यह सही संगीत नहीं चलेगा!

यह एक राग है:

(ACE)

यह राग हमें नोट्स बजाने का निर्देश दे रहा है A, Cऔर Eसाथ ही साथ। .एक राग में कभी विराम (अर्थात ) नहीं होगा ।

यह इस प्रकार लिखा जाएगा:

O.O.O...

और यह संगीत में दिखाई दे सकता है: B(ACE)D

आप एक राग में एक राग प्राप्त नहीं करेंगे, अर्थात यह मान्य नहीं होगा: (AB(CD)EF)या यह: A(B())और राग खाली नहीं होगा, अर्थात यह मान्य नहीं होगा:A()B

आपको अवैध इनपुट कभी नहीं मिलेगा।

उदाहरण:

B(ACE)D

.O.....
O.O.O..
...O...

B

.O.....

GGABC

......O
......O
O......
.O.....
..O....

...

.......
.......
.......

A..F.C(DA).

O......
.......
.......
.....O.
.......
..O....
O..O...
.......

.(ABCDEF)

.......
OOOOOO.

आउटपुट पर अनुगामी / अग्रणी व्हाट्सएप की अनुमति है।

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

Comments

एक संगीत स्ट्रिंग ()दो बार शामिल कर सकते हैं (जैसे AB(CD)E(FG):) ??

— मिस्टर एक्सकोडर

@ Mr.Xcoder हाँ, यह कर सकते हैं।

— ओकेक्स

क्या आउटपुट पात्रों की सूची / सरणी हो सकता है?

— रॉड

@ निश्चित रूप से, PPCG मानकों के अनुसार

— Okx

क्या हमें एक ही कॉर्ड में एक ही नोट के दो नहीं होने की गारंटी है?

— बिजनेस कैट

Answer 1

पिप , 29 बाइट्स

-lध्वज के लिए कोड के 28 बाइट्स, +1 ।

'.X7RA_'OMz@?a@`\(\w+.|.`@XL

कमांड-लाइन तर्क के रूप में लोअरकेस में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

                              a is 1st cmdline arg; XL is `[a-z]`; z is lowercase alphabet
             a@`\(\w+.|.`     List of all matches in a of this regex:
                               Either a ( followed by letters followed by another
                               character (i.e. the closing paren), or any one character
                         @XL  For each of those matches, a list of all matches of this
                               regex (effectively, split the match into a list of
                               characters and keep only the lowercase letters)
          z@?                 Find index of each letter in the lowercase alphabet
         M                    To that list of lists of indices, map this function:
'.X7                           Take a string of 7 periods
    RA_                        and replace the characters at all indices in the argument
       'O                      with O
                              Finally, autoprint the resulting list, with each item on
                              its own line (-l flag)

एक इनपुट कैसे बदला जाता है इसका एक नमूना यहां दिया गया है:

"b.(ceg)"
["b" "." "(ceg)"]
[["b"] [] ["c" "e" "g"]]
[[1] [] [2 4 6]]
[".O....." "......." "..O.O.O"]

Answer 2

पायथन 2 , 95 94 बाइट्स

^{-1 बाइट मान स्याही के लिए धन्यवाद}

x=1
for i in input():
 if x:o=['.']*7
 if'@'<i:o[ord(i)-65]='O'
 if'*'>i:x=i>'('
 if x:print o

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

व्याख्या

'@'<iयह देखना है कि iक्या एक पत्र है, .द्वारा Oसही स्थिति पर प्रतिस्थापित ।
'*'>iअगर जाँच करने के लिए है i, एक कोष्ठक है अगर यह होता है x=i>'('डाल देंगे 0पर xकी छपाई / समाशोधन को रोकने के लिए o, जब i==')', यह डाल देंगे 1पर xपुनः सक्षम करने के मुद्रण / समाशोधन o।
जब i=='.'कुछ भी नहीं बदला जाएगा, और '.......'मुद्रित किया जाएगा।
उनके एएससीआईआई कोड द्वारा चार्जर ऑर्डर दिया गया है, जहां'('<')'<'*'<'.'<'@'<'A'

Comments

ओह मैं उस टिप्पणी से चूक गया। nvm।

— क्विंटोपिया

अल्पविराम ['.']*7:। शायद यह एक पकड़ है जब आप एक टपल का उपयोग कर रहे थे, जिसे अल्पविराम की आवश्यकता होगी। इसके अलावा, मैं गलत हो सकता है, लेकिन यह एक ['O', '.', '.', '.', '.', '.', '.']पंक्ति प्रति पंक्ति उत्पादन करने के लिए लगता है , और मुझे यकीन नहीं है कि अगर यह अनुमति है?

— वैल्यू इंक

@ValueInk हां, ओपी ने अनुमति दी

— रॉड

आपने बाइट बदलने और अपने TIO लिंक को बदलने का उल्लेख किया है लेकिन आपकी पोस्ट पर सूचीबद्ध कोड अभी भी वही है: V

— वैल्यू इंक

@ValueInk ¯ \ _ (_) _ /

— Rod

Answer 3

बैच, 209 बाइट्स

@set s=%1
@set p=)
@for %%n in (a b c d e f g)do @set %%n=.
:g
@if %s:~,1% lss @ (set "p=%s:~,1%")else set %s:~,1%=O
@set s=%s:~1%
@if %p%==( goto g
@echo %a%%b%%c%%d%%e%%f%%g%
@if not "%s%"=="" %0 %s%

अक्षरों को जमा करने और लाइन को आउटपुट करने से काम करता है अगर अंतिम प्रतीक देखा गया था तो ए (।

Answer 4

रोड़ा , 97 78 76 बाइट्स

{search`\(\w+\)|.`|{|c|seq 65,71|{|l|["O"]if[chr(l)in c]else["."]}_;["
"]}_}

इसे ऑनलाइन आज़माएं!

यह एक अनाम फ़ंक्शन है जो स्ट्रीम से इनपुट पढ़ता है। इसे इस तरह उपयोग करें main { f={...}; push("ABCD") | f() }:। यह ETHproductions के उत्तर से रेगेक्स का उपयोग करता है।

Ungolfed:

{
    search(`\(\w+\)|.`) | for chord do
        seq(ord("A"), ord("G")) | for note do
            if [ chr(note) in chord ] do
                push("O")
            else
                push(".")
            done
        done
        push("\n")
    done
}

पिछला उत्तर:

f s{(s/"(?=([^()]*(\\([^()]*\\))?)*$)")|{|c|seq 65,71|{|l|["O"]if[chr(l)in c]else["."]}_;["
"]}_}

इसे ऑनलाइन आज़माएं!

यह दिए गए स्ट्रिंग को उन स्थानों पर विभाजित करके काम करता है जहां निम्नलिखित स्ट्रिंग में केवल मिलान किए गए कोष्ठक होते हैं। फिर, प्रत्येक कॉर्ड के लिए, यह संभव नोट्स के माध्यम से पुनरावृत्ति करता है और प्रिंट करता है Oयदि नोट कॉर्ड का सदस्य है और .अन्यथा।

Answer 5

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

@ बाइस धन्यवाद के लिए 9 बाइट्स बचाए

let f =
s=>s.replace(r=/\(\w+\)|./g,x=>`ABCDEFG
`.replace(r,c=>x.match(c)?"O":"."))

<input oninput="if(/^([A-G.]|\([A-G]+\))+$/.test(value))O.textContent=f(value)"><br>
<pre id=O></pre>

व्याख्या

सबसे पहले, हम मिलान करते हैं कि आउटपुट की प्रत्येक पंक्ति क्या बनेगी: कॉर्ड, और चार्ट जो कॉर्ड का हिस्सा नहीं हैं। फिर, प्रत्येक पंक्ति के लिए, हम स्ट्रिंग लेते हैं ABCDEFG\nऔर इसमें प्रत्येक गैर-न्यूलाइन वर्ण को प्रतिस्थापित करते हैं Oयदि एक पंक्ति में यह होता है, और .अन्यथा।

Comments

यदि एक अनुगामी न्यूलाइन स्वीकार्य है, तो आप 8 बाइट्स का उपयोग करके बचा सकते हैं s=>s.replace(r=/\(\w+\)|./g,x=>`ABCDEFG\n`.replace(r,c=>x.match(c)?"O":"."))।

— नील

@ नील वाह, यह अद्भुत :-)

— ETHproductions

हुह, अब जब मैं इसे फिर से मापता हूं, तो इसे 10 बाइट की बचत होनी चाहिए ...

— नील

हो सकता \)है .?

— l4m2

Answer 6

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

f=([c,...t],s)=>c?((s?0:x=[...'.......'],c='ABCDEFG)('.indexOf(c))>6?c-7:(x[c]='O',s))?f(t,1):x.join``+`
`+f(t):''

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

f=([c,...t],s)=>c?((s?0:x=[...'.......'],c='ABCDEFG)('.indexOf(c))>6?c-7:(x[c]='O',s))?f(t,1):x.join``+`
`+f(t):''

console.log(f("B(ACE)D"))
console.log(f("GGABC"))
console.log(f("..."))
console.log(f("A..F.C(DA)."))
console.log(f(".(ABCDEF)"))

Answer 7

रूबी, 78 75 71 बाइट्स

->x{x.scan(/\(\w+\)|./).map{|x|l=?.*7
x.bytes{|x|x>47?l[x-65]=?O:1};l}}

स्ट्रिंग्स की एक सरणी देता है।

अघोषित + स्पष्टीकरण

def boxes string
  string.scan(/\(\w+\)|./)    # Split the string into an array of chords.
  .map do |chord|             # Replace each chord with...
    line = '.' * 7            # a line, where by default each character is a '.',
    chord.bytes do |note|     # but for each note in the chord...
      if note > '.'.ord       # (if it is in fact a note and not a dot or paren)
        line[note-65] = 'O'   # replace the corresponding dot with an 'O'.
      end
    end
    line               
  end
end

Comments

3 बाइट्स को बचाने के लिए और इसके बजाय एक मल्टी-लाइन स्ट्रिंग वापस करने के लिए उपयोग करें x.gsub(...){l=?.*7;$&.bytes{...};l+$/}( निकालें, हटाएं और पहले regex मैच का उपयोग करने के लिए उपयोग कर सकते हैं ) के scanसाथ स्वैप करें । (इसके अलावा डिफ़ॉल्ट रूप से एक नई रेखा के लिए नक्शे।)gsubmap|x|$&$/

— मूल्य इंक

Answer 8

PHP, 171 बाइट्स

preg_match_all('#[A-G\.]|\([A-G]+\)#',$argv[1],$m);foreach($m[0]as$l){if($l=='.')echo".......";else foreach([A,B,C,D,E,F,G]as$a)echo strpos($l,$a)!==false?O:'.';echo"\n";}

टूट - फूट :

preg_match_all('#[A-G\.]|\([A-G]+\)#',$argv[1],$m); // Matches either one character in the range [A-G.] OR multiple [A-G] characters between parentheses
foreach($m[0]as$l)                                  // For each match :
    if($l=='.')                                     //   If no note is played
        echo".......";                              //     Echo empty music line
    else                                            //   Else
        foreach([A,B,C,D,E,F,G]as$a)                //     For each note in the [A-G] range
            echo strpos($l,$a)!==false?O:'.';       //       Echo O i the note is played, . if not
    echo"\n";                                       //  Echo new line
}

यहाँ यह कोशिश करो!

Answer 9

रेटिना , 120 बाइट्स

O`(?<=\([^)]*)[^)]
T`L.`d
(?<=\([^)]*)\d
$*x 
\)
m¶
+`\b(x+) \1(x+) m
$1 m$2 
 m?x

T`x m(`.\O_
\d
$*.O¶
¶
6$*.¶
%7>`.

मुझे यकीन है कि वहाँ गोल्फ के लिए जगह है, लेकिन यह अब काम करता है, इसलिए मैं इसे और अधिक बाद में गोल्फ करने की कोशिश करूँगा।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

मूल रूप से, प्रोग्राम प्रत्येक वर्ण को एक संख्या में बदलकर काम करता है, फिर Oएक पंक्ति में उस स्थिति में असाइन करता है। यह मैप ABCDEFG.करता है 01234569।

एकल नोट लाइनों को उत्पन्न करने के लिए, सभी को जो करना होता है , वह एस Oकी इसी संख्या के बाद रखा जाता है ., फिर लाइन को 7 से 7 बार लंबा करें।

हालांकि, कॉर्ड्स करने के लिए थोड़ा मुश्किल है। एक समान प्रक्रिया का उपयोग किया जाता है, लेकिन संख्याओं को वेतन वृद्धि के लिए अनुवादित किया जाना है, अर्थात कॉर्ड में पहला नोट है (जो भी हो), दूसरा एक्स पदों के बाद पहले, तीसरे के बाद वाई स्थिति है, आदि।

कोड

O`(?<=\([^)]*)[^)]

Chords के भीतर सभी वर्णों को क्रमबद्ध करके प्रारंभ करें।

T`L.`d

अक्षरों से संख्याओं में लिप्यंतरण (मानचित्रण) करें।

(?<=\([^)]*)\d
$*x 

सभी अंकों को एक एकीकृत प्रतिनिधित्व ( xs का उपयोग करके ) कोष्ठक के भीतर रखें , उसके बाद एक स्थान।

\)
m¶

सभी समापन कोष्ठक को mएक नई पंक्ति के साथ बदलें । mआने वाले पाश के लिए एक तरह के मार्कर के रूप में उपयोग किया जाएगा:

+`\b(x+) \1(x+) m
$1 m$2 

यह एक प्रतिस्थापन चरण है जो तब तक लूप करता है जब तक यह अब और नहीं बदल सकता। यह xएक से पहले s के अंतिम दो क्रम लेता है m, और दूसरे को mपीछे से घुमाते हुए पहले को घटाता है । मार्कर mकी आवश्यकता है, क्योंकि उसे यह ऑपरेशन दाएं से बाएं करना है।

 m?x

पहले वाले xको छोड़कर प्रत्येक क्रम में पहला निकालें ।

T`x m(`.\O_

Tकी जगह ransliterate xसाथ .साथ, अंतरिक्ष O, और हटाने mऔर (।

इस बिंदु पर, जीवाओं के लिए सभी लाइनें बनाई गई हैं। अब सिंगल-नोट लाइनें बनानी होंगी।

\d
$*.O¶

प्रत्येक अंक को कई .s से बदलें , उसके बाद Oa और एक newline।

¶
6$*.¶
%7>`.

प्रत्येक पंक्ति को .दाईं ओर s जोड़कर लंबाई 7 पर रखें । यह .प्रत्येक पंक्ति के अंत में 6 एस जोड़कर काम करता है (प्रत्येक पंक्ति में कम से कम 1 अन्य चरित्र होगा), फिर प्रत्येक पंक्ति पर पहले 7 के बाद प्रत्येक वर्ण को कुछ भी नहीं के साथ प्रतिस्थापित करना। ( .9 के नक्शे के बाद से , Oउन लाइनों पर काट दिया जाएगा)

Answer 10

पर्ल, 87 71 45 + 2 ( -nlध्वज) = 47 बाइट्स

#!/usr/bin/env perl -nl
use v5.10;
say map$&=~/$_/i?O:".",a..g while/\(\w+\)|./g

का उपयोग करते हुए:

perl -nlE 'say map$&=~/$_/i?O:".",a..g while/\(\w+\)|./g' <<< "A..F.C(DA)."

Ideone पर इसे आज़माएं।

Answer 11

पर्ल 5 - 78 + 1 (ध्वज) + 2 (इनपुट उद्धरण) = 81 बाइट्स

for(;/(\([a-g]+\)|[a-g\.])/g;){$i=$1;print$i=~/$_/?'o':'.'for(a..g);print"\n"}

ऐसे चलाया जा सकता है:

perl -n <name of file holding script> <<< <input in quotations>

Comments

क्या आपको नहीं लगता कि उद्धरणों में इनपुट 2 अतिरिक्त बाइट्स के रूप में गिना जाएगा? मैं गलत हो सकता हूं, क्योंकि इस मंचन पर एक मेटा सहमति हो सकती है अन्यथा।

— ओकेक्स

@ ओकेएक्स ने मेरे बायटेकाउंट को अपडेट किया। यकीन नहीं था अगर यह इसे जोड़ा, अभी भी यहाँ थोड़े नया :)

— CraigR8806

Answer 12

रूबी, 68 बाइट्स

->s{w=?.*m=7
s.bytes{|i|i>64?w[i-65]=?O:m=i!=40;m&&(puts w;w=?.*7)}}

यह विचार है कि स्ट्रिंग को .......हर बार जब हम एक पत्र पाते हैं, तो उसे आउटपुट और रीसेट करते हैं, लेकिन केवल तब जब हम बाहरी कोष्ठक होते हैं। (आउटपुट को बंद कर देता है। )तथा. दोनों आउटपुट को स्विच / छोड़ देते हैं, लेकिन बाद में असंगत है क्योंकि यह एक ब्रैकेट के अंदर कभी नहीं मिलेगा।

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

f=->s{w=?.*m=7              #set m to a truthy value (7) and w to seven .'s
  s.bytes{|i|               #for each byte in the string
    i>64?w[i-65]=?O:m=i!=40 #if a letter, modify the appropriate character of w ELSE set m to false if inside brackets, true otherwise.
    m&&(puts w;w=?.*7)      #if m is true, output the contents of w and reset to seven .'s
  }
}

p 1
f["B(ACE)D"]
p 2
f["B"]
p 3
f["GGABC"]
p 4
f["A..F.C(DA)."]
p 5
f[".(ABCDEF)"]

Answer 13

पायथन 3, 94 बाइट्स

एक अनाम फ़ंक्शन

import re
lambda s:[''.join('.O'[c in x]for c in'ABCDEFG')for x in re.findall(r'\(\w+\)|.',s)]

Answer 14

हास्केल , 101 बाइट्स

c#s|elem c s=c|1<3='.'
s?r=map(#s)"ABCDEFG":p r
p('(':r)|(x,_:t)<-span(')'<)r=x?t
p(x:r)=[x]?r
p e=[]

इसे ऑनलाइन आज़माएं! उपयोग: p "AB.(CA)D"। तार की सूची लौटाता है।

स्पष्टीकरण:

फ़ंक्शन pस्ट्रिंग पर पुनरावृत्ति करता है। यदि यह एक खुलने वाला ब्रैकेट पाता है, '('तो समापन ब्रैकेट की घटना से पहले और उसके बाद (x,_:t)<-span(')'<)rबाकी स्ट्रिंग rको विभाजन में विभाजित करता है। अन्यथा वर्तमान वर्ण स्ट्रिंग में बदल जाता है । दोनों मामलों में फ़ंक्शन को नोट्स के वर्तमान स्ट्रिंग और बाकी स्ट्रिंग के साथ कहा जाता है। स्ट्रिंग पर फ़ंक्शन को मैप करता है , जहां उन सभी वर्णों को बदलता है जो नोटों के वर्तमान स्ट्रिंग में नहीं हैं । परिणामी संगीत बॉक्स लाइन बाकी सूची पर पुनरावर्ती कॉल करने के लिए तैयार है ।x')'tx[x]??#"ABCDEFG"#'.'pr

Answer 15

रेटिना 0.8.2 , 52 बाइट्स

\(\w+\)|.
abcdefg$&¶
+`([a-g])(.*)\1
O$2
T`().l`___.

इसे ऑनलाइन आज़माएं! लोअर केस में इनपुट लेता है। स्पष्टीकरण:

\(\w+\)|.
abcdefg$&¶

संगीत को कॉर्ड्स या नोट्स में विभाजित करें, और नोट समकक्षों की सूची को जोड़कर आउटपुट का निर्माण शुरू करें।

+`([a-g])(.*)\1
O$2

प्रत्येक कॉर्ड में प्रत्येक नोट के लिए, आउटपुट को ए में बदलें Oऔर कॉर्ड से नोट को हटा दें।

T`().l`___.

अब सभी बाहरी संगीत को हटा दें, और सभी बेजोड़ नोटों को खाली कर दें।

Answer 16

PHP, 93 बाइट्स

for($s=$t="
.......";$c=ord($argn[$i++]);$d||$s=$t.!print$s)$c<65?$c-46&&$d=~$c&1:$s[$c&7]=O;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

टूट - फूट

for($s=$t="\n.......";      // init
    $c=ord($argn[$i++]);    // loop through characters
    $d||                        // 2. if chord flag is unset
        $s=$t.!print$s)             // then print and reset chord
    $c<65                       // 1. if not note
        ?$c-46                      // and not dot
            &&$d=~$c&1              // then set or clear chord flag
        :$s[$c&7]=O             // else set note in chord
    ;