Esta tarefa é simples: escreva um programa ou função que produza a lista de todas as notas musicais (usando nomes de notas em inglês) de A ♭ a G♯.

Todas as notas sem um nome consistindo em uma única letra (ou seja, notas pretas em um teclado musical) devem ter seu nome impresso duas vezes, uma vez como a afiada de uma nota, uma vez como o plano de uma. Notas nítidas ou planas que podem ser descritas com uma única letra, como B♯ (C) ou F ♭ (E), não devem ser produzidas.

Aqui está um exemplo da saída:

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

Especificações

• O programa ou função não deve receber nenhuma entrada.

• As notas podem ser impressas em qualquer ordem e em qualquer lista de saída permitida por nossas regras de E / S padrão

• Os símbolos Unicode nítidos e planos (♯ / ♭) podem ser substituídos por b e#

• Como sempre, as brechas padrão são proibidas.

• Como esse é o código-golfe , o menor programa, em bytes, vence.

Malbolge , 482 370 353 bytes

R1: vírgulas removidas entre elas (conforme não exigido pelo desafio)

R2: economize alguns 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

Experimente online!

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

Uma rotina que pega um ponteiro de saída em R4 e escreve as notas ali, separadas por espaços. No código de exemplo, escrevemos diretamente na tela.

Hex dump (somente rotina)

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

Saída

^{captura de tela do jzIntv}

_{1. Um código de operação CP-1610 é codificado com um valor de 10 bits, conhecido como 'DECLE'. Essa rotina tem 31 DECLEs, começando em US $ 4820 e terminando em US $ 483E (incluído).}

Python 3 , 50 bytes

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

Experimente online!

Python 2: 48 bytes

Esse código pode ser ajustado de modo a incluir B # e Cb, ao custo de bytes adicionais. Isso pode ser alcançado substituindo 5por 6.

Além disso, é (finalmente) mais curto do que apenas produzir a sequência simples:

Python 3 , 51 bytes

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

Experimente online!

Python 2: 50 bytes

05AB1E , 16 15 13 bytes

Au…b #âŽ7×bûÏ

-2 bytes graças a @maxb .

Experimente online.

Saída como uma lista, onde as notas de caractere único estão com um espaço à direita.

Explicação:

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)

Veja este 05AB1E ponta do meu (seção Como comprimir grandes inteiros? ) Para entender por que Ž7×é 1999.

Ž7×Como alternativa, pode ser ₄·<(1000, dobro, diminuir em 1) para a mesma contagem de bytes.

Gelatina , 18? * 20 bytes

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

Um link monádico retornando uma lista de listas de caracteres.

* _{Se uma lista mista de (a) lista de caracteres e (b) caracteres for aceitável, remova o final W€de 18.}

Experimente online!

Quão?

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

Retina 0.8.2 , 33 bytes

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

Experimente online! Explicação:

ABCDEFG

Insira os nomes das notas de base.

.
 $&b $& $&#

Expanda cada nota para incluir versões simples e nítidas.

 [BE]#...

Excluir B#, E#e também as notas seguintes eles ( Cbe Eb).

Perl 6 , 41 bytes

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

Experimente online!

Simples produto cruzado das notas e objectos cortantes / planos, seguido pela remoção de notas extras inválidas. Este é um bloco de código anônimo que produz a string:

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

R , 50 bytes

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

Experimente online!

Resposta chata.

R , 60 bytes

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

Experimente online!

Carvão , 21 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

    α                   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

Japonês , 23 22 bytes

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

Tente

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

dzaima / APL REPL, 38 28 25 bytes

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

Experimente online!

Stax , 17 15 bytes

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

Execute e depure

Programa de bônus: imprima os símbolos extravagantes

Ruby , 43 bytes

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

Experimente online!

Com o intervalo, 0..20isso imprimiria uma matriz contendo todos os apartamentos, todos os naturais e todos os objetos cortantes. Os indesejados Fb Cb E# B#são omitidos usando o intervalo2..18

As notas são impressas de acordo com https://en.wikipedia.org/wiki/Circle_of_fifths , ou em outras palavras, subindo 7 semitons (uma taxa de frequência de quase exatamente 1,5) a cada vez.

Isso leva à ordem da letra da nota fornecida, na qual cada nota é inclusive cinco graus (conhecida como "quinto") acima da nota anterior. Por exemplo F->CéFGABC

brainfuck , 106 bytes

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

Experimente online!

Produz cada nota separada por retornos de carro.

Zsh , 36 bytes

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

Uma solução mais feia, mas salva dois caracteres. (F)junta-se a uma lista de novas linhas e //[BE]#???remove as partes da string de que precisamos.

Experimente online!

Zsh , 38 bytes

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

Eu sempre gosto quando Zsh vence Perl (espero não falar tão cedo ...).

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

Experimente online!

Gelatina , 21 bytes

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

Experimente online!

Braquilog , 36 bytes

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

Experimente online!

Atualmente, estou no processo de forçar brutalmente o índice do conjunto de poderes que me deixaria me livrar ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩(e por extensão ↺, já que a saída não precisa estar na mesma ordem que a saída de exemplo), mas está demorando bastante enquanto ... talvez eu deva reservar um minuto para realmente descobrir em que sublistas de ordem são geradas e calcular o índice dessa maneira ...

Tela , 23 bytes

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

Experimente aqui!

22 bytes com novas linhas extras na saída

PHP , 65 bytes

Faz a lista com um loop. Os itens são separados por _um separador à direita.

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

Experimente online!

PHP , 43 bytes

O PHP produz qualquer coisa como está, quando não está dentro <?phpe ?>tags.

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

Experimente online!

Pitão , 23 21 bytes

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

Experimente 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

Editar: Reescrever parcial para salvar 2 bytes, versão anterior: s%2c*<r1G7"b #"xLG"fhoq Experimente online!

Commodore C64 / TheC64 Mini (provavelmente outras variantes BASIC de 8 bits do Commodore) - 52 bytes BASIC tokenizados

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

Pressionar a CTRLtecla mais Nno teclado C64 entra no 'modo comercial' no conjunto de caracteres para caracteres maiúsculos / minúsculos. Podemos imprimir isso em uma string em um byte / token; e como temos 40 colunas, o espaço de G a G # não é necessário.

Não precisamos fechar a string nesse caso, pois não é uma linha com várias instruções com um :separador.

A aparência dessa tela na tela do Commodore C64 (e compatíveis) é mostrada abaixo.

Barril , 43 bytes

A sequência, compactada.

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

TIO

APL (Dyalog Unicode) , 45 bytes

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

Experimente online!

⎕ROperação de substituição simples , precedendo ,cada elemento da cadeia de caracteres que corresponde a cada letra do ⎕Aalfabeto e, em seguida, eliminando os 2 primeiros caracteres, que são ,.

Brainfuck, 214 bytes

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

Experimente Online!

JavaScript (Node.js) , 84 bytes

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

Experimente online!

Retornar a string (como mostrado abaixo) seria mais curto em 36 bytes, mas qual é a graça?

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

brainfuck , 255 115 bytes

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

Experimente online!

Bash 5 , 42 bytes

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

Saída:

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

Perl 5 , 47 41 bytes

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

Experimente online!

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

Quebras de linha são apenas para fins de exibição.

Mais longo, mas muito mais interessante que a versão trivial (50 bytes) :

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

Z80Golf , 31 29 bytes

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

Experimente online!

Explicação :

O Z80Golf é apenas uma máquina de fantasia simples, baseada no CPU Z80 de 8 bits. O programa é carregado no local da memória 0x0000e o restante da memória é preenchido com zeros. A saída é feita chamando 0x8000, que produzirá o valor do registro A como um caractere.

O programa começa com os dados que serão processados, 6 bytes no total. Cada par de bytes especifica um sufixo da nota e uma máscara de bit controlando qual das letras pode ser combinada com esta nota. Para salvar bytes, o caractere de sufixo é invertido ( xor 0xff) - isso permite que os dados sejam executados como instruções com pequenos efeitos colaterais, possibilitando a remoção de um salto que ignora esses dados:

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

É assim que a CPU decodifica isso:

    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.

Esses dados são lidos dois bytes de cada vez no par de registradores DE. O ponteiro da pilha é usado para apontar para o próximo elemento. Começa em 0 e, como o Z80 usa uma pilha completa e descendente, todos os pops lerão o próximo par de dados - todas as operações da pilha são de 16 bits.

O loop externo é implementado com um contador decrescente no registrador B, para o qual o Z80 fornece suporte especial na forma da djnzinstrução:

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

A carta atual é mantida no registro A. Como o incremento se encaixa bem no início do loop, carregamos um a menos que o valor inicial 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