To zadanie jest proste: Napisz program lub funkcję, która wyświetli listę wszystkich nut (używając angielskich nazw nut) od A ♭ do G♯.

Wszystkie nuty bez nazwy składającej się z jednej litery (tj. Czarne nuty na klawiaturze muzycznej) powinny mieć wydrukowane dwa razy swoje imię, raz jako nuta nuty, raz jako płaska jednej. Ostre lub płaskie nuty, które można opisać pojedynczą literą, takie jak B♯ (C) lub F ♭ (E), nie powinny być wyprowadzane.

Oto przykład wyniku:

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

Dane techniczne

• Program lub funkcja nie może przyjmować żadnych danych wejściowych.

• Notatki mogą być drukowane w dowolnej kolejności i na dowolnej liście wyników dozwolonej przez nasze standardowe reguły We / Wy

• Ostre i płaskie symbole Unicode (♯ / ♭) mogą być zastąpione przez b i#

• Jak zawsze, standardowe luki są zabronione.

• Ponieważ jest to kod-golf , wygrywa najmniejszy program w bajtach.

Malbolge , 482 370 353 bajtów

R1: Usunięto przecinki między nimi (jak nie jest wymagane przez wyzwanie)

R2: Ogol kilka bajtów

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

Wypróbuj online!

Zespół CP-1610 ( Intellivision ), 31 DECLE ¹ = 39 bajtów

Procedura pobierania wskaźnika wyjściowego w R4 i zapisywania tam nut, oddzielonych spacjami. W przykładowym kodzie piszemy bezpośrednio na ekranie.

Zrzut szesnastkowy (tylko rutyna)

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

Pełne źródło

                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

Wydajność

^{zrzut ekranu z jzIntv}

_{1. Kod operacyjny CP-1610 jest kodowany za pomocą 10-bitowej wartości, zwanej „DECLE”. Ta procedura ma 31 DECLEs długości, zaczynając od 4820 $, a kończąc na 483E $ (w zestawie).}

Python 3 , 50 bajtów

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

Wypróbuj online!

Python 2: 48 bajtów

Ten kod można dostosować tak, aby zawierał B # i Cb, bez dodatkowych bajtów. Można to osiągnąć poprzez zastąpienie 5z 6.

Dodatkowo jest (w końcu) krótszy niż zwykły ciąg znaków:

Python 3 , 51 bajtów

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

Wypróbuj online!

Python 2: 50 bajtów

05AB1E , 16 15 13 bajtów

Au…b #âŽ7×bûÏ

-2 bajty dzięki @maxb .

Wypróbuj online.

Wyjście w postaci listy, w której nuty jednoznakowe mają spację końcową.

Wyjaśnienie:

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)

Zobacz moją wskazówkę 05AB1E (rozdział Jak kompresować duże liczby całkowite? ), Aby zrozumieć, dlaczego tak Ž7×jest 1999.

Ž7×alternatywnie może być ₄·<(1000, podwójnie, zmniejsz o 1) dla tej samej liczby bajtów.

Galaretka , 18? * 20 bajtów

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

Monadyczny link zwracający listę list znaków.

* _{Jeśli mieszana lista (a) list znaków i (b) znaków jest dopuszczalna, usuń końcowe W€18.}

Wypróbuj online!

W jaki sposób?

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

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

Wypróbuj online! Wyjaśnienie:

ABCDEFG

Wstaw nazwy nuty bazowej.

.
 $&b $& $&#

Rozwiń każdą notatkę, aby uwzględnić wersje płaskie i ostre.

 [BE]#...

Usuń B#, E#a także notatki po nich ( Cbi Eb).

Perl 6 , 41 bajtów

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

Wypróbuj online!

Prosty iloczyn banknotów i ostrych narzędzi / płaskich, a następnie usunięcie dodatkowych nieważnych nut. To anonimowy blok kodu, który tworzy ciąg znaków:

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

R , 50 bajtów

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

Wypróbuj online!

Nudna odpowiedź.

R , 60 bajtów

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

Wypróbuj online!

Węgiel drzewny , 21 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

    α                   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 bajtów

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

Spróbuj

;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 bajtów

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

Wypróbuj online!

Stax , 17 15 bajtów

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

Uruchom i debuguj

Program bonusowy: wydrukuj fantazyjne symbole

Rubinowy , 43 bajty

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

Wypróbuj online!

Przy takim zakresie 0..20wydrukowałby tablicę zawierającą wszystkie mieszkania, wszystkie zwierzęta naturalne i wszystkie ostre przedmioty. Niepożądane Fb Cb E# B#są pomijane przy użyciu zakresu2..18

Notatki są drukowane uporządkowane zgodnie z https://en.wikipedia.org/wiki/Circle_of_fifths , czyli innymi słowy, rosnąc o 7 półtonów (stosunek częstotliwości prawie dokładnie 1,5) za każdym razem.

Prowadzi to do podanej kolejności liter banknotów, w której każda nuta jest o pięć stopni włącznie (znana jako „piąta”) powyżej poprzedniej. Na przykład F->CjestFGABC

pieprzenie mózgu , 106 bajtów

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

Wypróbuj online!

Wysyła każdą nutę oddzieloną znakami powrotu karetki.

Zsh , 36 bajtów

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

Brzydsze rozwiązanie, ale oszczędza dwie postacie. (F)dołącza do listy w nowej linii i //[BE]#???usuwa potrzebne nam fragmenty ciągu.

Wypróbuj online!

Zsh , 38 bajtów

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

Zawsze lubię, gdy Zsh pokonuje Perla (mam nadzieję, że nie odezwę się zbyt wcześnie ...).

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

Wypróbuj online!

Galaretka , 21 bajtów

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

Wypróbuj online!

Brachylog , 36 bajtów

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

Wypróbuj online!

Obecnie jestem w trakcie brutalnego wymuszania indeksu powerset, który pozwoliłby mi się pozbyć ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩(i przez rozszerzenie ↺, ponieważ dane wyjściowe nie muszą być w tej samej kolejności co przykładowe dane wyjściowe), ale zajmuje to całkiem sporo podczas gdy ... może powinienem poświęcić chwilę, aby faktycznie ustalić, w jakiej kolejności generowane są listy podrzędne, i obliczyć indeks w ten sposób ...

Płótno , 23 bajty

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

Wypróbuj tutaj!

22 bajty z dodatkowymi znakami nowego wyjścia

PHP , 65 bajtów

Tworzy listę z pętlą. Elementy są oddzielane za _pomocą separatora końcowego.

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

Wypróbuj online!

PHP , 43 bajty

PHP wypisuje wszystko, co jest, gdy nie ma go w środku, <?phpi ?>tagi.

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

Wypróbuj online!

Pyth , 23 21 bajtów

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

Wypróbuj 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

Edycja: Częściowe przepisanie w celu zapisania 2 bajtów, poprzednia wersja: s%2c*<r1G7"b #"xLG"fhoq Wypróbuj online!

Commodore C64 / TheC64 Mini (prawdopodobnie inne 8-bitowe warianty BASIC Commodore) - 52 tokenizowane bajty BASIC

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

Naciśnięcie CTRLklawisza plus Nna klawiaturze C64 powoduje przejście do „trybu biznesowego” zestawu znaków dla wielkich / małych liter. Możemy wydrukować to w ciągu jednego bajta / tokena; a ponieważ mamy 40 kolumn, przestrzeń od G do G # nie jest wymagana.

W tym przypadku nie musimy zamykać łańcucha, ponieważ nie jest to linia z wieloma instrukcjami z :separatorem.

Jak to wygląda na ekranie Commodore C64 (i kompatybilnych) pokazano poniżej.

Beczka , 43 bajty

Ciąg skompresowany.

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

TIO

APL (Dyalog Unicode) , 45 bajtów

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

Wypróbuj online!

Prosta ⎕Roperacja eplace, poprzedzająca ,każdy element w łańcuchu, który pasuje do każdej litery w ⎕Aalfabecie, a następnie upuszcza pierwsze 2 znaki, które są ,.

Brainfuck, 214 bajtów

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

Wypróbuj online!

JavaScript (Node.js) , 84 bajtów

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

Wypróbuj online!

Samo zwrócenie ciągu (jak pokazano poniżej) byłoby krótsze o 36 bajtów, ale gdzie w tym jest zabawa?

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

pieprzenie mózgu , 255 115 bajtów

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

Wypróbuj online!

Bash 5 , 42 bajty

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

Wydajność:

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

Perl 5 , 47 41 bajtów

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

Wypróbuj online!

T-SQL, 124 bajty

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

Podziały linii służą wyłącznie do wyświetlania.

Dłuższa, ale o wiele bardziej interesująca niż wersja trywialna (50 bajtów) :

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

Z80Golf , 31 29 bajtów

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

Wypróbuj online!

Objaśnienie :

Z80Golf to prosta fantazja oparta na 8-bitowym procesorze Z80. Program jest ładowany w miejscu pamięci 0x0000, a reszta pamięci jest wypełniona zerami. Wyjście odbywa się przez wywołanie 0x8000, które wyświetli wartość rejestru A jako znak.

Program rozpoczyna się od danych, które będą przetwarzane, łącznie 6 bajtów. Każda para bajtów określa sufiks nuty i maskę bitów kontrolującą, które litery można łączyć z tą nutą. Aby zapisać bajty, znak sufiksu jest odwrócony ( xor 0xff) - pozwala to na wykonanie danych jako instrukcji z niewielkimi efektami ubocznymi, umożliwiając usunięcie przeskoku, który pomija te dane:

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

W ten sposób procesor dekoduje to:

    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.

Te dane są odczytywane dwa bajty na raz do pary rejestrów DE. Wskaźnik stosu służy do wskazywania następnego elementu. Zaczyna się od 0, a ponieważ Z80 używa pełnego, malejącego stosu, każdy pop odczyta następną parę danych - wszystkie operacje na stosie są 16-bitowe.

Pętla zewnętrzna jest implementowana z licznikiem malejącym w rejestrze B, dla którego Z80 zapewnia specjalne wsparcie w postaci djnzinstrukcji:

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

Aktualny list znajduje się w rejestrze A. Ponieważ przyrost dobrze pasuje na początku pętli, ładujemy o jeden mniej niż faktyczna wartość początkowa 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