Rất nhiều người thích chơi nhạc để giải trí và giải trí. Thật không may, âm nhạc đôi khi khá khó khăn. Đó là lý do tại sao bạn ở đây!

Bài tập

Đó là công việc của bạn để làm cho việc đọc nhạc dễ dàng hơn nhiều đối với những người đấu tranh với nó. Bạn cần viết một chương trình hoặc chức năng làm đầu vào cho một nhân viên âm nhạc và xuất ra tên của các ghi chú được viết trên nhân viên đó.

Nhân viên, khóa, và ghi chú

Một nhân viên âm nhạc , hoặc stave, là năm dòng ngang, giữa là bốn không gian. Mỗi dòng hoặc không gian đại diện cho một ghi chú khác nhau (cao độ), tùy thuộc vào khóa của âm nhạc.
Có một vài loại khóa âm nhạc khác nhau để lựa chọn, nhưng bây giờ chúng ta sẽ chỉ giao dịch với một loại khóa : âm treble . Trên khóa của âm bổng, các ghi chú được thể hiện trên các nhân viên như sau:

Dòng
F ----------
Đ ----------
B ----------
G ----------
E ----------

Không gian  
   ----------  
E
   ----------  
C
   ----------  
Một
   ----------  
F
   ----------

Định dạng của đầu vào

Đầu vào sẽ được cung cấp dưới dạng một chuỗi, như sau:

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

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

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

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

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

Năm dòng và bốn không gian của nhân viên được xây dựng trong chín hàng ký tự. Các dòng của nhân viên được xây dựng với các -ký tự (gạch nối) và khoảng trắng với ( dấu cách ). Mỗi hàng được phân tách với hàng tiếp theo bởi một ký tự dòng mới, ví dụ:
-----\n \n-----\n \n-----\n \n-----\n \n-----\n
Các hàng có độ dài tùy ý (đến một mức hợp lý có thể được xử lý bằng ngôn ngữ lập trình của bạn) và mỗi hàng có độ dài chính xác bằng các ký tự như các ký tự khác. Cũng lưu ý rằng các hàng sẽ luôn có độ dài chia hết cho ba (để phù hợp với mẫu của một ghi chú theo sau là hai cột không có ghi chú).

Ghi chú được đặt trên nhân viên này bằng cách thay thế phù hợp -hoặc nhân vật với o. Các ghi chú cũng có thể được nâng lên (sắc nét) hoặc hạ thấp (bằng phẳng) theo một nửa cung (khoảng một nửa độ chênh lệch tần số giữa một nốt và các nốt liền kề của nó). Điều này sẽ được đại diện bởi các nhân vật #và b, tương ứng, thay cho o. Mỗi ghi chú sẽ được phân tách từ tiếp theo bởi chính xác hai -ký tự và ghi chú đầu tiên sẽ luôn xuất hiện trên "cột" đầu tiên của -và (khoảng trắng) ký tự.

Khi xuất tên ghi chú, chương trình của bạn phải luôn sử dụng các chữ cái viết hoa ( A B C D E F G) tương ứng với ghi chú được đưa ra cho nhân viên. Đối với các ghi chú sắc nét ( #) và phẳng ( b), chương trình của bạn cần nối thêm #và btương ứng vào chữ cái tương ứng với ghi chú. Đối với một ghi chú tự nhiên không sắc nét hoặc bằng phẳng, một (không gian) nên được thêm vào.

Thí dụ

Đầu vào:

--------------------- o--
                  o     
--------------- o --------
            o           
--------- b --------------
      o                 
--- o --------------------
o                       
------------------------

* lưu ý tất cả "khoảng trống" trong ví dụ này thực sự là (ký tự khoảng trắng ).
Trong trường hợp này (thang đo F đơn giản), chương trình của bạn sẽ xuất ra điều này:

FGA Bb CDEF

Lưu ý khoảng cách giữa các ký tự của đầu ra phải chính xác như được hiển thị ở trên, để khớp chính xác với các ghi chú trên nhân viên. Giữa tất cả các tên ghi chú có hai ký tự (dấu cách), ngoại trừ giữa Bbvà C. Ở bđây thay thế một trong các ký tự (không gian).

Một ví dụ khác
Đầu vào:

------------------------
                     o  
------------------ # -----
               #        
------------ o -----------
         o              
------ # -----------------
   #                    
o -----------------------

Đầu ra:
E F# G# A B C# D# E

Thêm một ví dụ nữa cho sự may mắn
Đầu vào:

---------------------
ồ           
---------------------
         o              
---------------------

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

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

Đầu ra:
E E E C E G G

Quy tắc

• Ghi chú sẽ chỉ được đưa ra trong phạm vi năm nhân viên của E phẳng đến F sắc nét (ngoại trừ các thách thức, xem bên dưới)
• Bất kỳ ghi chú nào cũng có thể sắc nét hoặc bằng phẳng, không chỉ những nốt thường thấy trong âm nhạc (ví dụ: mặc dù B # thực sự chỉ được phát dưới dạng C trong thực tế, B # vẫn có thể xảy ra trong đầu vào)
• Bạn có thể giả sử sẽ có chính xác một nốt trên 3 cột (vì vậy sẽ không có hợp âm hoặc bất cứ thứ gì tương tự, và cũng không có phần còn lại)
• Bạn có thể giả sử ghi chú cuối cùng sẽ được theo sau bởi hai cột không có ghi chú
• Bạn có thể giả sử ngay cả dòng cuối cùng của nhân viên sẽ được theo sau bởi một ký tự dòng mới
• Đầu vào phải được lấy từ STDIN (hoặc ngôn ngữ tương đương) hoặc làm tham số chức năng
• Đầu ra phải là STDOUT (hoặc ngôn ngữ tương đương) hoặc là kết quả trả về nếu chương trình của bạn là một hàm
• Lỗ hổng tiêu chuẩn và tích hợp được cho phép! Âm nhạc là về thử nghiệm và chơi xung quanh. Hãy tiếp tục và vui vẻ với ngôn ngữ của bạn (mặc dù nhận ra rằng việc khai thác lỗ hổng có thể không tạo ra chương trình thú vị nhất)
• Đây là môn đánh gôn , vì vậy chương trình ngắn nhất tính bằng byte thắng

Thử thách tiền thưởng

• -10% nếu chương trình của bạn cũng có thể xử lý thành công không gian phía trên dòng trên cùng của nhân viên (G, G #, Gb).
• -10% nếu chương trình của bạn cũng có thể xử lý thành công không gian bên dưới dòng dưới cùng của nhân viên (D, D #, Db)
• Trong những trường hợp này, chương trình của bạn sẽ lấy đầu vào là một hàng bổ sung ở đầu và cuối; các hàng này phải được xử lý giống hệt như chín hàng khác

CJam ( 40 37 * 0,8 = 29,6 điểm)

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

Bản demo trực tuyến

Cảm ơn thực sự đã chỉ ra một số biến được xác định trước mà tôi đã quên.

Ruby, 106 byte * 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}

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

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]

JavaScript (ES6), 144 byte - 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``)

Giải trình

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
)

Kiểm tra

Hãy nhớ thêm một dòng phía trên nhân viên có độ dài chính xác của các dòng khác bởi vì giải pháp này bao gồm phân tích các dòng trên và dưới nhân viên.

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>