Eingang

Das Symbol eines Triadenakkords (siehe http://en.wikipedia.org/wiki/Chord_(music)#Triads ).

Ausgabe

Die Noten, die den gegebenen Akkord bilden.

Beispiele

Eingabe: AM Ausgabe:A C# E

Eingabe: C#m Ausgabe:C# E G#

Eingabe: Db+ Ausgabe:C# F A

Eingabe: C0 Ausgabe:C D# F#

Boni

-50, wenn Sie auch mit Septakkorden umgehen können

-150 für das tatsächliche Spielen des Akkordklangs

-150 für die Verwendung druckbarer Zeichen, um das Spielen des Akkords auf einem Klavier zu zeigen; Beispiel für AM:

┌─┬─┬┬─┬─┬─┬─┬┬─┲┱─┬─┬─┲━┱┬─┲━┱─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ┃┃ │ │ ┃ ┃│ ┃ ┃ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ┃┃ │ │ ┃ ┃│ ┃ ┃ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ┃┃ │ │ ┃ ┃│ ┃ ┃ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┲┛┗┱┘ │ ┗┯┛└┲┛ ┃ └┬┘└┬┘└┬┘ │
│  │  │  │  │  ┃  ┃  │  │  ┃  ┃  │  │  │  │
└──┴──┴──┴──┴──┺━━┹──┴──┴──┺━━┹──┴──┴──┴──┘

-100 für die Verwendung druckbarer Zeichen, um das Spielen des Akkords auf einer Gitarre zu zeigen; Beispiel für AM:

x   o   o   o   o   o
┌───┬───┬───┬───┬───┐
│   │   │   │   │   │
├───┼───┼───┼───┼───┤
│   │   │   │   │   │
├───┼───┼───┼───┼───┤
│   │   █   █   █   │
├───┼───┼───┼───┼───┤
│   │   │   │   │   │

(siehe https://en.wikipedia.org/wiki/Box-drawing_character )

Regeln

• Das Ergebnis muss ein Befehlszeilenprogramm oder ein Skript sein.

• Die Ein- und Ausgabe kann in beliebiger Form erfolgen, sofern sie einem Musiknotationsstandard entspricht.

• Eine Gitarren- oder Klavierdarstellung gilt nur dann als gültig, wenn sie die drei (Triade) oder vier (Siebte) erforderlichen Noten enthält und sonst nichts. Dieselbe Note kann mehrmals im Akkord enthalten sein.

• Externe Bibliotheken sind nicht zulässig, mit Ausnahme der Klangerzeugung (in diesem Fall werden die Direktiven #include, import... nicht zur Zeichenanzahl hinzugefügt).

• Dies ist Codegolf, der kürzeste Code gewinnt!

Ein bisschen Musiktheorie ...

In der modernen westlichen Klangmusik besteht jede Oktave aus zwölf aufeinanderfolgenden Noten, die häufig notiert werden:

A A# B C C# D D# E F F# G G#

Oder:

La La# Si Do Do# Re Re# Mi Fa Fa# Sol Sol#

In diesem System werden zwei aufeinanderfolgende Noten (z. B. Aund A#, oder Eund F) durch einen Halbton getrennt. Auch die Noten sind eine Art "Schleife": Was unmittelbar folgt, G#ist A.

Ein Akkord besteht aus ein paar (2, 3, 4, manchmal mehr) Noten, die "zusammen gut klingen". Zum Beispiel enthalten triadische Akkorde drei verschiedene Noten und siebente Akkorde vier verschiedene Noten.

Definieren wir die vier triadischen Akkorde als:

• Dur-Dreiklang : Enthält den Grundton des Akkords (in dieser Frage die als Eingabe angegebene Note), das große Drittel für den Grundton (4 Halbtöne höher als der Grundton) und das perfekte Fünftel für den Grundton (7 Halbtöne höher als der Grundton) ); Dies kann durch 0-4-7 symbolisiert werden

• Kleine Triade , symbolisiert 0-3-7

• Erweiterte Triade , symbolisiert 0-4-8

• Verminderte Triade , symbolisiert 0-3-6

So zum Beispiel, wenn Sie einen machen wollen C - Dur - Dreiklang , bemerkt C, CM, Cmaj, müssen Sie drei fest:

• 0: die Wurzel , in diesem Fall aC
• 4: das kleine Drittel , 4 Halbtöne höher als die Wurzel; das ist einE
• 7: das perfekte Fünftel , 7 Halbtöne höher als die Wurzel: aG

Dies ist , was die 0-4-7, 0-3-7, 0-4-8und 0-3-6Notationen über die mittleren verwendet! Verwenden Sie für die siebten Akkorde das folgende Muster:

Das war `s für heute! Überraschen Sie mich jetzt mit erstaunlichem Code ... Wenn Sie Fragen haben, fügen Sie unten einige Kommentare hinzu.

BBC BASIC

Emulator bei bbcbasic.co.uk

Rev 1, 340 - 150 Tastatur - 150 spielen = 40

Hier ist die neueste Version, in der ich es geschafft habe, die folgenden Verbesserungen einzubeziehen, während ich mich nur um ein paar Zeichen verlängere.

Die Eingabe kann bequem auf dem Bildschirm bearbeitet werden, bevor die Eingabetaste gedrückt wurde (ich habe zuvor GET $ verwendet, um einzelne Tastendrücke zu erhalten, da Sie in BBC Basic nicht auf ein einzelnes Zeichen aus einer Zeichenfolge zugreifen können, als ob die Zeichenfolge ein Array wäre sperrige MID $ -Funktion zum Extrahieren einer Zeichenfolge aus einer Zeichenfolge.

Beide Tastaturseiten werden angezeigt sowie die vollständige Linie zwischen E und F.

Um die oben hinzugefügten Zeichen zu kompensieren, habe ich das Programm neu angeordnet, um unnötige Druckanweisungen zu eliminieren, und einige Leerzeichen gelöscht, die auf den ersten Blick so aussahen, als könnten sie nicht gelöscht werden. IN BBC Basic sind alle eingebauten Funktionen reservierte Wörter, und Sie können einen Variablennamen ohne Leerzeichen davor setzen. Variablennamen dürfen nicht mit einem reservierten Wort beginnen. Um das Lesen des Programms zu vereinfachen, habe ich alle Variablen in Kleinbuchstaben geändert.

Obwohl die Präsentation viel besser aussieht, ist das folgende Programm tatsächlich schon voll besetzt. (Siehe Korrektur unten.) Im Allgemeinen sind Zeilenumbrüche und Doppelpunkte austauschbar, außer wenn eine IF-Anweisung verwendet wird. In diesem Fall werden alle Anweisungen in derselben Zeile (durch Doppelpunkte getrennt) bedingt ausgeführt. Anweisungen nach dem Zeilenumbruch werden nicht von der IF gesteuert und immer ausgeführt.

Programm Rev. 1 340 Zeichen

  a$="C#D#EF#G#A#B0Mm+"
  INPUTx$
  r=INSTR(a$,LEFT$(x$,1))-1
  c=INSTR(a$,MID$(x$,2,1))
  IFc=2c=INSTR(a$,MID$(x$,3)):r=r+1
  t=(r+4-c MOD2)MOD12
  f=(r+c DIV2)MOD12
  v=1
  FORn=-1TO11
  c=1-(n<0ORn=4ORn=11)*5
  b$=MID$(a$,n+1,1)
  IFb$="#"c=11:b$=MID$(a$,n,1)+b$
  c$=MID$("   _______--|__",c,5)
  IFr=n ORt=n ORf=n c$=c$+b$:SOUNDv,-15,100+n*4,99:v=v+1
  PRINTc$
  NEXT

KORREKTUR: Mit BBC BASIC für Windows von RT Russell können Sie einige Zeilenumbrüche und Doppelpunkte entfernen und die Gesamtsumme auf 327 reduzieren (siehe unten). Außerdem werden die Schlüsselwörter vor dem Speichern in einzelne Zeichen unterteilt und auf 279 reduziert.

  a$="C#D#EF#G#A#B0Mm+"INPUTx$
  r=INSTR(a$,LEFT$(x$,1))-1c=INSTR(a$,MID$(x$,2,1))IFc=2c=INSTR(a$,MID$(x$,3))r=r+1
  t=(r+4-c MOD2)MOD12f=(r+c DIV2)MOD12v=1FORn=-1TO11c=1-(n<0ORn=4ORn=11)*5b$=MID$(a$,n+1,1)IFb$="#"c=11b$=MID$(a$,n,1)+b$
  c$=MID$("   _______--|__",c,5)IFr=n ORt=n ORf=n c$=c$+b$SOUNDv,-15,100+n*4,99v=v+1
  PRINTc$
  NEXT

Ausgangsdrehzahl 1

Rev 0, 337 - 150 Tastatur - 150 spielen = 37

A$="C#D#EF#G#A#B0Mm+":X$=GET$:R=INSTR(A$,X$)-1:X$=GET$:IF X$="#"R=R+1:X$=GET$
C=INSTR(A$,X$):T=(R+4-C MOD2)MOD12:F=(R+C DIV2)MOD12:V=1:PRINT"______"
FORN=0 TO 11
C=1-(N=4)*12:B$=MID$(A$,N+1,1): IF B$="#" C=7: B$=MID$(A$,N,1)+B$
PRINT MID$("    __---|________",C,6);:IF(R-N)*(T-N)*(F-N)=0 PRINT B$;:SOUND V,-15,100+N*4,99:V=V+1
PRINT
NEXT

Dies ist ein ähnliches Konzept wie bei meiner Arduino-Antwort, aber ich wusste immer, dass ich diese Byteanzahl mit BBC Basic übertreffen kann. Erkennt nur scharfe Stellen, aber hält B # für ungültig, müssen Sie C setzen. Dies könnte behoben werden, wenn es wirklich als wichtig erachtet wurde.

Ich gab die Idee der Gitarre auf und konzentrierte mich auf die Verbesserung des Keyboards. Es läuft jetzt von C nach B, und ich habe auf der linken Seite der Tastatur und der Linie zwischen E und F hinzugefügt. Das kostet 28 Zeichen. Die rechte Seite würde nicht viel mehr sein.

Hier sind einige Beispiele, ein A # -reduzierter Akkord (der in dieser Umkehrung einen ziemlich ausgeflippten Klang hat) und ein B-Dur-Akkord. Beachten Sie, dass die Eingabe nicht auf dem Bildschirm wiedergegeben wird. Drehen Sie den Bildschirm gemäß der Arduino-Antwort gegen den Uhrzeigersinn, um ihn anzuzeigen.

Ungolfed-Version

A$="C#D#EF#G#A#B0Mm+"                              :REM Note names and chord type names fit very conveniently in the same string.
X$=GET$                                            :REM Get a character 
R=INSTR(A$,X$)-1                                   :REM Root note = position of that char in A$. INSTR starts counting at 1, but we want 0, so subtract.
X$=GET$                                            :REM If the root note is natural, the next character will be the chord type. But...
IF X$="#"R=R+1:X$=GET$                             :REM If this char is # we need to increment the root, and get another char for chord type. 
C=INSTR(A$,X$)                                     :REM C encodes for chord type
T=(R+4-C MOD2)MOD12                                :REM even C means major third, odd C means minor third
F=(R+C DIV2)MOD12                                  :REM "Mm" gives C=14,15 meaning C DIV2=7 (perfect fifth.) C=13,16 give diminished and augmented: 6,8.
V=1                                                :REM V is the sound channel number ("voice")                             
PRINT"______"                                      :REM left side of keyboard for cosmetic reasons
FORN=0 TO 11                                       :REM at the start of each iteration initialise C to 1, to point to the 4 spaces/2 underscores in the string below for drawing white notes. 
  C=1-(N=4)*12                                     :REM if the note is E, add 12 so it points to the 6 underscores to draw the line between E and F. 
  B$=MID$(A$,N+1,1)                                :REM load B$ with the name of the current note.
  IF B$="#" C=7: B$=MID$(A$,N,1)+B$                :REM if the character encountered is a sharp, update C to point the characters for drawing a sharp. Find the previous character in A$ and join it to the beginning of B$ to complete the note name.
  PRINT MID$("    __---|________",C,6);            :REM print the key (6 characters.)
  IF(R-N)*(T-N)*(F-N)=0 PRINT B$;:SOUND V,-15,100+N*4,99:V=V+1  :REM if N is equal to R,T or F, print the note name beside the key, play the note and increment the channel number for the next note.  
  PRINT                                            :REM print a carriage return. It may be possible to golf this line out.
NEXT

Wie Sie sehen, habe ich nicht versucht, Golf zu spielen. Ich bin ein Musikfreak und mein Lieblingsfreak ist es, wenn Leute Dinge mit der falschen Enharmonik schreiben (zB sagen, dass ein C-reduzierter Akkord CD # F # anstelle von C Eb Gb ist), also habe ich dieses Programm geschrieben, das die Enharmonik bekommt Recht. Dies geschieht, indem jede Note als die Anzahl der perfekten Quinten über F dargestellt wird.

Wenn Sie die Enharmonik unterscheiden möchten, kann jedes musikalische Intervall in einem Computerprogramm in Form einer Anzahl von perfekten Quinten und einer Anzahl von Oktaven dargestellt werden. Eine erweiterte Quinte besteht beispielsweise aus 6 perfekten Quinten und -3 Oktaven, und eine verminderte Quinte besteht aus -6 perfekten Quinten und 4 Oktaven.

Haskell, 441 Zeichen

import Data.List

notes = "FCGDAEB"

fromNum x = [notes !! (mod x 7)] ++ if x < 0 then replicate (-(div x 7)) 'b' else replicate (div x 7) '#'

toNum (x:xs) = y + 7 * if isPrefixOf "b" xs then -length xs else length xs
    where Just y = elemIndex x notes

chord xs = unwords . map (fromNum . \x -> toNum (init xs) + x) $ case last xs of 'A' -> [0,4,8]; 'M' -> [0,4,1]; 'm' -> [0,-3,1]; 'd' -> [0,-3,-6]

main = getLine >>= putStrLn . chord

Einige Beispielaufrufe:

jaspers:junk tswett$ ./chord
AM
A C# E
jaspers:junk tswett$ ./chord
C#m
C# E G#
jaspers:junk tswett$ ./chord
DbA
Db F A
jaspers:junk tswett$ ./chord
Cd
C Eb Gb
jaspers:junk tswett$ ./chord
A#M
A# C## E#
jaspers:junk tswett$ ./chord
Dbm
Db Fb Ab

Arduino

Die Ein- / Ausgabe wird über einen COM-Port an den Arduino gesendet bzw. von diesem empfangen. Ein Benutzer kann damit über ein Terminal oder den seriellen Monitor in der Arduino IDE interagieren. Wie Sie vielleicht aus meiner Wahl der Plattform erraten haben, plane ich, das eigentliche Spielen des Akkords aufzunehmen (obwohl ich es noch nicht getan habe.)

Ich habe den Keyboard-Bonus erfolgreich in Angriff genommen und mit begrenztem Erfolg versucht, die Gitarre in Angriff zu nehmen.

Die Akkordbox kommt mit 130 Bytes an, was zu lang ist, um es wert zu sein. Deshalb habe ich einen anderen Weg versucht, einfach den Bundnummern-Tab-Stil auszudrucken. Derzeit sind dies 81 Bytes für einen Bonus von 81-100 = -19. Wenn dieser Ansatz als gültig erachtet wird, kann ich versuchen, ihn zu verbessern.

Die verwendeten Akkorde sind alle vom Typ D, wobei der Grundton auf der 2. Saite, der fünfte auf der 3. Saite und der dritte auf der 1. und 4. Saite liegt. Die 5. und 6. Saite werden nicht verwendet und ich markiere dies mit X rechts neben dem Akkordkasten (die linke wäre üblicher, aber die rechts markierten Beispiele sind zu finden.)

Da das Programm F als die tiefste Note ansieht (um die Kompatibilität mit der Tastatur zu gewährleisten und gleichzeitig zu hohe Bünde mit dieser Akkordform zu vermeiden), ist der höchste Akkord ein E (mit Grundton im 17. Bund). Siehe Beispielausgabe.

Die Tastatur ist beim Golfen erfolgreicher. Es läuft aus den oben beschriebenen Gründen eher von FE als von CB. Sie müssen den Bildschirm um 90% gegen den Uhrzeigersinn drehen, um die Konturen der schwarzen Noten und die Abgrenzung zwischen den weißen Noten mit deutlich zu erkennen ---. Die Linie zwischen B und C könnte um einige ____Bytes verlängert werden.

Ich werde als nächstes versuchen, die Noten zu spielen. Dies wird interessant sein, da, obwohl ich glaube, dass der Arduino Uno 3 interne Timer hat, mit dem eingebauten Tonbefehl immer nur eine Note gespielt werden kann. Es gibt eine externe Bibliotheksfunktion, die alle Hardware-Timer verwendet (die die Seriennummer durcheinander bringen, aber in diesem Stadium sowieso nicht benötigt werden). Alternativ kann ich versuchen, die Töne in Softare zu erzeugen.

Wenn ich damit erfolgreich bin, werde ich Golf spielen, aber ich denke nicht, dass es der Gesamtsieger sein wird.

Ungolfed Code

String p="F#G#A#BC#D#E -Mm+",y,d[]=
{"    ","---|"},n="\n";

void setup() {
  Serial.begin(9600);
  Serial.setTimeout(99999);
}

void loop(){
  char x[9]; int r,t,f,i,c=1;
  Serial.readBytesUntil(13,x,9);
  Serial.println(x);  
  r=p.indexOf(x[0]);
  if (x[1]==35|x[1]==98){c=2;r+=x[1]==35?1:-1;}
  f=p.indexOf(x[c])/2;
  t=4-p.indexOf(x[c])%2;

  //chord box
  y=n;for(i=24;i--;)y+=d[1]+(i%4?"":" \n");
  y[89]=y[107]='X'; y[t*4-10]=y[t*4+52]=y[f*4+14]=y[28]='O';
  Serial.print("\t "+String(r+6)+y);

  f+=r;t+=r;

  //tab style
  Serial.println(String(t+1)+n+String(r+6)+n
  +String(f-2)+n+String(t+3)+"\nX\nX\n");

  f%=12;t%=12;

  //piano
  for(i=0;i<12;i++){
    c=0;
    y=String(p[i]);
    if(y=="#") {c=1;y=p[i-1]+y;}      
    Serial.println(d[c]+"__"+((r-i&&t-i&&f-i)?"":y));
  }  
}

Beispielausgabe Je geringer der Abstand zwischen den Textzeilen ist, desto besser sieht dies aus. Daher sieht es toll aus, wenn ich den Beitrag gerade bearbeite, aber schrecklich in der grauen Box nach dem Posten. Stattdessen habe ich einen Screenshot des seriellen Arduino-Monitors gepostet, der einen mittleren Zeilenabstand aufweist (und daher die Anzeigequalität gewährleistet).

Python3 - 315 Zeichen

Zum ersten Mal in Codegolf! Unterstützt derzeit nur Moll-, Dur-, verminderte und erweiterte Akkorde.

z=["C","C#","D","D#","E","F","F#","G","G#","A","A#","B"];y=[1,2,4,5,6]
def q(a):print(z[a%12])
a=input();k=(ord(a[0])+3)%7;j=k;m=4;s=0;f=7;
for i in y:
    if(k>=i):j+=1
if('#'in a):j+=1
if('b'in a):j-=1
if('m'in a or'0'in a):m=3
if('+'in a or"aug"in a):f=8
if('0'in a or"dim"in a):f=6;m=3
if('ma'in a):m=4
q(j);q(j+m);q(j+f);

Python 506 (Unicode als 1 Zeichen) -150 (Sound) -150 (Tastatur) = 206

Zum Abspielen von Ton wird verwendet pygame.midi. Beachten Sie, dass die pygame.midi.get_default_output_id()Methode nicht sehr gut funktioniert. So können Sie versuchen , die Linie zu ändern o=Output(get_default_output_id())zu o=Output(1), o=Output(2)usw. Normalerweise ist der richtige Wert zwischen 0 und 5.

c=input()
s='C D EF G A B'.index(c[0])+{'#':1,'b':-1,'':0}[c[1:-1]]
m='0mM+'.index(c[-1])
t=s+3+m//2
R=[list(x)for x in['┌─'+'─┬─'*13+'─┐']+['│'+'  │'*14]*5+['└─'+'─┴─'*13+'─┘']]
i=3
for d in[3,6,3,3,6]*2:q=slice(i-1,i+2);R[0][q]='┬─┬';R[1][q]=R[2][q]=R[3][q]='│ │';R[4][q]='└┬┘';i+=d
X=[2]+[1,2,1,2,3,1,2,1,2,1,2,3]*2
from pygame.midi import*
init()
o=Output(get_default_output_id())
for s in[s,t,t+3+m%2]:R[[5,3][s%12 in[1,3,6,8,10]]][sum(X[:s+1])]='o';o.note_on(s+60,127,1)
for r in R:print(''.join(r))

Ergebnisse

goooolf> python chords2.py
CM
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│ o│  │ o│  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
Cm
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││o│ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│ o│  │  │  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
Dm
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │ o│  │ o│  │ o│  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
D+
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │o││ ││o│ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │ o│  │  │  │  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
G+
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││o│ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │  │  │ o│  │ o│  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
Am
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │  │  │  │ o│  │ o│  │ o│  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
C#0
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │o││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │ o│  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
EbM
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││o│ │ │ ││ ││o│ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │  │  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘

J - 82 Zeichen

In sich geschlossen, liest von der Konsoleneingabe. Wenn Sie stdin benötigen, ändern Sie das Finale 1in a 3. Keine Boni beanspruchen und nur die Triaden abdecken.

+/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1

Anstelle einer scharfen Notiz C#müssen Sie zB den entsprechenden flachen Namen verwenden Db. (Wenn Sie dies korrigieren, wird der Code mehr als ein bisschen aufgeblasen.) Die vier Akkordtypen dienen 0zum Verringern, mfür Moll, Mfür Dur und +für Augmented.

Die Logik ist wie folgt: Wir verwenden das letzte Zeichen, um der Basis 0-3-6 einen Versatz hinzuzufügen, der die Art des dritten und fünften Zeichens auswählt. In der Zwischenzeit verwenden wir die Notiz, um herauszufinden, von wo in der Skala die Noten gezogen werden sollen. Die ;:beide machen die Note kompatibel mit der Indizierung in die Wagschale zu Beginn und später (nach &.) verwandelt sie die gezogenen Noten in einen Raum getrennt String.

Anwendungsbeispiel:

   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
AM
A Ch E
   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
Ab0
Ab B D
   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
B+
B Eb G
   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
Em
E G B

Javascript, 224 Zeichen

n=prompt();a="A0A#0B0C0C#0D0D#0E0F0F#0G0G#".split(0);x=1;r=a.indexOf(n[0]);n[1]=="#"&&(r++,x++);n[1]=="b"&&(r--,x++);s=r+4;l=r+7;(n[x]=="m"||n[x]==0)&&s++;s%=12;n[x]=="+"&&l++;n[x]==0&&l--;l%=12;alert(a[r]+" "+a[s]+" "+a[l])

Dies ist mein erster Code Golf. Ich denke, es kann kürzer sein, aber ich kann keine Bytes zum Speichern finden.

Unterstützt die wichtigsten, mfür kleinere, 0für verminderte, +für Augmented oder 37 mehr Bytes für dim, aug.

Python ( 143 134 Zeichen)

n,a='A A# B C C# D D# E F F# G G#'.split(),input();m,i=ord(a[-1])-42,n.index(a[:-1])
print(n[i],n[(i+4-m//2)%12],n[(i-4+(-m//2))%12]) 

Meine erste Golfherausforderung :), weiß nicht, ob noch mehr Bytes entfernt werden können.
Die hier verwendete Notation ist * aug / + maj /, min / - dim.
Ich verdiene einen Bonuspunkt für die Konstante 42 im Code: P

Python 3: 257 - 150 = 107

Nur 25 Zeichen zu lang, um die J-Lösung zu übertreffen! Naja. Hier gibt es einige nette Ideen, denke ich.

I='AaBCcDdEFfGg'*2
Q='0123456789.,'*2
K="""-1#_2
-,#_0
-9#_.
____8
-6#_7
-4#_5
____3"""
r,*R,q=input()
r=I.find(r)+bool(R)
p=str.replace
for x in[0]+[8,4,7,3,6]['+Mm0'.find(q):][:2]:K=p(K,Q[x+r],I[x+r].upper())
for x in Q:K=p(K,x,' ')
print(p(K,' #','  '))

Die Eingabe entspricht den Beispielen, Sie müssen jedoch scharfe Namen anstelle von flachen Namen verwenden. (zB Gb muss F # sein)

Ausgang ist eine einzelne Oktave eines Klaviers, von oben und links gesehen, mit überlagerten Notennamen. Sollte nur ein winziger Teil der Vorstellungskraft sein.

$ echo C#m | python3 chords.py
-  _ 
-G#_ 
-  _ 
____ 
-  _E
-C#_ 
____ 

Scala 537 Zeichen - 50

import java.util.Scanner
object C extends App{
val c=Map("M"->145,"m"->137,"+"->273,"0"->73,"7"->1169,"M7"->2193,"m7"->1161,"Mm7"->2185,"+7"->1297,"+M7"->2321,"07"->585,"7b5"->1097)
val n=List("A","A#","B","C","C#","D","D#","E","F","F#","G","G#")
val o=List("","Bb","Cb","B#","Db","","Eb","Fb","E#","Gb","","Ab")
val s=new Scanner(System.in).nextLine
val v=s indexWhere{c=>c!='#'&&c!='b'&&(c<'A'||c>'G')}
val (u,m)=s splitAt v
val x=n.indexOf(u)max o.indexOf(u)
val k=c(m)
for(i<-0 to 11)if((k&(1<<i))!=0)print(n((i+x)%12)+" ")
println}

Haskell, 273 Zeichen

n(s,a)="CCDDEFFGGAABB"!!(s+1-a):["b#"!!a|" b b  b b b "!!s/=' ']
t p=[(s,a)|s<-[11,10..0],a<-[0,1],n(s,a)==p]!!0
m(s,d)=n(mod s 12,d-3)
c q=[n(a,x),m(a+d,d),m(a+d+e,e)]where
 (a,x)=t$init q;f=lookup(last q).zip"0mM+";Just d=f[3,3,4,4];Just e=f[3,4,3,4]
main=print.c=<<getLine

Ergebnisse

C0 ->["C","Eb","Gb"]   Cm ->["C","Eb","G"]    CM ->["C","E","G"]     C+ ->["C","E","G#"]    
C#0->["C#","F","G"]    C#m->["C#","F","G#"]   C#M->["C#","F","Ab"]   C#+->["C#","F","A"]    
D0 ->["D","F","Ab"]    Dm ->["D","F","A"]     DM ->["D","F#","A"]    D+ ->["D","F#","A#"]   
D#0->["D#","Gb","A"]   D#m->["D#","Gb","A#"]  D#M->["D#","G","Bb"]   D#+->["D#","G","B"]    
E0 ->["E","G","Bb"]    Em ->["E","G","B"]     EM ->["E","G#","B"]    E+ ->["E","G#","C"]    
F0 ->["F","Ab","B"]    Fm ->["F","Ab","C"]    FM ->["F","A","C"]     F+ ->["F","A","C#"]    
F#0->["F#","A","C"]    F#m->["F#","A","C#"]   F#M->["F#","A#","Db"]  F#+->["F#","A#","D"]   
G0 ->["G","Bb","Db"]   Gm ->["G","Bb","D"]    GM ->["G","B","D"]     G+ ->["G","B","D#"]    
G#0->["G#","B","D"]    G#m->["G#","B","D#"]   G#M->["G#","C","Eb"]   G#+->["G#","C","E"]    
A0 ->["A","C","Eb"]    Am ->["A","C","E"]     AM ->["A","C#","F"]    A+ ->["A","C#","F"]    
A#0->["A#","Db","F"]   A#m->["A#","Db","F"]   A#M->["A#","D","F"]    A#+->["A#","D","F#"]   
B0 ->["B","D","F"]     Bm ->["B","D","F#"]    BM ->["B","D#","Gb"]   B+ ->["B","D#","G"]