Esta tarea es simple: escriba un programa o función que genere la lista de todas las notas musicales (usando nombres de notas en inglés) de A ♭ a G♯.

Todas las notas sin un nombre que consista en una sola letra (es decir, notas negras en un teclado musical) deben tener su nombre impreso dos veces, una vez como una nota aguda, una vez como una plana. Las notas agudas o planas que se pueden describir con una sola letra, como B♯ (C) o F ♭ (E) no deben emitirse.

Aquí hay un ejemplo de la salida:

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

Presupuesto

El programa o función no debe tomar ninguna entrada.
Las notas se pueden imprimir en cualquier orden y en cualquier salida de lista permitida por nuestras reglas estándar de E / S
Los símbolos Unicode agudos y planos (♯ / ♭) pueden sustituirse con b y#
Como siempre, las lagunas estándar están prohibidas.
Como se trata de código de golf , el programa más pequeño, en bytes, gana.

code-golf kolmogorov-complexity

— TheOnlyMrCat
fuente

3

relacionado

— Jonathan Allan

1

¿Podemos producir en "C "lugar de "C"?

— Arnauld

1

@Arnauld sí, puedes

— TheOnlyMrCat

77

Por cierto, B # existe en notación musical; está, por ejemplo, en la firma de la clave de C #, donde sirve como tono principal.

— Kaz

2

No sé, parece que falta Cb aquí;)

— AJFaraday

13

Malbolge , 482 370 353 bytes

R1: comas eliminadas en el medio (como no es requerido por el desafío)

R2: afeitarse unos pocos bytes

('<;_#!=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

Pruébalo en línea!

— Krzysztof Szewczyk
fuente

12

Conjunto CP-1610 ( Intellivision ), 31 DECLEs ¹ = 39 bytes

Una rutina que toma un puntero de salida en R4 y escribe las notas allí, separadas por espacios. En el código de ejemplo, escribimos directamente en la pantalla.

Volcado hexadecimal (solo rutina)

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

Fuente completa

                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

Salida

^{captura de pantalla de jzIntv}

_{1. Un código de operación CP-1610 está codificado con un valor de 10 bits, conocido como 'DECLE'. Esta rutina tiene 31 DECLEs de largo, comenzando en $ 4820 y terminando en $ 483E (incluido).}

— Arnauld
fuente

9

Python 3 , 50 bytes

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

Pruébalo en línea!

Python 2: 48 bytes

Este código se puede ajustar para incluir B # y Cb, sin costo de bytes adicionales. Esto se puede lograr reemplazando 5con 6.

Además, es (finalmente) más corto que simplemente generar la cadena simple:

Python 3 , 51 bytes

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

Pruébalo en línea!

Python 2: 50 bytes

— Jitse
fuente

2

Esta es una solución muy creativa

— TheOnlyMrCat

7

05AB1E , 16 15 13 bytes

Au…b #âŽ7×bûÏ

-2 bytes gracias a @maxb .

Pruébalo en línea.

Salidas como una lista, donde las notas de un solo carácter tienen un espacio final.

Explicación:

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)

Ver este consejo 05AB1E mío (sección Cómo comprimir grandes números enteros? ) Para entender por qué Ž7×es1999 .

Ž7×alternativamente podría ser ₄·<(1000, doble, disminuir en 1) para el mismo número de bytes.

— Kevin Cruijssen
fuente

3

¿Es 7£realmente necesario? Parece funcionar bien sin él.

— maxb

6

Jalea , 18? * 20 bytes

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

Un enlace monádico que devuelve una lista de listas de caracteres.

* _{Si una lista mixta de (a) listas de caracteres y (b) caracteres es aceptable, elimine el final W€de 18.}

Pruébalo en línea!

¿Cómo?

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

— Jonathan Allan
fuente

@mirabilos son 20 bytes de código fuente, los caracteres Unicode representan cada uno un byte del código fuente; vea la página de códigos vinculada por la palabra bytesen el encabezado.

— Jonathan Allan

5

Retina 0.8.2 , 33 bytes


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

Pruébalo en línea! Explicación:


ABCDEFG

Inserte los nombres de las notas base.

.
 $&b $& $&#

Expanda cada nota para incluir versiones planas y nítidas.

 [BE]#...

Eliminar B#, E#y también las notas que los siguen ( Cby Eb).

— Neil
fuente

5

Perl 6 , 41 bytes

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

Pruébalo en línea!

Producto cruzado simple de las notas y los objetos punzantes / planos, seguido de la eliminación de las notas inválidas adicionales. Este es un bloque de código anónimo que produce la cadena:

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

— Jo King
fuente

4

R , 50 bytes

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

Pruébalo en línea!

Aburrida respuesta.

R , 60 bytes

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

Pruébalo en línea!

— Giuseppe
fuente

1

Creo que la lista de ejemplos de notas redundantes no pretende ser exhaustiva: el resultado del ejemplo también omite Cby E#.

— Cadena no relacionada

4

Carbón , 21 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

    α                   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

— Neil
fuente

3

Japt , 23 22 bytes

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

Intentalo

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

— Encarnación de la ignorancia
fuente

Su código contiene <6pero está <5en la explicación.

— TheOnlyMrCat

@TheOnlyMrCat Editado

— Encarnación de la ignorancia

2

dzaima / APL REPL, 38 28 25 bytes

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

Pruébalo en línea!

— dzaima
fuente

Creo que puedes eliminar el ⎕←.

— Erik the Outgolfer

@EriktheOutgolfer hmm sí, si cambio a REPL

— dzaima

Oh cierto, olvidé contar el {}LOL.

— Erik the Outgolfer

2

Stax , 17 15 bytes

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

Ejecutar y depurarlo

Programa de bonificación: imprime los símbolos elegantes

— recursivo
fuente

2

Ruby , 43 bytes

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

Pruébalo en línea!

Con el rango, 0..20esto imprimiría una matriz que contiene todos los planos, todos los naturales y todos los objetos punzantes. Los no deseados Fb Cb E# B#se omiten al usar el rango2..18

Las notas se imprimen ordenadas de acuerdo con https://en.wikipedia.org/wiki/Circle_of_fifths , o en otras palabras, ascendentes en 7 semitonos (una relación de frecuencia de casi exactamente 1,5) cada vez.

Esto lleva al orden de las letras de las notas, en el que cada nota tiene cinco grados inclusive (conocido como "quinto") sobre la anterior. Por ejemplo F->CesFGABC

— Level River St
fuente

Me gusta que asciendas por quintos. Agradable.

— Wayne Conrad

2

brainfuck , 106 bytes

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

Pruébalo en línea!

Emite cada nota separada por retornos de carro.

— Jo King
fuente

2

Zsh , 36 bytes

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

Una solución más fea, pero guarda dos caracteres. (F)se une a una lista de nuevas líneas y //[BE]#???elimina las partes de la cadena que necesitamos.

Pruébalo en línea!

Zsh , 38 bytes

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

Siempre lo disfruto cuando Zsh vence a Perl (espero no hablar demasiado pronto ...).

<<<${${:-{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

Pruébalo en línea!

— Función Gamma
fuente

1

Jalea , 21 bytes

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

Pruébalo en línea!

— Erik el Outgolfer
fuente

1

Brachylog , 36 bytes

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

Pruébalo en línea!

Actualmente estoy en el proceso de forzar al índice de potencia bruta que me permitiría deshacerme ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩(y por extensión ↺, ya que la salida no necesita estar en el mismo orden que la salida de ejemplo), pero está tomando bastante mientras que ... tal vez debería dedicar un minuto para calcular en qué orden se generan las sublistas y calcular el índice de esa manera ...

— Cadena no relacionada
fuente

1

Lienzo , 23 bytes.

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

Pruébalo aquí!

22 bytes con nuevas líneas adicionales en la salida

— dzaima
fuente

1

PHP , 65 bytes

Hace la lista con un bucle. Los elementos están separados por _un separador final.

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

Pruébalo en línea!

PHP , 43 bytes

PHP genera todo tal cual, cuando no está dentro <?phpy las ?>etiquetas.

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

Pruébalo en línea!

— Noche2
fuente

1

Pyth , 23 21 bytes

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

Pruébalo en línea!

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

Editar: reescritura parcial para guardar 2 bytes, versión anterior: ¡ s%2c*<r1G7"b #"xLG"fhoq Pruébelo en línea!

— Sok
fuente

1

Commodore C64 / TheC64 Mini (probablemente otras variantes básicas de Commodore de 8 bits) - 52 bytes BASIC tokenizados

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

Al presionar la CTRLtecla plus Nen el teclado C64 se ingresa al 'modo de negocios' en el juego de caracteres para mayúsculas / minúsculas. Podemos imprimir esto en una cadena en un byte / token; y como tenemos 40 columnas, no se requiere el espacio de G a G #.

No necesitamos cerrar la cadena en este caso, ya que no es una línea con múltiples estados con un :separador.

A continuación se muestra cómo se ve esto en una pantalla Commodore C64 (y compatibles).

— Shaun Bebbers
fuente

1

Barril , 43 bytes

La cuerda, comprimida.

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

TIO

— UNA
fuente

0

APL (Dyalog Unicode) , 45 bytes

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

Pruébalo en línea!

⎕ROperación eplace simple, que antecede ,a cada elemento en la cadena que coincide con cada letra en el ⎕Aalfabeto, luego suelta los primeros 2 caracteres, que son ,.

— J. Sallé
fuente

0

Brainfuck, 214 bytes

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

Pruébalo en línea!

— Algodón Zachary
fuente

0

JavaScript (Node.js) , 84 bytes

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

Pruébalo en línea!

Solo devolver la cadena (como se muestra a continuación) sería más corto en 36 bytes, pero ¿dónde está la diversión en eso?

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

— T. Dirks
fuente

0

brainfuck , de 255 115 bytes

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

Pruébalo en línea!

— Krzysztof Szewczyk
fuente

1

Votaría esto, pero está mal. No hay una nota negra entre B y C, o entre E y F. Por lo tanto, se supone que no debe emitir. B #, Cb, E # o Fb. Además, no veo nada en la especificación sobre si está bien usar minúsculas.

— Level River St

@LevelRiverSt el desafío no indicó en ninguna parte que no tenemos notas entre B y C & E y F

— Krzysztof Szewczyk

All notes without a name consisting of a single letter (i.e. black notes on a musical keyboard) should have their name printed twice, once as the sharp of a note, once as the flat of one. Sharp or flat notes that can be described with a single letter, like B♯ (C) or F♭ (E) should not be outputted.

Eso me parece bastante claro, y no veo ningún historial de edición en el OP en mi pantalla.

— Level River St

0

Bash 5 , 42 bytes

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

Salida:

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

— Thorsten
fuente

0

Perl 5 , 47 41 bytes

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

Pruébalo en línea!

— Xcali
fuente

0

T-SQL, 124 bytes

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

Los saltos de línea son solo para fines de visualización.

Más largo pero mucho más interesante que la versión trivial (50 bytes) :

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

— BradC
fuente

0

Z80Golf , 31 29 bytes

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

Pruébalo en línea!

Explicación :

Z80Golf es solo una máquina de fantasía simple basada en la CPU Z80 de 8 bits. El programa se carga en la ubicación de la memoria.0x0000 y el resto de la memoria se llena con ceros. La salida se realiza mediante una llamada 0x8000, que generará el valor del registro A como un carácter.

El programa comienza con los datos que se procesarán, 6 bytes en total. Cada par de bytes especifica un sufijo de nota y una máscara de bits que controla qué letras se pueden combinar con esta nota. Para guardar bytes, el carácter de sufijo se invierte ( xor 0xff): esto permite que los datos se ejecuten como instrucciones con pequeños efectos secundarios, lo que permite eliminar un salto que omite estos datos:

               ;    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:

Así es como la CPU decodifica esto:

    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.

Estos datos se leen dos bytes a la vez en el par de registros DE. El puntero de la pila se usa para señalar el siguiente elemento. Comienza en 0, y debido a que el Z80 usa una pila descendente completa, cualquier mensaje emergente leerá el siguiente par de datos: todas las operaciones de la pila son de 16 bits.

El bucle externo se implementa con un contador decreciente en el registro B, para el cual el Z80 proporciona soporte especial en forma de djnzinstrucción:

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

La carta actual se encuentra en el registro A. Debido a que el incremento se ajusta bien al comienzo del ciclo, cargamos uno menos que el valor de inicio real de 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

— NieDzejkob
fuente

Salida de la lista de notas musicales.

Presupuesto

Malbolge , 482 370 353 bytes

Conjunto CP-1610 ( Intellivision ), 31 DECLEs 1 = 39 bytes

Volcado hexadecimal (solo rutina)

Fuente completa

Salida

Python 3 , 50 bytes

Python 3 , 51 bytes

05AB1E , 16 15 13 bytes

Jalea , 18? * 20 bytes

¿Cómo?

Retina 0.8.2 , 33 bytes

Perl 6 , 41 bytes

R , 50 bytes

R , 60 bytes

Carbón , 21 bytes

Japt , 23 22 bytes

dzaima / APL REPL, 38 28 25 bytes

Stax , 17 15 bytes

Ruby , 43 bytes

brainfuck , 106 bytes

Zsh , 36 bytes

Zsh , 38 bytes

Jalea , 21 bytes

Brachylog , 36 bytes

Lienzo , 23 bytes.

PHP , 65 bytes

PHP , 43 bytes

Pyth , 23 21 bytes

Commodore C64 / TheC64 Mini (probablemente otras variantes básicas de Commodore de 8 bits) - 52 bytes BASIC tokenizados

Barril , 43 bytes

APL (Dyalog Unicode) , 45 bytes

Brainfuck, 214 bytes

JavaScript (Node.js) , 84 bytes

brainfuck , de 255 115 bytes

Bash 5 , 42 bytes

Perl 5 , 47 41 bytes

T-SQL, 124 bytes

Z80Golf , 31 29 bytes

Conjunto CP-1610 ( Intellivision ), 31 DECLEs ¹ = 39 bytes