Questa attività è semplice: scrivere un programma o una funzione che emetta l'elenco di tutte le note musicali (usando nomi di note inglesi) da A ♭ a G♯.

Tutte le note senza un nome costituito da una singola lettera (cioè note nere su una tastiera musicale) dovrebbero avere il loro nome stampato due volte, una volta come il segno acuto di una nota, una volta come il piatto di una. Le note taglienti o piatte che possono essere descritte con una singola lettera, come B♯ (C) o F ♭ (E), non devono essere emesse.

Ecco un esempio dell'output:

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

specificazioni

Il programma o la funzione non deve accettare alcun input.
Le note possono essere stampate in qualsiasi ordine e in qualsiasi elenco di output consentito dalle nostre regole I / O standard
I simboli Unicode nitidi e piatti (♯ / ♭) possono essere sostituiti con b e#
Come sempre, le scappatoie standard sono vietate.
Dato che si tratta di code-golf , vince il programma più piccolo, in byte.

code-golf kolmogorov-complexity

— TheOnlyMrCat
fonte

3

relativi

— Jonathan Allan il

1

Possiamo produrre "C "invece di "C"?

— Arnauld

1

@Arnauld sì, puoi

— TheOnlyMrCat

7

A proposito, B # esiste nella notazione musicale; è ad esempio nella firma chiave per la chiave di C #, dove funge da tono principale.

— Kaz,

2

Non lo so, sembra che Cb manchi qui;)

— AJFaraday il

13

Malbolge , 482 370 353 byte

R1: rimosse le virgole tra di loro (come non richiesto dalla sfida)

R2: rasatura di pochi 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

Provalo online!

— Krzysztof Szewczyk
fonte

12

Assemblaggio CP-1610 ( Intellivision ), 31 DECLE ¹ = 39 byte

Una routine che prende un puntatore di output in R4 e vi scrive le note, separate da spazi. Nel codice di esempio, scriviamo direttamente sullo schermo.

Dump esadecimale (solo routine)

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

Fonte 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

Produzione

^{screenshot da jzIntv}

_{1. Un codice operativo CP-1610 è codificato con un valore di 10 bit, noto come "DECLE". Questa routine è lunga 31 DECLE, a partire da $ 4820 e termina a $ 483E (incluso).}

— Arnauld
fonte

9

Python 3 , 50 byte

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

Provalo online!

Python 2: 48 byte

Questo codice può essere modificato in modo da includere B # e Cb, al costo di nessun byte aggiuntivo. Ciò può essere ottenuto sostituendo 5con 6.

Inoltre, è (finalmente) più breve della semplice emissione della stringa semplice:

Python 3 , 51 byte

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

Provalo online!

Python 2: 50 byte

— Jitse
fonte

2

Questa è una soluzione molto creativa

— TheOnlyMrCat il

7

05AB1E , 16 15 13 byte

Au…b #âŽ7×bûÏ

-2 byte grazie a @maxb .

Provalo online.

Output come un elenco, in cui le note a carattere singolo sono con uno spazio finale.

Spiegazione:

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)

Vedere questo 05AB1E punta del mio (sezione Come comprimere grandi numeri interi? ) Per capire il motivo per cui Ž7×è 1999.

Ž7×potrebbe essere alternativamente ₄·<(1000, doppio, diminuzione di 1) per lo stesso conteggio byte.

— Kevin Cruijssen
fonte

3

È 7£davvero necessario? Sembra funzionare bene senza di essa.

— max

6

Gelatina , 18? * 20 byte

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

Un collegamento monadico che restituisce un elenco di elenchi di caratteri.

* _{Se è accettabile un elenco misto di (a) elenchi di caratteri e (b) caratteri, rimuovere il finale W€per 18.}

Provalo online!

Come?

Ø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
fonte

@mirabilos sono 20 byte di codice sorgente, i caratteri Unicode rappresentano ciascuno un byte del codice sorgente - vedi la tabella codici collegata dalla parola bytesnell'intestazione.

— Jonathan Allan il

5

Retina 0.8.2 , 33 byte


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

Provalo online! Spiegazione:


ABCDEFG

Inserisci i nomi delle note di base.

.
 $&b $& $&#

Espandi ogni nota per includere versioni piatte e nitide.

 [BE]#...

Elimina B#, E#e anche le note che seguono ( Cbe Eb).

— Neil
fonte

5

Perl 6 , 41 byte

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

Provalo online!

Semplice prodotto incrociato delle note e degli oggetti taglienti / piatti, seguito dalla rimozione delle note extra non valide. Questo è un blocco di codice anonimo che produce la stringa:

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

— Jo King
fonte

4

R , 50 byte

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

Provalo online!

Risposta noiosa.

R , 60 byte

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

Provalo online!

— Giuseppe
fonte

1

Penso che l'elenco di esempi di note ridondanti non sia pensato per essere esaustivo - anche l'output di esempio omette Cbe E#.

— Stringa non correlata

4

Carbone , 21 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

    α                   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
fonte

3

Japt , 23 22 byte

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

Provalo

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

— Incarnazione dell'ignoranza
fonte

Il tuo codice contiene <6ma è <5nella spiegazione.

— TheOnlyMrCat

@TheOnlyMrCat Edited

— Embodiment of Ignorance

2

dzaima / APL REPL, 38 28 25 byte

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

Provalo online!

— dzaima
fonte

Penso che puoi rimuovere il file ⎕←.

— Erik the Outgolfer

@EriktheOutgolfer hmm sì, se

— passo

Oh giusto, ho dimenticato di contare il {}LOL.

— Erik the Outgolfer

2

Stax , 17 15 byte

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

Esegui ed esegui il debug

Programma bonus: stampa i simboli di fantasia

— ricorsivo
fonte

2

Rubino , 43 byte

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

Provalo online!

Con la gamma 0..20 questo stamperebbe una matrice che contiene tutti gli appartamenti, tutti i naturali e tutti gli oggetti taglienti. Quelli indesideratiFb Cb E# B# vengono omessi utilizzando l'intervallo2..18

Le note sono stampate ordinate secondo https://en.wikipedia.org/wiki/Circle_of_fifths , ovvero in ordine crescente di 7 semitoni (un rapporto di frequenza di quasi esattamente 1,5) ogni volta.

Questo porta all'ordine delle lettere di nota dato, in cui ogni nota è inclusiva di cinque gradi (nota come "quinta") sopra la precedente. Ad esempio F->CèFGABC

— Level River St
fonte

Mi piace che tu salga per quinte. Bello.

— Wayne Conrad,

2

Brainfuck , 106 byte

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

Provalo online!

Emette ciascuna nota separata da ritorni a capo.

— Jo King
fonte

2

Zsh , 36 byte

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

Una soluzione più brutta, ma salva due personaggi. (F)unisce un elenco su newline e //[BE]#???rimuove le parti della stringa di cui abbiamo bisogno.

Provalo online!

Zsh , 38 byte

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

Mi piace sempre quando Zsh batte Perl (speriamo di non parlare troppo presto ...).

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

Provalo online!

— GammaFunction
fonte

1

Gelatina , 21 byte

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

Provalo online!

— Erik the Outgolfer
fonte

1

Brachylog , 36 byte

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

Provalo online!

Sono attualmente in procinto di forzare brutalmente l'indice del powerset che mi permetterebbe di sbarazzarmi di ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩(e per estensione ↺, poiché l'output non deve essere nello stesso ordine dell'output di esempio), ma sta prendendo abbastanza un mentre ... forse dovrei mettere un minuto da parte per capire in che ordine vengono generate le liste secondarie e calcolare l'indice in quel modo ...

— Stringa non correlata
fonte

1

Tela , 23 byte

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

Provalo qui!

22 byte con nuove righe in più nell'output

— dzaima
fonte

1

PHP , 65 byte

Crea l'elenco con un ciclo. Gli articoli sono separati da _un separatore finale.

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

Provalo online!

PHP , 43 byte

PHP emette qualsiasi cosa sia, quando non è dentro <?phpe ?>tag.

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

Provalo online!

— night2
fonte

1

Pyth , 23 21 byte

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

Provalo online!

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

Modifica: riscrittura parziale per salvare 2 byte, versione precedente: s%2c*<r1G7"b #"xLG"fhoq provalo online!

— Sok
fonte

1

Commodore C64 / TheC64 Mini (probabilmente altre varianti BASIC a 8 bit di Commodore) - 52 byte BASIC tokenizzati

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

Premere il CTRLtasto piùN sulla tastiera C64 si passa alla "modalità business" sul set di caratteri per i caratteri maiuscoli / minuscoli. Possiamo stamparlo in una stringa in un byte / token; e poiché abbiamo 40 colonne, lo spazio da G a G # non è richiesto.

In questo caso non è necessario chiudere la stringa poiché non è una riga con più istruzioni con a : separatore.

Di seguito viene mostrato l'aspetto di una schermata Commodore C64 (e compatibili).

— Shaun Bebbers
fonte

1

Keg , 43 byte

La stringa, compressa.

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

TIO

— UN
fonte

0

APL (Dyalog Unicode) , 45 byte

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

Provalo online!

Semplice ⎕Roperazione eplace, anteponendo ,a ciascun elemento nella stringa che corrisponde a ciascuna lettera ⎕Adell'alfabeto, quindi rilasciando i primi 2 caratteri, che sono ,.

— J. Sallé
fonte

0

Brainfuck, 214 byte

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

Provalo online!

— Zachary Cotton
fonte

0

JavaScript (Node.js) , 84 byte

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

Provalo online!

Restituire la stringa (come mostrato sotto) sarebbe più breve di 36 byte, ma dov'è il divertimento?

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

— T. Dirks
fonte

0

Brainfuck , 255 115 byte

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

Provalo online!

— Krzysztof Szewczyk
fonte

1

Voterei questo, ma è sbagliato. Non c'è una nota nera tra B e C, o tra E e F. Quindi non dovresti produrre. B #, Cb, E # o Fb. Inoltre, non vedo nulla nelle specifiche sul fatto che sia OK per usare le lettere minuscole.

— Level River St

@LevelRiverSt la sfida non ha dichiarato da nessuna parte che non abbiamo note tra B, C, E e 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.

Mi sembra abbastanza chiaro e non vedo alcuna cronologia delle modifiche sull'OP sul mio schermo.

— Level River St

0

Bash 5 , 42 byte

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

Produzione:

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

— Thorsten
fonte

0

Perl 5 , 47 41 byte

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

Provalo online!

— Xcali
fonte

0

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

Le interruzioni di riga sono solo a scopo di visualizzazione.

Più lungo ma molto più interessante della versione banale (50 byte) :

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

— BradC
fonte

0

Z80Golf , 31 29 byte

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

Provalo online!

Spiegazione :

Z80Golf è solo una semplice macchina fantasy basata sulla CPU Z80 a 8 bit. Il programma viene caricato nella posizione di memoria 0x0000e il resto della memoria è pieno di zero. L'output viene eseguito chiamando 0x8000, che genererà il valore del registro A come carattere.

Il programma inizia con i dati che verranno elaborati, 6 byte in totale. Ogni coppia di byte specifica un suffisso di nota e una maschera di bit che controlla quale delle lettere può essere combinata con questa nota. Per salvare i byte, il carattere del suffisso viene invertito (xor 0xff ) - questo consente ai dati di essere eseguiti come istruzioni con piccoli effetti collaterali, rendendo possibile rimuovere un salto che salta questi dati:

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

Ecco come la CPU lo decodifica:

    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.

Questi dati vengono letti due byte alla volta nella coppia di registri DE. Il puntatore dello stack viene utilizzato per puntare all'elemento successivo. Inizia da 0 e poiché lo Z80 utilizza uno stack completo e discendente, tutti i pop leggeranno la coppia di dati successiva - tutte le operazioni dello stack sono a 16 bit.

Il loop esterno è implementato con un contatore decrescente nel registro B, per il quale lo Z80 fornisce un supporto speciale sotto forma di djnzistruzioni:

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

La lettera corrente è contenuta nel registro A. Poiché l'incremento si adatta bene all'inizio del ciclo, ne cariciamo uno in meno rispetto al valore iniziale effettivo di 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
fonte

Emette l'elenco di note musicali

specificazioni

Malbolge , 482 370 353 byte

Assemblaggio CP-1610 ( Intellivision ), 31 DECLE 1 = 39 byte

Dump esadecimale (solo routine)

Fonte completa

Produzione

Python 3 , 50 byte

Python 3 , 51 byte

05AB1E , 16 15 13 byte

Gelatina , 18? * 20 byte

Come?

Retina 0.8.2 , 33 byte

Perl 6 , 41 byte

R , 50 byte

R , 60 byte

Carbone , 21 byte

Japt , 23 22 byte

dzaima / APL REPL, 38 28 25 byte

Stax , 17 15 byte

Rubino , 43 byte

Brainfuck , 106 byte

Zsh , 36 byte

Zsh , 38 byte

Gelatina , 21 byte

Brachylog , 36 byte

Tela , 23 byte

PHP , 65 byte

PHP , 43 byte

Pyth , 23 21 byte

Commodore C64 / TheC64 Mini (probabilmente altre varianti BASIC a 8 bit di Commodore) - 52 byte BASIC tokenizzati

Keg , 43 byte

APL (Dyalog Unicode) , 45 byte

Brainfuck, 214 byte

JavaScript (Node.js) , 84 byte

Brainfuck , 255 115 byte

Bash 5 , 42 byte

Perl 5 , 47 41 byte

T-SQL, 124 byte

Z80Golf , 31 29 byte

Assemblaggio CP-1610 ( Intellivision ), 31 DECLE ¹ = 39 byte