вход

Символ любого триадического аккорда (см. 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#

Бонусы

-50, если вы можете также иметь дело с седьмыми аккордами

-150 за то, что на самом деле играет звук аккорда

-150 за использование печатных символов, чтобы показать, как играть аккорд на фортепиано; пример для AM:

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

-100 за использование печатных символов, чтобы показать, как играть аккорд на гитаре; пример для AM:

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

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

правила

• Результатом должна быть программа или скрипт командной строки.

• Вход и выход могут быть в любой форме, если они соответствуют стандарту музыкальной нотации.

• Гитара или фортепьяно считается действительным, если и только если оно содержит три (триадные) или четыре (седьмой) обязательные ноты и ничего больше. Одна и та же нота может присутствовать несколько раз в аккорде.

• Внешние библиотеки не допускаются, за исключением генерации звука (в этом случае директивы #include, import... не добавляются к числу символов).

• Это код гольф, выигрывает самый короткий код!

Немного теории музыки ...

В современной западной тональной музыке каждая октава состоит из двенадцати последовательных нот, часто отмечаемых:

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

Или:

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

В этой системе мы считаем, что две последовательные ноты (например, Aи A#, или Eи F) разделены одним полутоном. Кроме того, заметки являются своего рода «зацикливанием»: то, что сразу следует, G#- A.

Аккорд состоит из нескольких (2, 3, 4, иногда больше) нот, которые «звучат хорошо вместе». Например, триадические аккорды содержат три разные ноты, а седьмые аккорды содержат четыре разные ноты.

Давайте определим четыре триадических аккорда как:

• Большая триада : содержит корень аккорда (в этом вопросе примечание, приведенное в качестве входных данных), главную треть для корня (на 4 полутона выше, чем корень) и идеальную пятую для корня (на 7 полутонов выше, чем корень). ); это может быть символизировано 0-4-7

• Малая триада , символизирует 0-3-7

• Дополненная триада , символизирует 0-4-8

• Уменьшенная триада , символизированная 0-3-6

Так, например, если вы хотите сделать мажорную триаду , отметили C, CM, Cmaj, вам нужно будет три отметили:

• 0: корень , в данном случаеC
• 4: минорная треть , на 4 полутона выше корня; этоE
• 7: идеальный пятый , 7 полутонов выше, чем корень:G

Это то , что 0-4-7, 0-3-7, 0-4-8и 0-3-6условные обозначения используются выше среднего! Для седьмых аккордов используйте следующий шаблон:

На сегодня все! Теперь удивите меня удивительным кодом ... Если у вас есть какие-либо вопросы, добавьте несколько комментариев ниже.

BBC BASIC

Эмулятор на bbcbasic.co.uk

Rev 1, 340 - 150 клавишных - 150 играющих = 40

Вот последняя версия, в которой мне удалось включить следующие улучшения, удлинив при этом еще на несколько символов.

Ввод можно удобно редактировать на экране перед нажатием клавиши return ( раньше я использовал GET $ для получения однократных нажатий клавиш, потому что BBC Basic не позволяет получить доступ к одному символу из строки, как если бы строка была массивом. Теперь я использую довольно громоздкая функция MID $ для извлечения строки из одного символа из строки.

Отображаются обе стороны клавиатуры, а также полная линия между E и F.

Чтобы компенсировать символы, добавленные выше, я переставил программу, чтобы исключить ненужные операторы печати, и удалил некоторые пробелы, которые на первый взгляд выглядели так, как будто их нельзя удалить. В BBC Basic все встроенные функции являются зарезервированными словами, и вы можете поместить имя переменной прямо перед ними без пробела между ними. Имена переменных не могут начинаться с зарезервированного слова. Чтобы сделать программу менее запутанной для чтения, я изменил все переменные на строчные.

Хотя презентация выглядит намного лучше, следующая программа уже полностью отработана. (См. Исправление ниже.) Обычно символы новой строки и двоеточия взаимозаменяемы, за исключением случаев, когда используется оператор IF. В этом случае все операторы в одной строке (разделенные двоеточиями) должны быть выполнены условно. Выражения после новой строки не контролируются IF и всегда будут выполняться.

Программа рев 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 Bassic для Windows от RT Russell позволяет исключить некоторые новые строки и двоеточия, в результате чего общее количество сокращается до 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 basic. Только распознает острые предметы, но считает 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

Как вы можете сказать, я вообще не пытался играть в гольф. Я - фанат музыки, и моя любимая мозоль - это когда люди пишут вещи с использованием неправильной эхармоники (например, говорят, что аккорд с уменьшенным Си - это CD # F # вместо C Eb Gb), поэтому я написал эту программу, которая получает энгармонику правильно. Это делается путем представления каждой ноты как числа совершенных пятых над F.

Для чего стоит, если вы хотите различить энгармонику, любой музыкальный интервал может быть красиво представлен в компьютерной программе как число идеальных пятых и октав. Например, расширенная четверть - это 6 идеальных пятых и -3 октавы, а уменьшенная пятая - это -6 идеальных пятых и 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

Вход / выход отправляется на / принимается от Arduino через COM-порт. Пользователь может взаимодействовать с этим через терминал или последовательный монитор в Arduino IDE. Как вы уже догадались из моего выбора платформы, я планирую включить фактическую игру аккорда (хотя я еще этого не сделал).

Я успешно справился с бонусом на клавиатуру и попытался справиться с гитарой, но с ограниченным успехом.

Поле аккордов занимает 130 байтов, что слишком долго, чтобы того стоить. Поэтому я попробовал другой способ, просто печатая стиль табуляции ладных чисел. В настоящее время это 81 байт для бонуса 81-100 = -19. Если этот подход считается действительным, я могу попытаться улучшить его.

Используются аккорды всех форм D-типа с корнем на 2-й строке, пятым на 3-й строке и третьим на 1-й и 4-й строках. 5-я и 6-я строки не используются, и я отмечаю это X в правой части поля аккордов (слева будет более обычным, но примеры, отмеченные справа, можно найти.)

Поскольку программа рассматривает F как самую низкую ноту (для совместимости с клавиатурой, избегая при этом чрезмерно высоких ладов с этой формой аккорда), самая высокая аккорд - это E (с корнем на 17-м ладу). См. Пример выходных данных.

Клавиатура более удачна с точки зрения игры в гольф. Он запускается из FE, а не CB по причинам, описанным выше. Его нужно просматривать, поворачивая экран на 90% против часовой стрелки, когда вы можете четко видеть контуры черных нот и разграничение между белыми нотами с помощью ---. Линия между B a C может быть расширена еще ____на несколько байтов.

Я попробую сыграть ноты дальше. Это будет интересно, потому что, хотя я считаю, что Arduino Uno имеет 3 внутренних таймера, только одна нота за раз может быть воспроизведена с помощью встроенной тональной команды. Существует функция внешней библиотеки, которая использует все аппаратные таймеры (которые будут портить последовательный порт, но в любом случае на этом этапе он не понадобится). В качестве альтернативы я могу попытаться воспроизвести тональные сигналы в более мягкой форме.

Если мне это удастся, я проиграю, но не думаю, что это будет абсолютный победитель.

Код без правил

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 символа

Автономный, читает из консоли ввода. Если вам нужен стандартный ввод, измените финал 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. (Исправление для этого приведет к раздуванию кода более чем на несколько раз.) Четыре типа аккордов предназначены 0для уменьшающихся, mдля минорных, Mдля мажорных и +для дополненных.

Логика следующая: мы используем последний символ для добавления смещения к основанию 0-3-6, которое выбирает вид третьего и пятого. Тем временем мы используем заметку, чтобы найти, где в шкале вытащить заметки. И то, и ;:другое делает примечание совместимым с индексированием в масштабе в начале, а затем (путем &.) превращает вытянутые примечания в разделенную пробелами строку.

Пример использования:

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

Питон ( 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 в коде: P

Питон 3: 257 - 150 = 107

Всего 25 символов слишком долго, чтобы победить решение J! Ну что ж. Я думаю, здесь есть несколько интересных идей.

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

Выход - единственная октава фортепиано, видимая сверху и слева, с наложенными именами нот. Должно быть только крошечное воображение.

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