Ồ không! Tôi có một bài kiểm tra lý thuyết sớm và tôi chưa nhớ quy mô! Giúp tôi nhớ quy mô chính của mình bằng cách in như sau:

7♯ - C♯ D♯ E♯ F♯ G♯ A♯ B♯ C♯
6♯ - F♯ G♯ A♯ B  C♯ D♯ E♯ F♯
5♯ - B  C♯ D♯ E  F♯ G♯ A♯ B
4♯ - E  F♯ G♯ A  B  C♯ D♯ E
3♯ - A  B  C♯ D  E  F♯ G♯ A
2♯ - D  E  F♯ G  A  B  C♯ D
1♯ - G  A  B  C  D  E  F♯ G
0  - C  D  E  F  G  A  B  C
1♭ - F  G  A  B♭ C  D  E  F
2♭ - B♭ C  D  E♭ F  G  A  B♭
3♭ - E♭ F  G  A♭ B♭ C  D  E♭
4♭ - A♭ B♭ C  D♭ E♭ F  G  A♭
5♭ - D♭ E♭ F  G♭ A♭ B♭ C  D♭
6♭ - G♭ A♭ B♭ C♭ D♭ E♭ F  G♭
7♭ - C♭ D♭ E♭ F♭ G♭ A♭ B♭ C♭

Đây là mã golf, vì vậy mã ngắn nhất sẽ thắng. Bạn có thể sử dụng #và bký hiệu thay vì ♯và ♭tương ứng.

Chỉnh sửa: Nếu bạn đang sử dụng ♯và ♭ký, bạn chỉ phải tính chúng là một byte duy nhất. Điều này là để không đưa ra một bất lợi không công bằng.

Than , 66 65 byte (nếu sử dụng # và b)

↑⮌…0¦8‖Ｏ⸿×⁷♭Ｍ→×⁷♯→⸿⸿¹⁵ＦＥ⁸﹪⊕⊗ι⁷«⸿⸿✂׳FCGDAEBι⁺¹⁵ι→⸿✂⭆♭ ♯×⁷κι⁺¹⁵ι»⟲

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

↑⮌…0¦8‖Ｏ

In các ký tự 0để 7đảo ngược, sau đó phản ánh với chồng chéo. Danh sách thường in xuống dưới, do đó, in lên trên thực sự in ngay; chúng tôi sẽ xoay mọi thứ vào vị trí cuối cùng.

⸿×⁷♭Ｍ→×⁷♯

Bắt đầu một dòng mới và in 7 căn hộ và 7 sắc nét với một khoảng cách ở giữa.

→⸿⸿¹⁵

Để lại một dòng trống và in 15 -s.

ＦＥ⁸﹪⊕⊗ι⁷«

Lấy các số từ 0 đến 7, nhân đôi chúng, thêm 1, sau đó giảm modulo 7. Lặp lại kết quả.

⸿⸿✂׳FCGDAEBι⁺¹⁵ι

Để lại một dòng trống và sau đó lấy một lát 15 ký tự của chuỗi ghi chú ba lần bắt đầu từ giá trị hiện tại.

→⸿✂⭆♭ ♯×⁷κι⁺¹⁵ι

Trên dòng tiếp theo, hãy cắt một lát gồm 15 ký tự căn hộ, khoảng trắng và sắc nét, mỗi lần lặp lại 7 lần.

»⟲

Sau khi in tất cả các ghi chú, xoay mọi thứ vào vị trí.

Ruby , 113 byte ( 131 126 108 105 với # và b)

-7.upto(7){|i|print i.abs," ♭♯"[i<=>0]," - ",(4..11).map{|j|("FCGDAEB"*3)[k=j*2%7-i]+"♭♯ "[~k/7]}*" ",$/}

Hãy thử trực tuyến!

Ruby , 116 byte (108 với # và b)

Hãy thử trực tuyến!

Ruby , 126 byte (118 với # và b)

Hãy thử trực tuyến!

Ruby , 131 byte với # và b

Hãy thử trực tuyến!

Python 3 , 135 byte

đếm và ♭ là 1 byte mỗi

cảm ơn Zacharý cho -6 byte.

for i in range(15):k=' ♯♭'[(i<7)-(i>7)]+' -';print(str(i-7)[-1]+k,*[v+k[a+8>i>a]for a,v in zip([1,3,5,0,2,4,6,1],('CDEFGAB'*8)[i*3:])])

Hãy thử trực tuyến!

GNU sed , 148 144 + 1 = 145 byte

+1 byte cho -rcờ.

s/^/ 7# - C# D# E# F# G# A# B# \n65432101234567/
:
s/((.).(. - )((\S..){3})([^-]+)..\n)([0-7])/\1\2\7\3\6\2 \4\n/
s/ 0#/b0b/
t
s/^.//gm
s/0b/0 /

Hãy thử trực tuyến!

Giải trình

Đầu tiên, chèn một mẫu các loại:

 7# - C# D# E# F# G# A# B# 
65432101234567

Lưu ý không gian hàng đầu và dấu trên dòng đầu tiên.

Trong một vòng lặp, lấy số đầu tiên từ dòng cuối cùng và thay thế nó bằng các phần của dòng thứ hai đến cuối cùng như vậy:

 7# - C# D# E# F# G# A# B# 
│ └┬─┘└───┬───┘└───┬────┘
2  3      4        6
│  │      └────────│──┐
├──│────────────┐  │  │
│  │      ┌─────│──┘  │
│ ┌┴─┐┌───┴────┐│ ┌───┴───┐
 6# - F# G# A# B  C# D# E# 

Như bạn có thể thấy, không gian ban đầu (chụp 2) được sử dụng để thay thế ký tự sau B.

Khi 0đạt được, thay thế không gian ban đầu bằng b. Vòng lặp tiếp tục, nhưng thay vì thay thế #s bằng khoảng trắng, trên mỗi dòng tiếp theo, một khoảng trắng được thay thế bằng a b.

Cuối cùng, dọn dẹp một chút: Xóa ký tự đầu ra khỏi mỗi dòng và thay thế 0bbằng 0.

Befunge, 134 132 130 byte

<v:,,," - ",g2+!!\`0::,+*86*-1*2`0::p00:<75
@>4*65*+81v>55+,$$\:00g0`!\9p3+7%\1-:8+#^_
 b#"A"%7:\_^#:-1,*84,g2*+1`0g00!!g9%7:\+1,+

Hãy thử trực tuyến!

Giải trình

• Chúng tôi bắt đầu với một vòng lặp bên ngoài đếm ngược từ 7 đến -7. Chúng tôi sẽ gọi đây là số hàng .
• Đối với mỗi hàng, chúng tôi bắt đầu bằng cách viết ra '0'+abs(row)(số tỷ lệ), sau đó tính toán (row>0)+(row!=0)để tra cứu xem nó tự nhiên, sắc nét hay phẳng trong bảng #b(bạn sẽ thấy điều này ở đầu dòng mã thứ ba).
• Sau đó, chúng tôi tính toán ghi chú bắt đầu của quy mô, n , như 30 + row*4. Đây cuối cùng sẽ là mod 7, vì vậy hãy nghĩ về nó như là trình tự lặp lại 2,5,1,4,0,3,6 (tức là CFBEADG).
• Vòng lặp bên trong của chúng tôi, i , sau đó đếm ngược từ 8 xuống 1, cho tám ghi chú trong thang đo, tăng n trên mỗi lần lặp.
• Thư của ghi chú chỉ đơn giản là 'A' + n%7. Cho dù đó là sắc nét hay bằng phẳng được xác định bằng cách nhìn lên i%7trong một bảng. Bảng ban đầu là tất cả sự thật, vì quy mô đầu tiên là tất cả các sắc nét.
• Tuy nhiên, sau mỗi hàng là đầu ra, chúng tôi cập nhật bảng bằng cách chuyển đổi một giá trị. Ở lần lặp đầu tiên, chúng ta sẽ chuyển giá trị ở phần bù 5, nhưng mỗi vòng lặp phần bù được điều chỉnh theo (offset+3)%7.
• Ở nửa đầu của đầu ra, khi hàng lớn hơn 0, chúng tôi sẽ chuyển các giá trị bảng này thành sai. Ở nửa sau của đầu ra, khi hàng nhỏ hơn hoặc bằng 0, chúng ta sẽ đặt chúng trở về đúng.

Bong bóng , 107 byte

Ngưỡng bong bóng

00000000: 4dca a90d 0301 1443 41ee 2a9e f4b1 a5ec  M......CA.*.....
00000010: 8d73 f7e1 fe8b 48a0 e968 aec1 3c87 d7f0  .s....H..h..<...
00000020: 1e3e c377 b80f 8ff9 a3ce c165 74d4 31b8  .>.w.......et.1.
00000030: 8c8a da07 1751 4fdb e022 ea69 1d5c 443d  .....QO..".i.\D=
00000040: 2d83 8ba8 a71b b888 7a5a 828b 524f 6b70  -.......zZ..ROkp
00000050: 51fa 690b 2e4b 47ed c165 e9a8 23b8 2c1d  Q.i..KG..e..#.,.
00000060: 7506 97a5 a3ae e0b2 74d4 0f              u.......t..

Hãy thử trực tuyến!

JavaScript (ES6), 130 124 byte

Hoặc 128 121 byte với một dòng mới hàng đầu.

f=(y=14,x=8)=>x?f(y,x-1)+' '+'BCDEFGA'[(y*3+x)%7]+'# b'[(x*5%7+y)/7|0]:(y?f(y-1)+`
`:'')+`${y<7?7-y+'#':y>7?y-7+'b':'0 '} -`

O.innerText = f()

<pre id=O style="font-size:11px"></pre>

C,  212   189   186  185 byte

Cảm ơn @Jonathan Frech vì đã tiết kiệm một byte!

#define N n>0?35:98:32);
f(i,n){for(n=8;--n+8;puts(""))for(i=-1,printf("%d%c -",abs(n),n?N++i<8;)printf(" %c%c",(n*4+65+i)%7+65,"\377\277\273\233\231\211\10\0@Ddfv\367\377"[n+7]&1<<i?N}

Hãy thử trực tuyến!

Chưa được kiểm soát:

#define N n>0 ? 35 : 98 : 32);
f(i, n)
{
    for (n=8; --n+8; puts(""))
        for (i=-1, printf("%d%c -", abs(n), n?N ++i<8;)
            printf(" %c%c",
                (n*4+65+i)%7 + 65,
                "\377\277\273\233\231\211\10\0@Ddfv\367\377"[n+7] & 1<<i ? N
}

Thạch ,  57 56 55  54 byte

-1 byte nhờ EriktheOutgolfer (sử dụng 7ŒRđể thay thế -7r7)

_Ṃị“ b#”
=”B+\Çż
×3⁵+€ịØAḣ7¤ḊḊÇ€Z
7ŒRµṠÑżAW€żÇj€”-UK€Y

Một chương trình đầy đủ in đầu ra mong muốn (sử dụng #, b).

Hãy thử trực tuyến!

Làm sao?

_Ṃị“ b#” - Link 1, getSharpsFlatsOrSpaces: list of integers
 Ṃ       - minimum (of the input list)
_        - subtract (from the input list) -- for our purposes this resets whatever our
         -       1st value is to 0, since our inputs are always monotonically increasing
   “ b#” - literal list of characters = [' ', 'b', '#']
  ị      - index into (1-based and modular)

=”B+\Çż - Link 2, addSharpsFlatsOrSpaces: list of characters  e.g."CFBEADGCFBEADGC"
 ”B     - literal character 'B'
=       - equals? (vectorises)                      [0,0,1,0,0,0,0,0,0,1,0,0,0,0,0]
    \   - cumulative reduce with:
   +    -   addition                                [0,0,1,1,1,1,1,1,1,2,2,2,2,2,2]
     Ç  - call the last link (1) as a monad                       "##       bbbbbb"
      ż - zip (with input) ["#C","#F"," B"," E",...," F","bB","bE","bA","bD","bG","bC"]

×3⁵+€ịØAḣ7¤ḊḊÇ€Z - link 3, getNoteLetters: list of integers          e.g. [-7,-6,...,6,7]
×3               - multiply by three       [-21,-18,-15,-12,-9,-6,-3,0,3,6,9,12,15,18,21]
  ⁵              - literal ten                                                         10
   +€            - add for €ach (in [1,10])   [[-20,...,22],[-19,...,23],...,[-11,...31]]
          ¤      - nilad followed by link(s) as a nilad:
      ØA         -   yield uppercase alphabet                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        ḣ7       -   head to index seven                                        "ABCDEFG"
     ị           - index into ["ADGCFBEADGCFBEA","BEADGCFBEADGCFB","CFBEADGCFBEADGC",...]
           Ḋ     - dequeue    ["BEADGCFBEADGCFB","CFBEADGCFBEADGC","DGCFBEADGCFBEAD",...]
            Ḋ    - dequeue    ["CFBEADGCFBEADGC","DGCFBEADGCFBEAD","EADGCFBEADGCFBE",...]
             Ç€  - call the last link(2) as a monad for €ach
                 -    [[["#C","#F"," B"," E",...," F","bB","bE","bA","bD","bG","bC"],...]
               Z - transpose           [["#C","#D",...,"#C"],["#F",..." B",...,"#F"],...]

7ŒRµṠÑżAW€żÇj€”-UK€Y - Main link: no arguments
7ŒR                  - absolute range of seven     [-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7]
   µ                 - start a new monadic chain (call that r)
    Ṡ                - sign (of r)                 [-1,-1,-1,-1,-1,-1,-1,0,1,1,1,1,1,1,1]
     Ñ               - call the next link (1) as a monad                "####### bbbbbbb"
       A             - absolute value (of r)              [7,6,5,4,3,2,1,0,1,2,3,4,5,6,7]
      ż              - zip                      [[7,'#'],[6,'#'],...,[0,' '],...,[7,'b']]
        W€           - wrap €ach        [[[7,'#']],[[6,'#']],...,[[0,' ']],...,[[7,'b']]]
           Ç         - call the last link (3) as a monad (with r)      see link 3 example
          ż          - zip                     [[[['#',7]],["#C","#D",...,"#C"]],
                                                [[['#',6]],["#F",...," B",..."#F"]], ...]
              ”-     - literal character '-'
            j€       - join for €ach            [[['#',7],'-',"#C","#D",..."#C"],
                                                 [['#',6],'-',"#F",...," B",..."#F"],...]
                U    - upend (reverse each)     [[[7,'#'],'-',"C#","D#",..."C#"],
                                                 [[6,'#'],'-',"F#",...,"B ",..."F#"],...]
                 K€  - join €ach with spaces            [[7+"# - C# D# ... C#"],
                                                         [6+"# - F# ... B  ... F#"], ...]
                   Y - join with newlines
                     - implicit print to STDOUT

CJam , 109 106 94 byte

{_0={_z/}|" b#"=a}:A;15,{X7-_zs\A+" - "+o7,0+{YX+7%65+c"2461357"Y=aiX\-_7,#){;0}&AS++o}fYNo}fX

Dùng thử trực tuyến

Java 8, 255 byte

Đếm và ♭ là 1 byte mỗi.

v->{String r="",t="GABCDEF";for(int i=-8;++i<8;r+="\n"){r+=(i<0?-i+"♯":i>0?i+"♭":"0 ")+" - ";for(String c:((t=t.substring(3)+t.substring(0,3))+t.charAt(0)).split(""))r+=c+("BEADGCF".substring(i<0?7+i:i).contains(c)?i<0?"♯":" ":i>0?"♭":" ")+" ";}return r;}

Giải trình:

Hãy thử trực tuyến.

v->{                   // Method with empty unused parameter and String return-type
  String r="",         //  Result-String, starting empty
         t="GABCDEF";  //  Temp-String `t`, starting at "GABCDEF"
  for(int i=-8;++i<8;  //  Loop from -7 to 7 (inclusive); range (-8;8) == [-7;7]
      r+="\n"){        //    After every iteration: append the result with a new-line
    r+=                //   Append the result-String with:
       (i<0?           //    If `i` is negative:
         -i+"♯"        //     Append the absolute value of `i` + a literal "♯"
        :i>0?          //    Else-if `i` is positive:
         i+"♭"         //     Append `i` + a literal "♭"
        :              //    Else (`i` is 0):
         "0 ")         //     Append a literal "0" + space
     +" - ";           //   And then append a literal " - "
  for(String c:((t=t.substring(3)+t.substring(0,3))
                       //  Split String `t` in the middle,
                       //  and swap the two parts (i.e. "GABCDEF" becomes "CDEFGAB")
                +t.charAt(0))
                       //  Then append the first character
                .split(""))
                       //  And loop over each character:
     r+=c+             //   Append the result-String with this character, plus:
          ("BEADGCF".substring(i<0?
                       //    If `i` is negative
            7+i        //     Take the last `-i` characters of "BEAFGCF"
           :           //    Else (`i` is 0 or positive)
            i)         //     Take the last `7-i` characters of "BEAFGCF"
          .contains(c)?//    And if these last characters contain the current character:
            i<0?       //     And `i` is negative:
             "♯"       //      Append a literal "♯"
            :          //     Else (`i` is 0 or positive)
             " "       //      Append a space
          :i>0?        //    Else-if `i` is positive
            "♭"        //     Append a literal "♭"
          :            //    Else:
           " ")        //     Append a space
      +" ";}           //   And then append a space
  return r;}           //  Return the result-String