Ach nein! Ich habe bald einen Theorie-Test und kann mich noch nicht an die Waage erinnern! Hilf mir, mich an meine wichtigsten Skalen zu erinnern, indem du Folgendes druckst:

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♭

Das ist Code-Golf, also gewinnt der kürzeste Code. Sie können #und bSymbole anstelle von ♯und ♭verwenden.

Bearbeiten: Wenn Sie ♯und ♭Zeichen verwenden, müssen Sie diese nur als ein einzelnes Byte zählen. Dies ist kein unfairer Nachteil.

Holzkohle , 66 65 Bytes (bei Verwendung von # und b)

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

↑⮌…0¦8‖Ｏ

Drucken Sie die Zeichen 0in 7umgekehrter Reihenfolge und spiegeln Sie sie dann mit Überlappung. Listen werden normalerweise nach unten gedruckt, sodass beim Drucken nach oben tatsächlich nach rechts gedruckt wird. Wir werden alles am Ende drehen.

⸿×⁷♭Ｍ→×⁷♯

Beginnen Sie eine neue Linie und drucken Sie 7 flache und 7 scharfe Stellen mit einer Lücke dazwischen.

→⸿⸿¹⁵

Lassen Sie eine leere Zeile und drucken Sie 15 -s.

ＦＥ⁸﹪⊕⊗ι⁷«

Nehmen Sie die Zahlen 0 bis 7, verdoppeln Sie sie, addieren Sie 1 und reduzieren Sie dann Modulo 7. Führen Sie eine Schleife über das Ergebnis.

⸿⸿✂׳FCGDAEBι⁺¹⁵ι

Lassen Sie eine leere Zeile und nehmen Sie einen 15-stelligen Teil der dreifachen Notenfolge, beginnend mit dem aktuellen Wert.

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

Nehmen Sie in der nächsten Zeile eine 15-stellige Scheibe mit Ebenen, Leerzeichen und Spitzen, die jeweils siebenmal wiederholt werden.

»⟲

Drehen Sie nach dem Drucken aller Notizen alles an seinen Platz.

Ruby , 113 Bytes ( 131 126 108 105 mit # und b)

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

Probieren Sie es online!

Ruby , 116 Bytes (108 mit # und b)

Probieren Sie es online!

Ruby , 126 Bytes (118 mit # und b)

Probieren Sie es online!

Ruby , 131 Bytes mit # und b

Probieren Sie es online!

Python 3 , 135 Bytes

Zählen von ♯ und ♭ als jeweils 1 Byte

Dank an Zacharý für -6 Bytes.

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:])])

Probieren Sie es online!

GNU sed , 148 144 + 1 = 145 Bytes

+1 Byte für -rFlag.

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 /

Probieren Sie es online!

Erläuterung

Fügen Sie zunächst eine Art Vorlage ein:

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

Beachten Sie das führende und nachfolgende Leerzeichen in der ersten Zeile.

Nehmen Sie in einer Schleife die erste Zahl aus der letzten Zeile und ersetzen Sie sie durch Teile der vorletzten Zeile wie folgt:

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

Wie Sie sehen, wird das ursprüngliche Leerzeichen (Capture 2) verwendet, um das Zeichen nach dem zu ersetzen B .

Wenn das 0erreicht ist, ersetzen Sie das ursprüngliche Leerzeichen durch b. Die Schleife wird fortgesetzt, aber anstatt #s durch Leerzeichen zu ersetzen , wird in jeder folgenden Zeile ein Leerzeichen durch a ersetzt b.

Führen Sie abschließend eine kleine Bereinigung durch: Entfernen Sie das führende Zeichen aus jeder Zeile und ersetzen Sie es 0bdurch 0.

Befunge, 134 132 130 Bytes

<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,+

Probieren Sie es online!

Erläuterung

• Wir beginnen mit einer äußeren Schleife, die von 7 bis -7 herunterzählt. Wir werden das die Reihe nennen .
• Für jede Zeile schreiben wir zuerst '0'+abs(row)die Skalennummer auf und berechnen dann (row>0)+(row!=0), ob sie in der Tabelle natürlich, scharf oder flach ist #b(dies wird am Anfang der dritten Codezeile angezeigt).
• Wir berechnen dann die Startnote der Skala, n , as 30 + row*4. Dies wird letztendlich Mod 7 sein, stellen Sie es sich also als die sich wiederholende Sequenz 2,5,1,4,0,3,6 (dh CFBEADG) vor.
• Unsere innere Schleife i zählt dann für die acht Noten in der Skala von 8 auf 1 herunter und erhöht n bei jeder Iteration um .
• Der Brief der Notiz ist einfach 'A' + n%7. Ob es scharf oder flach ist, wird durch Nachschlagen i%7in einer Tabelle festgestellt . Die Tabelle ist anfangs alle wahr, da die erste Skala alle scharfen Stellen ist.
• Nachdem jede Zeile ausgegeben wurde, aktualisieren wir die Tabelle, indem wir einen Wert umschalten. Bei der ersten Iteration wird der Wert bei Versatz 5 umgeschaltet, aber bei jeder Schleife wird der Versatz um angepasst (offset+3)%7.
• In der ersten Hälfte der Ausgabe setzen wir diese Tabellenwerte auf false , wenn die Zeile größer als Null ist. In der zweiten Hälfte der Ausgabe setzen wir sie auf true zurück , wenn die Zeile kleiner oder gleich Null ist.

Bubblegum , 107 Bytes

Bubblegum Schwelle

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..

Probieren Sie es online!

JavaScript (ES6), 130 bis 124 Byte

Oder 128 121 Bytes mit einer führenden Newline.

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 Bytes

Vielen Dank an Jonathan Frech für das Speichern eines Bytes!

#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}

Probieren Sie es online!

Abgerollt:

#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
}

Jelly ,  57 56 55  54 Bytes

-1 Byte dank EriktheOutgolfer ( 7ŒRzum Ersetzen verwenden -7r7)

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

Ein vollständiges Programm druckt die gewünschte Ausgabe (mit #, b).

Probieren Sie es online!

Wie?

_Ṃị“ 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 Bytes

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

Probieren Sie es online aus

Java 8, 255 Bytes

Zählen von ♯ und ♭ als jeweils 1 Byte.

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

Erläuterung:

Probieren Sie es online aus.

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