Tugas ini sederhana: Tulis program atau fungsi yang menampilkan daftar semua not musik (menggunakan nama not Bahasa Inggris) dari A ♭ ke G♯.

Semua catatan tanpa nama yang terdiri dari satu huruf (yaitu catatan hitam pada keyboard musikal) harus memiliki nama mereka dicetak dua kali, sekali sebagai tajam dari catatan, sekali sebagai flat dari satu. Catatan tajam atau datar yang dapat dijelaskan dengan satu huruf, seperti B♯ (C) atau F ♭ (E) tidak boleh ditampilkan.

Ini adalah contoh dari output:

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

Spesifikasi

• Program atau fungsi tidak boleh mengambil input apa pun.

• Catatan dapat dicetak dalam urutan apa pun, dan dalam daftar keluaran apa pun yang diizinkan oleh aturan I / O standar kami

• Simbol Unicode yang tajam dan datar (♯ / ♭) dapat diganti dengan b dan#

• Seperti biasa, lubang standar dilarang.

• Karena ini adalah kode-golf , program terkecil, dalam byte, menang.

Malbolge , 482 370 353 byte

R1: Penghilangan koma peralihan (karena tidak diharuskan oleh tantangan)

R2: Memotong beberapa 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

Cobalah online!

Perakitan CP-1610 ( Intellivision ), 31 DECLEs ¹ = 39 byte

Rutin mengambil pointer output di R4 dan menulis catatan di sana, dipisahkan dengan spasi. Dalam kode contoh, kami menulis langsung ke layar.

Hex dump (hanya rutin)

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

Sumber lengkap

                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

Keluaran

^{tangkapan layar dari jzIntv}

_{1. Sebuah opcode CP-1610 dikodekan dengan nilai 10-bit, yang dikenal sebagai 'DECLE'. Rutin ini sepanjang 31 DECLEs, mulai dari $ 4820 dan berakhir pada $ 483E (termasuk).}

Python 3 , 50 byte

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

Cobalah online!

Python 2: 48 byte

Kode ini dapat disesuaikan untuk menyertakan B # dan Cb, dengan biaya tanpa byte tambahan. Ini dapat dicapai dengan mengganti 5dengan 6.

Selain itu, ini (akhirnya) lebih pendek dari sekadar mengeluarkan string polos:

Python 3 , 51 byte

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

Cobalah online!

Python 2: 50 byte

05AB1E , 16 15 13 byte

Au…b #âŽ7×bûÏ

-2 byte terima kasih kepada @maxb .

Cobalah online.

Output sebagai daftar, di mana catatan char tunggal dengan spasi tambahan.

Penjelasan:

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)

Lihat ini 05AB1E ujung tambang (bagian Cara kompres bilangan bulat besar? ) Untuk memahami mengapa Ž7×adalah 1999.

Ž7×bisa juga ₄·<(1000, dobel, kurangi 1) untuk byte-count yang sama.

Jelly , 18? * 20 byte

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

Tautan monadik mengembalikan daftar daftar karakter.

* _{Jika daftar campuran (a) daftar karakter dan (b) karakter dapat diterima hapus jejak W€untuk 18.}

Cobalah online!

Bagaimana?

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

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

Cobalah online! Penjelasan:

ABCDEFG

Masukkan nama catatan dasar.

.
 $&b $& $&#

Perluas setiap not untuk menyertakan versi datar dan tajam.

 [BE]#...

Hapus B#, E#dan juga catatan yang mengikuti mereka ( Cbdan Eb).

Perl 6 , 41 byte

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

Cobalah online!

Produk silang sederhana dari catatan dan benda tajam / flat, diikuti dengan menghapus catatan tambahan yang tidak valid. Ini adalah blok kode anonim yang menghasilkan string:

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

Cobalah online!

Jawaban yang membosankan.

R , 60 byte

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

Cobalah online!

Arang , 21 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

    α                   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

Cobalah

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

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

Cobalah online!

Stax , 17 15 byte

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

Jalankan dan debug itu

Program bonus: cetak simbol mewah

Ruby , 43 byte

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

Cobalah online!

Dengan rentang 0..20ini akan mencetak array yang berisi semua flat, semua alami dan semua benda tajam. Yang tidak diinginkan Fb Cb E# B#dihilangkan dengan menggunakan rentang2..18

Catatan dicetak dicetak sesuai dengan https://en.wikipedia.org/wiki/Circle_of_fifths , atau dengan kata lain naik dengan 7 semitones (rasio frekuensi hampir persis 1,5) setiap kali.

Ini mengarah pada urutan surat yang diberikan, di mana setiap nada adalah lima derajat inklusif (dikenal sebagai "kelima") di atas yang sebelumnya. Sebagai contoh F->CadalahFGABC

brainfuck , 106 byte

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

Cobalah online!

Output setiap not dipisahkan oleh carriage return.

Zsh , 36 byte

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

Solusi yang lebih buruk, tetapi menghemat dua karakter. (F)bergabung dengan daftar pada baris baru, dan //[BE]#???menghapus bagian-bagian dari string yang kita butuhkan.

Cobalah online!

Zsh , 38 byte

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

Saya selalu menikmatinya ketika Zsh mengalahkan Perl (mudah-mudahan saya tidak berbicara terlalu cepat ...).

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

Cobalah online!

Jelly , 21 byte

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

Cobalah online!

Brachylog , 36 byte

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

Cobalah online!

Saat ini saya sedang dalam proses brute-forcing memaksa indeks powerset yang akan membiarkan saya menyingkirkan ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩(dan dengan ekstensi ↺, karena output tidak perlu berada dalam urutan yang sama dengan contoh output), tetapi butuh cukup sementara ... mungkin saya harus menyisihkan satu menit untuk benar-benar mengetahui urutan sublists yang dihasilkan, dan menghitung indeks dengan cara itu ...

Kanvas , 23 byte

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

Coba di sini!

22 byte dengan baris baru ekstra dalam output

PHP , 65 byte

Membuat daftar dengan satu lingkaran. Item dipisahkan oleh _dengan trailing separator.

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

Cobalah online!

PHP , 43 byte

PHP mengeluarkan apa saja, bila tidak di dalam, <?phpdan diberi ?>tag.

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

Cobalah online!

Pyth , 23 21 byte

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

Cobalah 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

Sunting: Tulis ulang sebagian untuk menghemat 2 byte, versi sebelumnya: s%2c*<r1G7"b #"xLG"fhoq Cobalah online!

Commodore C64 / TheC64 Mini (mungkin varian BASIC 8-bit Commodore lainnya) - 52 byte BASIC tokenized

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

Menekan CTRLtombol plus Npada keyboard C64 masuk ke 'mode bisnis' pada karakter yang ditetapkan untuk karakter huruf besar / kecil. Kami dapat mencetak ini dalam string dalam satu byte / token; dan karena kami memiliki 40 kolom, ruang dari G ke G # tidak diperlukan.

Kita tidak perlu menutup string dalam kasus ini karena ini bukan garis multi-pernyataan dengan :pemisah.

Bagaimana ini terlihat pada layar Commodore C64 (dan yang kompatibel) ditunjukkan di bawah ini.

Tong , 43 byte

Tali, dikompresi.

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

TIO

APL (Dyalog Unicode) , 45 byte

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

Cobalah online!

⎕ROperasi eplace sederhana , mengawali ,setiap elemen dalam string yang cocok dengan setiap huruf dalam ⎕Alfabet, lalu menjatuhkan 2 karakter pertama, yaitu ,.

Brainfuck, 214 Bytes

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

Cobalah secara Online!

JavaScript (Node.js) , 84 byte

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

Cobalah online!

Hanya mengembalikan string (seperti yang ditunjukkan di bawah) akan lebih pendek sebesar 36 byte, tetapi di mana kesenangannya?

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

brainfuck , 255 115 byte

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

Cobalah online!

Bash 5 , 42 byte

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

Keluaran:

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

Cobalah online!

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

Jeda baris hanya untuk tujuan tampilan.

Lebih lama tetapi jauh lebih menarik daripada versi sepele (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

Cobalah online!

Penjelasan :

Z80Golf hanyalah mesin fantasi sederhana berdasarkan Z80 8-bit CPU. Program dimuat di lokasi memori 0x0000, dan sisa memori diisi dengan nol. Output dilakukan dengan memanggil 0x8000, yang akan menampilkan nilai register A sebagai karakter.

Program dimulai dengan data yang akan diproses, totalnya 6 byte. Setiap pasangan byte menentukan akhiran catatan, dan bitmask yang mengontrol huruf mana yang dapat dikombinasikan dengan catatan ini. Untuk menyimpan byte, karakter suffix terbalik ( xor 0xff) - ini memungkinkan data dieksekusi sebagai instruksi dengan sedikit efek samping, sehingga memungkinkan untuk menghapus lompatan yang melewatkan data ini:

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

Beginilah cara CPU menerjemahkan ini:

    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.

Data ini dibaca dua byte sekaligus ke dalam pasangan register DE. Penunjuk tumpukan digunakan untuk menunjuk ke elemen berikutnya. Ini dimulai pada 0, dan karena Z80 menggunakan tumpukan penuh, turun, setiap pops akan membaca pasangan data berikutnya - semua operasi tumpukan adalah 16-bit.

Loop luar diimplementasikan dengan penghitung pengurangan di register B, yang mana Z80 menyediakan dukungan khusus dalam bentuk djnzinstruksi:

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

Surat saat ini disimpan di register A. Karena kenaikan cocok pada awal loop, kami memuat satu kurang dari nilai awal aktual 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