入力

トライアド和音の記号（http://en.wikipedia.org/wiki/Chord_(music)#Triadsを参照）。

出力

与えられたコードを構成する音。

例

入力：AM 出力：A C# E

入力：C#m 出力：C# E G#

入力：Db+ 出力：C# F A

入力：C0 出力：C D# F#

ボーナス

7番目の和音にも対処できる場合は-50

-150は実際に和音を鳴らします

-150ピアノで和音を演奏する方法を示すために印刷可能なキャラクターを使用する場合。例AM：

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

印刷可能な文字を使用してギターでコードを演奏する方法を示す場合は-100。例AM：

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

（https://en.wikipedia.org/wiki/Box-drawing_characterを参照）

ルール

• 結果は、コマンドラインプログラムまたはスクリプトでなければなりません。

• 入力と出力は、楽譜表記の標準に従っている限り、どのような形式でもかまいません。

• ギターまたはピアノの表現は、3つ（トライアド）または4つ（7つ）の必要なノートが含まれていて、それ以外の場合にのみ有効と見なされます。同じ音が和音に数回現れることがあります。

• サウンド生成を除き、外部ライブラリは許可されません（この場合#include、import...ディレクティブは文字カウントに追加されません）。

• これはコードゴルフで、最短のコードが勝ちます！

音楽理論の少し...

現代の西洋の調子の音楽では、各オクターブは12の連続した音符で構成されています。

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

または：

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

このシステムでは、2つの連続する音符（Aand A#、or E、andなどF）が1つの半音で区切られていると見なします。また、メモは一種の「ループ」G#ですA。すぐに続くのはです。

和音は、「一緒に聞こえる」いくつかの音（2、3、4、時にはそれ以上）で構成されます。たとえば、トライアドのコードには3つの異なる音が含まれ、7番目のコードには4つの異なる音が含まれます。

4つのトライアドコードを次のように定義しましょう。

• Major triad：コードのルート（この質問では、入力として与えられた音符）、ルートのメジャー3分の1（ルートより4半音高い）、およびルートの完全な5番目（ルートより7半音高い） ）; これは0-4-7として記号化できます

• 0-3-7で表されるマイナートライアド

• 拡張されたトライアド、0-4-8のシンボル

• 0-3-6を象徴する減少したトライアド

あなたが作りたいのであれば、たとえば、Cメジャートライアドを指摘し、C、CM、Cmaj、あなたは注意3が必要になります。

• 0：ルート、この場合はaC
• 4：マイナーサード、ルートより4半音高い。それはE
• 7：完全な5番目、ルートより7半音高い：aG

これは何である0-4-7、0-3-7、0-4-8および0-3-6平均の上に使用される表記！7番目のコードでは、次のパターンを使用します。

今日は以上です！さて、素晴らしいコードで私を驚かせてください...質問があれば、以下にコメントを追加してください。

BBC BASIC

bbcbasic.co.ukのエミュレーター

Rev 1、340-150キーボード-150プレイ= 40

これが最新バージョンです。このバージョンでは、次の機能強化を含めながら、さらに数文字だけ長くすることができました。

Returnキーを押す前に、画面で入力を快適に編集できます（BBC Basicでは、文字列が配列であるかのように文字列から1文字にアクセスできないため、GET $を使用して単一のキーを押していました。文字列内から1文字の文字列を抽出するかさばるMID $関数。

キーボードの両側と、EとFの間のフルラインが表示されました。

上記によって追加された文字を補正するために、プログラムを再配置して不要な印刷ステートメントを削除し、一見削除できないように見えた空白を削除しました。BBC Basicでは、すべての組み込み関数は予約語であり、間にスペースを入れずに変数名を直前に置くことができます。変数名は予約語で始めることはできません。プログラムを読みやすくするために、すべての変数を小文字に変更しました。

プレゼンテーションはかなり良く見えますが、次のプログラムは実際にはすでに完全にゴルフされています。（以下の修正を参照してください。）一般に、IFステートメントが使用されている場合を除き、改行とコロンは交換可能です。その場合、同じ行にあるすべてのステートメント（コロンで区切られた）は条件付きで実行されます。改行の後のステートメントは、IFによって制御されず、常に実行されます。

プログラムrev 1 340文字

  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

修正：RT RussellのWindows用BBC BASICを使用すると、いくつかの改行とコロンを削除して、合計を327に減らすことができます（以下を参照）。また、保存する前にキーワードを単一の文字にトークン化し、279まで下げます。

  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

出力回転数1

Rev 0、337-150キーボード-150プレイ= 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

これは、Arduinoの答えに似た概念ですが、BBCベーシックでそのバイトカウントを打ち負かすことができると常に知っていました。シャープのみを認識しますが、B＃は無効であると見なします。Cを配置する必要があります。これが本当に重要と見なされる場合は修正できます。

私はギターのアイデアを捨て、キーボードの改善に集中しました。現在はCからBに実行され、キーボードの左側とEとFの間の行に追加しました。これには28文字かかります。右側はそれ以上ではありません。

サンプル出力、A＃ディミニッシュコード（この反転ではかなり奇妙な音がします）およびBメジャーコードがあります。入力は画面にエコーされないことに注意してください。Arduinoの回答に従って、画面を反時計回りに回して表示します。

ゴルフされていないバージョン

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

あなたが言うことができるように、私はこれを全くゴルフしようとしませんでした。私は音楽マニアであり、私の不満は、人々が間違った調和を使用して物事を書くときです（たとえば、Cの和音はC Eb GbではなくCD＃F＃であると言う）。右。これは、各音符をFの上の完全な5分の1の数として表すことによって行われます。

価値のあることですが、エンハーモニクスを区別したい場合、コンピューターのプログラムでは、音楽の音程を完璧な5分の1とオクターブの数としてうまく表現できます。たとえば、拡張4分の1は6パーフェクト5分音符と-3オクターブであり、減少した5分の1は-6パーフェクト5分音符と4オクターブです。

Haskell、441文字

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

呼び出しの例：

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

入出力は、COMポートを介してArduinoとの間で送受信されます。ユーザーは、端末またはArduino IDEのシリアルモニターを介してこれと対話できます。プラットフォームの選択から推測したかもしれませんが、実際の和音の演奏を含める予定です（まだ行っていません）。

私はキーボードボーナスにうまく取り組みました。

コードボックスは130バイトで受信しますが、長すぎて価値がありません。したがって、別の方法を試してみました。フレット番号のタブスタイルを印刷するだけです。現在、これは81-100 = -19のボーナスに対して81バイトです。このアプローチが有効であると思われる場合、私はそれを試して改善することができます。

使用されるコードはすべて、2番目のストリングにルート、3番目のストリングに5番目、1番目と4番目のストリングに3番目のルートを持つDタイプのシェイプです。5番目と6番目の文字列は使用されず、コードボックスの右側にXを付けてこれをマークします（左側がより一般的ですが、右側にマークされた例があります）。

プログラムはFを最低音と見なしているため（この和音の形で過度に高いフレットを避けながらキーボードとの互換性を保つため）、最高の和音はE（17フレットのルート付き）です。出力例を参照してください。

キーボードはゴルフの面でより成功しています。上記の理由により、CBではなくFEから実行されます。画面を90％反時計回りに回して表示する必要があります。黒のノートのアウトラインとを使用して白のノートの境界をはっきりと見ることができます---。BとCの間の行は、____さらに数バイト拡張することができます。

次にノートを演奏してみます。Arduino Unoには3つの内部タイマーがあると思いますが、組み込みのトーンコマンドを使用して一度に1つのノートしか再生できないため、これは興味深いでしょう。すべてのハードウェアタイマーを使用する外部ライブラリ関数があります（シリアルを台無しにしますが、とにかくその段階では必要ありません。）あるいは、softareでトーンを生成することもできます。

私がそれで成功した場合、私はそれを打ち倒しますが、それが全体的な勝者になるとは思いません。

未ゴルフコード

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

サンプル出力 テキスト行の間隔が狭いほど、見栄えが良くなります。したがって、実際に投稿を編集しているときは見栄えが良いですが、投稿後の灰色のボックスでは恐ろしいです。代わりに、中間行間隔のArduinoシリアルモニターのスクリーンショットを投稿しました（したがって、表示品質）。

Python3-315文字

codegolfで初めて！現在、マイナー、メジャー、ディミニッシュ、オーグメンテッドコードのみをサポートしています。

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（1文字としてユニコード）-150（サウンド）-150（キーボード）= 206

サウンドの再生には、を使用しpygame.midiます。このpygame.midi.get_default_output_id()メソッドはうまく機能しないことに注意してください。あなたが行を変更してみてようo=Output(get_default_output_id())にo=Output(1)、o=Output(2)など通常正しい値は0と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))

結果

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文字

自己完結型、コンソール入力から読み取ります。stdinが必要な場合は、final 1をに変更し3ます。ボーナスを要求せず、トライアドのみをカバーします。

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

シャープなメモの代わりに、たとえばC#同等のフラット名を使用する必要がありますDb。（これを修正すると、コードが少しだけ膨らみます。）4種類のコードは0減少するためのものです。mマイナー、Mメジャー、および+拡張用です。

ロジックは次のとおりです。最後の文字を使用して、ベース0-3-6にオフセットを追加し、3番目と5番目の種類を選択します。一方、音符を使用して、音階のどこから音符を引き出すかを見つけます。の;:両方の開始時に、スケールにインデックスを付けると、ノートの互換性になり、以降（で&.文字列を区切り）空間に引き込まノートを回します。

使用例：

   +/&(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文字

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

これは私の最初のコードゴルフです。短くできると思いますが、保存するバイトが見つかりません。

支持体、主要なm、マイナーのための0低下のためには、+のために増補、以上の37のバイトdim、aug。

Python（143 134文字）

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

私の最初のゴルフチャレンジ:)、さらにバイトを削ることができるかどうかわからない。
ここで使用される表記は* aug / + maj /、min /-dim
です。コードに定数42を含めると、ボーナスポイントに値します

Python 3：257-150 = 107

Jソリューションに勝るには長すぎる25文字です！しかたがない。ここにはきちんとしたアイデアがあると思います。

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

入力は例に似ていますが、フラットな名前の代わりにシャープな名前を使用する必要があります。（たとえば、GbはF＃でなければなりません）

出力は、ピアノの1オクターブであり、上と左から見て、音名が重ねられています。ほんの小さな想像力のストレッチである必要があります。

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

Scala 537文字-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文字

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

結果

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"]