Nhiệm vụ này rất đơn giản: Viết chương trình hoặc chức năng đưa ra danh sách tất cả các nốt nhạc (sử dụng tên ghi chú tiếng Anh) từ A đến G♯.

Tất cả các ghi chú không có tên bao gồm một chữ cái (ví dụ: ghi chú màu đen trên bàn phím âm nhạc) nên được in tên của chúng hai lần, một lần là sắc nét của một nốt nhạc, một lần là phẳng của một nốt nhạc. Ghi chú sắc nét hoặc bằng phẳng có thể được mô tả bằng một chữ cái, như B♯ (C) hoặc F ♭ (E) không nên xuất ra.

Dưới đây là một ví dụ về đầu ra:

Ab, A, A#, Bb, B, C, C#, Db, D, D#, Eb, E, F, F#, Gb, G, G#

Thông số kỹ thuật

• Chương trình hoặc chức năng không được lấy bất kỳ đầu vào.

• Các ghi chú có thể được in theo bất kỳ thứ tự nào và trong bất kỳ đầu ra danh sách nào được phép theo quy tắc I / O tiêu chuẩn của chúng tôi

• Các ký hiệu Unicode sắc nét và phẳng (/) có thể được thay thế bằng b và#

• Như mọi khi, sơ hở tiêu chuẩn bị cấm.

• Vì đây là code-golf , chương trình nhỏ nhất, tính bằng byte, thắng.

Malbolge , 482 370 353 byte

R1: Đã xóa các dấu phẩy ở giữa (như không yêu cầu của thử thách)

R2: Tắt một vài byte

('<;_#!=6Z|{8xUwvt,PrqonKmk)"FhCUTdb?`+<;:[Z7YtVU2T|/g-O+i(gJrHc#EC~B{@zZxw:tt'r5Qo"!l/K-hUfe?bP``_Lo~[}|X2VCTR3Q+N`_^9+7Hji3ffdAc~w|u;]\wpon4VUSSQ.PONcb(JI^]#DCYX|@?>=<:u9NMRKo32MFj.C,Ae)>'<%:^"!~5:3WxwwuRts0q(Lnml)"Fhgfe"y?a`_zyxq7YXWlUj0RgfkjMb(JI^c\[Z~BAV?T=Rv987Mq44310FEi-,G@)>b&%#"8=6Z{{yyw/Sut1*)('Km$k(!Efe{zyx>`uz]r8ZXnm3TTih.PkNchg`&HFF[DY}Az

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

Lắp ráp CP-1610 ( Intellivision ), 31 DECLE ¹ = 39 byte

Một thói quen lấy một con trỏ đầu ra trong R4 và viết các ghi chú ở đó, được phân tách bằng dấu cách. Trong mã ví dụ, chúng tôi viết trực tiếp lên màn hình.

Hex dump (chỉ thường lệ)

275 001 2BD 03C 048 1DB 2B8 012 044 2A9 2BA 108 078 201 003 262
261 263 2FA 008 37A 140 225 00B 089 22C 011 2B7 018 210 000

Nguồn đầy đủ

                ROMW    10              ; use 10-bit ROM width
                ORG     $4800           ; map this program at $4800

                ;; ------------------------------------------------------------- ;;
                ;;  test code                                                    ;;
                ;; ------------------------------------------------------------- ;;
4800            SDBD                    ; set up an interrupt service routine
4801            MVII    #isr,     R0    ; to do some minimal STIC initialization
4804            MVO     R0,       $100
4806            SWAP    R0
4807            MVO     R0,       $101

4809            EIS                     ; enable interrupts

480A            MVII    #$200,    R4    ; R4 = backtab pointer
480C            CALL    notes           ; invoke our routine

480F            DECR    R7              ; loop forever

                ;; ------------------------------------------------------------- ;;
                ;;  ISR                                                          ;;
                ;; ------------------------------------------------------------- ;;
      isr       PROC

4810            MVO     R0,       $0020 ; enable display

4812            CLRR    R0
4813            MVO     R0,       $0030 ; no horizontal delay
4815            MVO     R0,       $0031 ; no vertical delay
4817            MVO     R0,       $0032 ; no border extension
4819            MVII    #$D,      R0
481B            MVO     R0,       $0028 ; light-blue background
481D            MVO     R0,       $002C ; light-blue border

481F            JR      R5              ; return from ISR

                ENDP

                ;; ------------------------------------------------------------- ;;
                ;;  routine                                                      ;;
                ;; ------------------------------------------------------------- ;;
      notes     PROC

4820            PSHR    R5              ; save return address

4821            SDBD                    ; R5 = pointer to @@chr
4822            MVII    #@@chr,   R5
4825            CLRR    R3              ; R3 = 0 (space)
4826            MVII    #$12,     R0    ; R0 = bitmask = $12
4828            SWAP    R0,       2     ; extend it to $1212

4829  @@loop    MVI@    R5,       R1    ; R1 = next symbol
482A            MVII    #('A'-32)*8, R2 ; R2 = 'A' character

482C  @@note    SARC    R0              ; right shift the bitmask
482D            BC      @@next          ; skip this note if the carry is set

482F            MVO@    R2,       R4    ; append the note
4830            MVO@    R1,       R4    ; append the symbol
4831            MVO@    R3,       R4    ; append a space

4832  @@next    ADDI    #8,       R2    ; advance to the next note
4834            CMPI    #('H'-32)*8, R2 ; is it now a 'H'?
4836            BLT     @@note          ; if not, process the inner loop

4838            TSTR    R1              ; was the symbol a space?
4839            BNEQ    @@loop          ; if not, process the outer loop

483B            PULR    R7              ; return

483C  @@chr     DECLE   ('#'-32)*8      ; '#'
483D            DECLE   ('b'-32)*8      ; 'b'
483E            DECLE   0               ; space

                ENDP

Đầu ra

^{ảnh chụp màn hình từ jzIntv}

_{1. Mã op CP-1610 được mã hóa với giá trị 10 bit, được gọi là 'DECLE'. Thủ tục này dài 31 DECLE, bắt đầu từ $ 4820 và kết thúc ở mức $ 483E (bao gồm).}

Python 3 , 50 byte

print(*map(''.join,zip(3*'ADGBCEF',7*' '+5*'#b')))

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

Python 2: 48 byte

Mã này có thể được điều chỉnh để bao gồm B # và Cb, với chi phí không có byte bổ sung. Điều này có thể đạt được bằng cách thay thế 5bằng 6.

Ngoài ra, nó (cuối cùng) ngắn hơn là chỉ xuất ra chuỗi đơn giản:

Python 3 , 51 byte

exit('Ab A A# Bb B C C# Db D D# Eb E F F# Gb G G#')

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

Python 2: 50 byte

05AB1E , 16 15 13 byte

Au…b #âŽ7×bûÏ

-2 byte nhờ @maxb .

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

Đầu ra dưới dạng một danh sách, trong đó các ghi chú char đơn có một khoảng trắng ở cuối.

Giải trình:

Au             # Push the lowercase alphabet, and uppercase it
  …b #         # Push string "b #"
      â        # Take the cartesian product of both strings to create all possible pairs:
               #  ["Ab","A ","A#","Bb","B ","B#",...,"Zb","Z ","Z#"]
       Ž7×     # Push compressed integer 1999
          b    # Convert it to a binary string "11111001111"
           û   # Palindromize it to "111110011111110011111"
            Ï  # Only leave the notes in the list at the truthy values (1), (the trailing
               # items beyond the length of this binary string are also discarded)
               # (after which the result is output implicitly)

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để nén các số nguyên lớn? ) Để hiểu tại sao Ž7×là 1999.

Ž7×cách khác có thể là ₄·<(1000, gấp đôi, giảm 1) cho cùng một số đếm byte.

Thạch , 18? * 20 byte

ØAḣ7µp⁾b#Żs6ḣ€4ẎḊ;W€

Một liên kết đơn thể trả về một danh sách các danh sách các nhân vật.

* _{Nếu một danh sách hỗn hợp gồm (a) danh sách các ký tự và (b) ký tự được chấp nhận, hãy xóa dấu vết W€trong 18.}

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

Làm sao?

ØAḣ7µp⁾b#Żs6ḣ€4ẎḊ;W€ - Link: no argument
ØA                   - list of characters     [A-Z]
  ḣ7                 - head to 7              "ABCDEFG"
    µ                - new monadic link (call that X)
      ⁾b#            - list of characters     "b#"
     p               - Cartesian product      ["Ab","A#","Bb","B#","Cb","C#","Db","D#","Eb","E#","Fb","F#","Gb","G#"]
         Ż           - prepend a zero       [0,"Ab","A#","Bb","B#","Cb","C#","Db","D#","Eb","E#","Fb","F#","Gb","G#"]
          s6         - split into sixes    [[0,"Ab","A#","Bb","B#","Cb"],["C#","Db","D#","Eb","E#","Fb"],["F#","Gb","G#"]]
            ḣ€4      - head each to 4      [[0,"Ab","A#","Bb"],["C#","Db","D#","Eb"],["F#","Gb","G#"]]
               Ẏ     - tighten              [0,"Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#"]
                Ḋ    - dequeue                ["Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#"]
                  W€ - wrap each (of X)       ["A","B","C","D","E","F","G"]
                 ;   - concatenate            ["Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#","A","B","C","D","E","F","G"]

Võng mạc 0.8.2 , 33 byte

ABCDEFG
.
 $&b $& $&#
 [BE]#...

Hãy thử trực tuyến! Giải trình:

ABCDEFG

Chèn tên ghi chú cơ sở.

.
 $&b $& $&#

Mở rộng từng lưu ý để bao gồm các phiên bản phẳng và sắc nét.

 [BE]#...

Xóa B#, E#và cả các ghi chú theo sau chúng ( Cbvà Eb).

Perl 6 , 41 byte

{S:g/[E|B]\#...//}o{'A'..'G'X~'b #'.comb}

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

Sản phẩm chéo đơn giản của các ghi chú và vật sắc nhọn / căn hộ, tiếp theo là loại bỏ các ghi chú không hợp lệ thêm. Đây là một khối mã ẩn danh tạo ra chuỗi:

Ab A  A# Bb B   C  C# Db D  D# Eb E   F  F# Gb G  G#

R , 50 byte

cat("Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#")

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

Chán câu trả lời.

R , 60 byte

cat(outer(LETTERS[1:7],c("#","","b"),paste0)[-c(2,5,17,20)])

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

Than , 21 byte

Φ⪪⭆…α⁷⭆b #⁺ι벧↨⊖⊘φ²κ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

    α                   Predefined variable uppercase alphabet
   … ⁷                  First 7 letters i.e. `ABCEDFG`
  ⭆                     Map over characters and join
       b #              Literal string `b #`
      ⭆                 Map over characters and join
          ⁺ιλ           Concatenate outer and inner characters
 ⪪           ²          Split back into substrings of length 2
Φ                       Filter where nonzero
                  φ     Predefined variable 1000
                 ⊘      Halved i.e. 500
                ⊖       Decremented i.e 499
               ↨   ²    Converted to base 2 i.e. [1, 1, 1, 1, 1, 0, 0, 1, 1]
              §     κ   Cyclically indexed by outer index
                        Implicitly print matching values on separate lines

Japt , 23 22 byte

;B¯7
ï"b #" fÏÄ %9%8<6

Thử nó

;B          Alphabet
  ¯7        First seven characters ("ABCDEFG")
            Assign to U
ï"b #"       Cartesian product with "b #" ("Ab,A ,A#,Bb,B ,B#,Cb,C ,C#,Db,D ,D#,Eb,E ,E#,Fb,F ,F#,Gb,G ,G#")
f           Filter:
 ÏÄ           Is index + 1
   %9%8       Mod 9 Mod 8
     <6       Less than 6
            End filter ("Ab,A ,A#,Bb,B ,C ,C#,Db,D ,D#,Eb,E ,F ,F#,Gb,G ,G#")

REPL / APL REPL, 38 28 25 byte

(⊤2056111)⌿,' b#'∘.,⍨7↑⎕A

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

Stax , 17 15 byte

║♠+I▬┌ó£ΔφΔ`╗╨Å

Chạy và gỡ lỗi nó

Chương trình thưởng: in các biểu tượng ưa thích

Ruby , 43 byte

p (2..18).map{|i|"FCGDAEB"[i%7]+"b #"[i/7]}

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

Với phạm vi 0..20này sẽ in một mảng chứa tất cả các căn hộ, tất cả các tự nhiên và tất cả các vật sắc nhọn. Những người không mong muốn Fb Cb E# B#được bỏ qua bằng cách sử dụng phạm vi2..18

Các ghi chú được in ra theo thứ tự https://en.wikipedia.org/wiki/Circle_of_fifths , hay nói cách khác là tăng dần 7 nửa cung (tỷ lệ tần số gần như chính xác 1,5) mỗi lần.

Điều này dẫn đến thứ tự thư ghi chú được đưa ra, trong đó mỗi ghi chú được bao gồm năm độ (được gọi là "thứ năm") so với thứ tự trước đó. Ví dụ F->ClàFGABC

Brainfuck , 106 byte

+++[[-<+>>++<]>]<<[-<->]++<<++<,+<-<[->+>+<<]<+[>>>>>+>-[<.<<<.>.[<]]>[>]<+[---<.<.<.[<]]>[>]<++<.<<.<<<-]

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

Đầu ra mỗi ghi chú được phân tách bằng trả về vận chuyển.

Zsh , 36 byte

<<<${${(F):-{A..G}{b,,#}}//[BE]#???}

Một giải pháp xấu hơn, nhưng nó tiết kiệm hai nhân vật. (F)tham gia một danh sách trên các dòng mới và //[BE]#???loại bỏ các phần của chuỗi chúng ta cần.

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

Zsh , 38 byte

<<<${${:-{A..G}{b,,#}}:#([BE]#|[CF]b)}

Tôi luôn thích nó khi Zsh đánh bại Perl (hy vọng tôi không nói quá sớm ...).

<<<${${:-{A..G}{b,,#}}:#([BE]#|[CF]b)}
     ${:-             }                 # empty-fallback, basically an anonymous parameter expansion
         {A..G}{b,,#}                   # Cross product range A-G with b,(nothing),#
   ${                 :#             }  # Remove matching elements
                        ([BE]#|[CF]b)   # B#, E#, Cb, Fb
<<<                                     # Print to stdout

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

Thạch , 21 byte

ØAḣ7;p¥⁾b#“¿€×Ø‘œPẎẎ€

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

Brachylog , 36 byte

"#b"ẹ,Ẹ↺;Ṇh₇ᵗ↔{∋ᵐc}ᶠ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩

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

Tôi hiện đang trong quá trình cưỡng bức chỉ số sức mạnh cho phép tôi thoát khỏi ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩(và bằng cách mở rộng ↺, vì đầu ra không cần phải theo thứ tự như đầu ra ví dụ), nhưng nó hoàn toàn mất một trong khi ... có lẽ tôi nên dành một phút để thực sự tìm ra danh sách con thứ tự nào được tạo ra và tính toán chỉ mục theo cách đó ...

Canvas , 23 byte

Ｚ７ｍ｛#＋¹¹b＋］｛“╷!↕„２┬²＠？Ｐ

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

22 byte có thêm dòng mới trong đầu ra

PHP , 65 byte

Làm cho danh sách với một vòng lặp. Các mục được phân tách bằng _một dấu phân cách.

for(;$l=ABCDEFG[$i++];)echo$l._.[$a="$l#_",$a.$b=$l.b_,$b][$i%3];

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

PHP , 43 byte

PHP xuất ra bất cứ thứ gì như vậy, khi không bên trong <?phpvà ?>các thẻ.

Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#

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

Pyth , 23 21 byte

s<R7c.>*<r1G7"b #"2 9

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

s<R7c.>*<r1G7"b #"2 9   Implicit: G=lowercase alphabet
         r1G            Convert G to upper case
        <   7           First 7 characters
       *     "b #"      Cartesian product with "b #"
     .>           2     Rotate the above 2 places to the right
    c               9   Chop into pieces of length 9
 <R7                    Trim each to length 7
s                       Flatten, implicit print

Chỉnh sửa: Viết lại một phần để lưu 2 byte, phiên bản trước: s%2c*<r1G7"b #"xLG"fhoq Dùng thử trực tuyến!

Commodore C64 / TheC64 Mini (có thể là các biến thể BASIC 8 bit khác của Commodore) - 52 byte BASIC được mã hóa

 0?"{CTRL+N}Ab A A# Bb B C C# Db D D# Eb E F F# Gb GG#

Nhấn CTRLphím cộng Ntrên bàn phím C64 sẽ chuyển sang 'chế độ kinh doanh' trên bộ ký tự cho các ký tự chữ hoa / thường. Chúng tôi có thể in nó ra thành một chuỗi trong một byte / mã thông báo; và vì chúng tôi có 40 cột, không gian từ G đến G # là không bắt buộc.

Chúng ta không cần phải đóng chuỗi trong trường hợp này vì nó không phải là một dòng nhiều câu với :dấu phân cách.

Giao diện của màn hình Commodore C64 (và đồng hương) được hiển thị bên dưới.

Keg , 43 byte

Chuỗi, nén.

AbAA\#BbBCC\#DbDD\#EbEFF\#GbGG\#(:H<[ $]')'

TIO

APL (Dyalog Unicode) , 45 byte

2↓(,¨⎕A)⎕R', &'⊢'AbAA#BbBCC#DbDD#EbEFF#GbGG#'

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

⎕RThao tác đơn giản , chuẩn bị ,cho từng thành phần trong chuỗi khớp với từng chữ cái trong ⎕Alph.us, sau đó bỏ 2 ký tự đầu tiên ,.

Brainfuck, 214 byte

>>>>++++++++[<++++<++++<++++++++++++<++++++++>>>>-]<<+++<++<+.>.>>.<<<.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<+.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<+.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<.>>.>.<<<+

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

JavaScript (Node.js) , 84 byte

_=>[...'ABCDEFG'].map((n,i)=>`${i%3!=2?n+'b,':''}${n}${i%3!=1?`,${n}#`:''}`).join`,`

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

Chỉ cần trả về chuỗi (như hiển thị bên dưới) sẽ ngắn hơn 36 byte, nhưng đâu là niềm vui trong đó?

_=>'Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#'

Brainfuck , 255 115 byte

--[----->+<]>-----[<+>>+>+<<-]>>+<<<-[->+++<]>+++[->>>+>+<
<<<]>>>>--->+++++++[-<<<<.>.>>.<<<.>>>.<<<.>>.>.<<<+>>>>]

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

Bash 5 , 42 byte

x=`echo {A..G}{b,,#}`;echo ${x//[BE]#???/}

Đầu ra:

Ab A A# Bb B C C# Db D D# Eb E F F# Gb G G#

Perl 5 , 47 41 byte

say for'AbA#DbD#GbG#BbEbC#F#'=~/../g,A..G

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

T-SQL, 124 byte

SELECT value+a
FROM STRING_SPLIT('A-B-C-D-E-F-G','-')
    ,(VALUES('b'),(''),('#'))b(a)
WHERE value+a NOT IN ('B#','E#','Cb','Fb')

Ngắt dòng chỉ dành cho mục đích hiển thị.

Dài hơn nhưng thú vị hơn nhiều so với phiên bản tầm thường (50 byte) :

PRINT'Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#'

Z80Golf , 31 29 byte

00000000: 9d5b dc6d df7f 0603 3e40 d13c cb3a 3008  .[.m....>@.<.:0.
00000010: fff5 7b2f ffaf fff1 20f1 10ec 76         ..{/.... ...v

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

Giải thích :

Z80Golf chỉ là một cỗ máy tưởng tượng đơn giản dựa trên CPU 8 bit Z80. Chương trình được tải tại vị trí bộ nhớ 0x0000và phần còn lại của bộ nhớ chứa đầy số không. Đầu ra được thực hiện bằng cách gọi 0x8000, sẽ xuất giá trị của thanh ghi A dưới dạng ký tự.

Chương trình bắt đầu với dữ liệu sẽ được xử lý, tổng cộng 6 byte. Mỗi cặp byte chỉ định một hậu tố ghi chú và bitmask kiểm soát các chữ cái nào có thể được kết hợp với ghi chú này. Để lưu byte, ký tự hậu tố được đảo ngược ( xor 0xff) - điều này cho phép dữ liệu được thực thi theo hướng dẫn với ít tác dụng phụ, giúp có thể loại bỏ bước nhảy bỏ qua dữ liệu này:

               ;    GFEDCBA
    db 0xff^'b', 0b01011011 ; Ab Bb Db Eb Gb
    db 0xff^'#', 0b01101101 ; A# C# D# F# G#
    db 0xff^' ', 0b01111111 ; A  B  C  D  E  F  G
skip_data:

Đây là cách CPU giải mã điều này:

    sbc a, l  ; a subtraction with carry on registers we don't care about
    ld e, e   ; put the E register back into itself. This instruction is useless
              ; but still exists to make the encoding regular.
    call c, 0xdf6d ; if the carry flag is set, call a function. The carry flag isn't set
              ; because of the initial register values (all zeroes) when the sbc above
              ; was executed
    ld a, a   ; as above, put A back into itself.

Dữ liệu này được đọc hai byte cùng một lúc vào cặp thanh ghi DE. Con trỏ ngăn xếp được sử dụng để trỏ đến phần tử tiếp theo. Nó bắt đầu từ 0 và vì Z80 sử dụng ngăn xếp đầy đủ, giảm dần, bất kỳ cửa sổ bật lên nào cũng sẽ đọc cặp dữ liệu tiếp theo - tất cả các hoạt động ngăn xếp là 16 bit.

Vòng lặp bên ngoài được triển khai với bộ đếm giảm dần trong thanh ghi B, trong đó Z80 cung cấp hỗ trợ đặc biệt dưới dạng djnzhướng dẫn:

    ld b, 3
process_pair:
    ...
    djnz process_pair
    halt

Thư hiện tại được tổ chức trong sổ đăng ký A. Vì gia số phù hợp tốt khi bắt đầu vòng lặp, chúng tôi tải ít hơn một giá trị bắt đầu thực tế của A:

process_pair:
    ld a, 'A'-1
    pop de ; D = bitmask, E = suffix character
process_note:
    inc a
    srl d ; put the current bitmask bit in the carry flag
          ; also sets the zero flag if this is the last note in the pair
    jr nc, skip
    ; Print the note. Note that we need to preserve the zero flag to check it in the
    ; loop condition later.
    rst $38 ; Short encoding of call $0038.
            ; Because the program is so short, the memory in the 0038..8000 range
            ; is filled with zeroes, which happens to be the encoding for a no-op.
            ; The execution will therefore fall-through to the character-print hook.
    push af ; Save the letter on the stack (which will be just to the left of the
            ; unprocessed data) to free up A for printing other characters.
            ; (only 16-bit register pairs can be saved, so we also push the flags)
    ld a, e
    cpl     ; Undo the inversion used to make the execution fall-through the data.
            ; Done again each iteration because it takes less bytes to operate
            ; on the A register.
    rst $38 ; Print the suffix.
    xor a   ; Standard assembly practice of setting a register to zero by XORing it
            ; with itself. Saves a byte over a simple `ld a, 0`.
    rst $38 ; Print a null byte as a separator.
    pop af  ; Restore the current letter from the stack.
skip:
    jr nz, process_note ; If the zero flag (last changed at the srl d) is not set,
                        ; loop once again
    djnz process_pair
    halt