Nhiệm vụ của bạn là lấy một chuỗi các ký tự (âm nhạc) làm đầu vào (trong một chức năng hoặc chương trình) và in (hoặc trả lại) âm nhạc như trong hộp nhạc.

Bạn sẽ chỉ nhận được các ký tự ABCDEFG.()làm đầu vào và đầu vào sẽ không bao giờ trống. Bạn cũng có thể nhận được các chữ cái viết thường, nếu bạn muốn cho nó.

Đây là một hộp nhạc trống, có độ dài 3:

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

Như bạn có thể thấy, các dòng có độ dài 7 ký tự và vì độ dài của hộp nhạc là 3, chúng tôi có 3 dòng. Chỉ có .s ở đây, vì hộp nhạc trống. Hãy đặt một vài bản nhạc vào đó!

Đầu tiên, chúng tôi tạo ra hộp nhạc. Trong ví dụ này, đầu vào sẽ là CDAG.DAG.

Độ dài CDAG.DAGlà 8, vì vậy chúng tôi cần một hộp nhạc có độ dài 8:

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

Sau đó, chúng tôi đọc đầu vào, mỗi lần một ký tự và đặt một Ovị trí tương ứng.

Ký tự đầu tiên là Cvà vị trí của mỗi ghi chú tương đương với điều này (tôi đã thêm khoảng trắng cho rõ ràng):

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

Nếu ký tự đầu vào là a ., thì chúng ta chỉ cần in một dòng trống.......

Vì vậy, Csẽ là nhân vật thứ 3 cùng. Hãy đặt nó trong hộp âm nhạc của chúng tôi ở đầu:

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

Chúng tôi sẽ lặp lại quy trình này cho tất cả các ký tự khác (văn bản trong ngoặc chỉ để hiển thị cho bạn ghi chú, bạn không nên xuất nó):

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

Do cách hộp âm nhạc hoạt động, nếu chúng tôi sử dụng một ký tự khác O, .và <insert newline here>, chẳng hạn như khoảng trắng, trong đầu ra của chúng tôi, thì nó sẽ không phát đúng nhạc!

Đây là một hợp âm:

(ACE)

Hợp âm này được hướng dẫn chúng tôi để chơi các ghi chú A, Cvà Ecùng một lúc. Sẽ không bao giờ có một khoảng dừng (tức là a .) trong một hợp âm.

Đây là cách nó sẽ được viết:

O.O.O...

Và đây là cách nó có thể xuất hiện trong âm nhạc: B(ACE)D

Bạn sẽ không bao giờ nhận được hợp âm trong hợp âm, nghĩa là điều này sẽ không hợp lệ: (AB(CD)EF)hoặc điều này: A(B())và hợp âm sẽ không trống, tức là điều này sẽ không hợp lệ:A()B

Bạn sẽ không bao giờ nhận được một đầu vào không hợp lệ.

Ví dụ:

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.

Trailing / khoảng trắng hàng đầu trên đầu ra được cho phép.

Vì đây là môn đánh gôn , mã ngắn nhất sẽ thắng!

Pip , 29 byte

28 byte mã, +1 cho -lcờ.

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

Lấy đầu vào bằng chữ thường làm đối số dòng lệnh. Hãy thử trực tuyến!

Giải trình

                              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)

Đây là một ví dụ về cách chuyển đổi đầu vào:

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

Con trăn 2 , 95 94 byte

^{-1 byte nhờ vào Ink Ink}

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

Hãy thử trực tuyến!hoặc Thử tất cả các trường hợp thử nghiệm

Giải trình

'@'<ilà để kiểm tra nếu ilà một chữ cái, thay thế .bằng Ovị trí bên phải.
'*'>ilà để kiểm tra xem có phải ilà dấu ngoặc đơn hay không, nếu nó được x=i>'('đưa 0vào xđể ngăn việc in / xóa o, khi nào i==')', nó sẽ được 1bật xlại cho phép in / xóa o.
Khi i=='.'không có gì sẽ được thay đổi, và '.......'sẽ được in.
Thứ tự charater được đưa ra bởi mã ASCII của họ, trong đó'('<')'<'*'<'.'<'@'<'A'

Hàng loạt, 209 byte

@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%

Hoạt động bằng cách tích lũy các chữ cái và xuất ra dòng nếu biểu tượng cuối cùng nhìn thấy không phải là a (.

Röda , 97 78 76 byte

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

Hãy thử trực tuyến!

Đây là một chức năng ẩn danh đọc đầu vào từ luồng. Sử dụng nó như thế này:main { f={...}; push("ABCD") | f() } . Nó sử dụng regex từ câu trả lời của ETHproductions.

Ung dung:

{
    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
}

Câu trả lời trước:

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

Hãy thử trực tuyến!

Nó hoạt động bằng cách tách chuỗi đã cho tại các vị trí mà chuỗi sau chỉ chứa dấu ngoặc đơn phù hợp. Sau đó, đối với mỗi hợp âm, nó lặp đi lặp lại qua các ghi chú có thể và in Onếu nốt đó là thành viên của hợp âm và .nếu không.

JavaScript (ES6), 86 85 76 byte

Đã lưu 9 byte nhờ @Neil

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>

Giải trình

Đầu tiên, chúng tôi khớp với những gì sẽ tạo thành từng dòng của đầu ra: hợp âm và ký tự không phải là một phần của hợp âm. Sau đó, đối với mỗi dòng, chúng tôi lấy chuỗi ABCDEFG\nvà thay thế từng ký tự không phải dòng mới trong dòng đó bằng Onếu dòng có chứa nó và một dòng .khác.

JavaScript (ES6), 118 116 114 byte

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):''

Các trường hợp thử nghiệm

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)"))

Ruby, 78 75 71 byte

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

Trả về một chuỗi các chuỗi.

Ungolfed + giải thích

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

PHP, 171 byte

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";}

Phá vỡ :

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
}

Hãy thử nó ở đây!

Võng mạc , 120 byte

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>`.

Tôi chắc chắn có chỗ để chơi gôn, nhưng giờ nó đã hoạt động, vì vậy tôi sẽ cố gắng chơi golf sau.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Về cơ bản, chương trình hoạt động bằng cách thay đổi mỗi ký tự thành một số, sau đó gán a Ocho vị trí đó trong một dòng. Nó ánh xạ ABCDEFG.tới01234569 .

Để tạo các dòng ghi chú duy nhất, tất cả những gì phải làm là đặt Osau số lượng tương ứng của. s , sau đó điền dòng dài 7 ký tự.

Tuy nhiên, các hợp âm là một chút khó khăn hơn để làm. Một quy trình tương tự được sử dụng, nhưng các số phải được dịch thành số gia, tức là nốt đầu tiên trong hợp âm là (bất cứ thứ gì), thứ hai là vị trí X sau vị trí thứ nhất, thứ ba là vị trí Y sau đó, v.v.

Mã

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

Bắt đầu bằng cách sắp xếp tất cả các ký tự trong hợp âm.

T`L.`d

Thực hiện chuyển ngữ (ánh xạ) từ chữ cái sang số.

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

Thay thế tất cả các chữ số trong ngoặc bằng một biểu diễn đơn (sử dụng xs), theo sau là khoảng trắng.

\)
m¶

Thay thế tất cả các dấu ngoặc đóng mtheo sau bởi một dòng mới. Nó msẽ được sử dụng như một điểm đánh dấu các loại cho vòng lặp sắp tới:

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

Đây là giai đoạn thay thế vòng lặp cho đến khi nó không thể thay thế nữa. Nó lấy hai chuỗi cuối cùng của xs trước một mvà trừ đi chuỗi thứ nhất từ ​​giây thứ hai, di chuyển mtrở lại. Điểm đánh dấu mlà cần thiết bởi vì nó phải thực hiện thao tác này từ phải sang trái.

 m?x

Loại bỏ cái đầu tiên xtrong mỗi chuỗi trừ cái đầu tiên.

T`x m(`.\O_

Transliterate bằng cách thay thế xbằng ., khoảng trắng bằng O, và xóa mvà( .

Tại thời điểm này, tất cả các dòng cho hợp âm đã được tạo ra. Bây giờ các dòng ghi chú đơn phải được tạo ra.

\d
$*.O¶

Thay thế mỗi chữ số bằng nhiều chữ số đó ., theo sau là Omột dòng mới.

¶
6$*.¶
%7>`.

Pad mỗi dòng đến chiều dài 7 bằng cách thêm .s ở bên phải. Điều này hoạt động bằng cách thêm 6 .giây vào cuối mỗi dòng (mỗi dòng sẽ có ít nhất 1 ký tự khác), sau đó thay thế mọi ký tự sau 7 ký tự đầu tiên trên mỗi dòng không có gì. (Vì .bản đồ đến 9, Osẽ bị cắt trên các dòng đó)

Perl, 87 71 45 + 2 ( -nlcờ) = 47 byte

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

Sử dụng:

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

Hãy thử nó trên Ideone.

Perl 5 - 78 + 1 (cờ) + 2 (Báo giá đầu vào) = 81 byte

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

Có thể chạy như vậy:

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

Ruby, 68 byte

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

Ý tưởng là sửa đổi chuỗi .......mỗi khi chúng ta tìm thấy một chữ cái, sau đó xuất ra và đặt lại nó, nhưng chỉ khi chúng ta ở ngoài dấu ngoặc.(tắt đầu ra. )và .cả chuyển đổi / rời khỏi đầu ra, nhưng cái sau là không quan trọng vì nó sẽ không bao giờ được tìm thấy trong một dấu ngoặc.

Ungolfed trong chương trình thử nghiệm

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)"]

Python 3, 94 byte

Một chức năng ẩn danh

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

Haskell , 101 byte

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=[]

Hãy thử trực tuyến! Sử dụng:p "AB.(CA)D" . Trả về một danh sách các chuỗi.

Giải trình:

Hàm pđệ quy trên chuỗi. Nếu nó tìm thấy một khung mở '('thì (x,_:t)<-span(')'<)rphân vùng chuỗi còn lại rthành các chuỗi xtrước khi xuất hiện của khung đóng ')'và tsau nó. Nếu không, ký tự hiện tại xđược biến thành một chuỗi [x]. Trong cả hai trường hợp, hàm ?được gọi với chuỗi ghi chú hiện tại và chuỗi còn lại. ?ánh xạ hàm #qua chuỗi "ABCDEFG", trong đó #thay thế tất cả các ký tự không có trong chuỗi ghi chú hiện tại bằng '.'. Dòng hộp nhạc kết quả được thêm vào cuộc gọi đệ quy trong pdanh sách còn lại r.

Võng mạc 0.8.2 , 52 byte

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

Hãy thử trực tuyến! Đưa đầu vào trong trường hợp thấp hơn. Giải trình:

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

Tách nhạc thành hợp âm hoặc ghi chú và bắt đầu xây dựng đầu ra bằng cách thêm danh sách tương đương ghi chú.

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

Đối với mỗi nốt trong mỗi hợp âm, thay đổi đầu ra thành một Ovà xóa nốt khỏi hợp âm.

T`().l`___.

Xóa tất cả các bản nhạc hiện tại và thay đổi tất cả các ghi chú chưa từng có thành trống.

PHP, 93 byte

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

Chạy như ống với -nRhoặc thử trực tuyến .

phá vỡ

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
    ;