Вхідні дані

Символ будь-якого тріадного акорду (див. 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: корінь , в даному випадку aC
• 4: другорядний третій , на 4 півтона вище кореня; цеE
• 7: ідеальна п’ята , на 7 півтонів вище кореня: аG

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

Ось це на сьогодні! Тепер дивуйте мене дивовижним кодом ... Якщо у вас виникли питання, додайте коментарі нижче.

BBC BASIC

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

Ред. 1, 340 - 150 клавіатура - 150 гра = 40

Ось остання версія, в яку мені вдалося включити наступні вдосконалення, подовжуючи лише кілька символів.

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

Відображаються обидві сторони клавіатури, а також повна лінія між E і F.

Щоб компенсувати додані вище символи, я переставив програму для усунення зайвих операцій друку та видалив пробіл, який на перший погляд виглядав так, що його не можна було видалити. У BBC Basic всі вбудовані функції є зарезервованими словами, і ви можете поставити ім'я змінної прямо перед ними, не маючи місця між ними. Імена змінних заборонено починати із зарезервованого слова. Щоб зробити програму менш заплутаною для читання, я змінив усі змінні на малі регістри.

Хоча презентація виглядає набагато краще, наступна програма насправді вже повністю гольфується. (Див. Виправлення нижче.) Зазвичай нові рядки та колонки взаємозамінні, за винятком випадків, коли використовується оператор 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

ВИКОРИСТАННЯ. BBC BASIC RT Russell для ОС Windows дозволяє усунути деякі нові лінії та колонки, знизивши загальну суму до 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

Оберт 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

Це схожа концепція на мою відповідь Ардуїно, але я завжди знав, що можу перемогти цей байт з базовим BBC. Розпізнає лише різкі розміри, але вважає B # недійсним, ви повинні поставити C. Це може бути виправлено, якби воно справді вважалося важливим.

Я відмовився від ідеї гітари і зосередився на вдосконаленні клавіатури. Тепер він працює від C до B, і я додав у лівій частині клавіатури та рядок між E та F. Це коштує 28 символів. Права частина не буде набагато більше.

Ось деякий зразок виходу, зменшений акорд (#) (який має досить чудернацький звук у цій інверсії) та основний акорд 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 - це 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 через COM-порт. Користувач може взаємодіяти з цим через термінал або послідовний монітор в ID Arduino IDE. Як ви, напевно, здогадалися з мого вибору платформи, я планую включити фактичну гру акорду (хоча я цього ще не зробив.)

Я успішно вирішив бонус на клавіатурі, і намагався вирішити гітару з обмеженим успіхом.

У аккордовій коробці розміщено 130 байт, що занадто довго не варто. Тому я спробував інший спосіб, просто надрукувавши стилі номери стилю Tab. Наразі це 81 байт за бонус 81-100 = -19. Якщо цей підхід буде визнаний дійсним, я можу спробувати його вдосконалити.

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

Оскільки програма вважає F найнижчою нотою (для сумісності з клавіатурою, уникаючи надмірно високих ладів з такою формою акорда), найвищим акордом є E (з коренем на 17-му ладі.) Дивіться приклад виводу.

Клавіатура більш успішна в плані гольфу. Він працює від FE, а не від CB з причин, описаних вище. Це потрібно переглядати, повертаючи екран на 90% проти годинникової стрілки, коли ви чітко бачите контури чорних нот та розмежування білих нот із ---. Рядок між B a C може бути продовжений на кілька ____на кілька байтів.

Я спробую грати в ноти далі. Це буде цікаво, тому що, хоча я вважаю, що у Arduino Uno є 3 внутрішніх таймера, лише одна нота одночасно може відтворюватись за допомогою вбудованої в команду тональності. Існує функція зовнішньої бібліотеки, яка використовує всі апаратні таймери (які зіпсують послідовний цикл, але на цьому етапі це все-таки не знадобиться.) Як альтернатива, я можу спробувати створити тони у 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 char

Перший раз у кодегольфі! Зараз підтримує лише незначні, основні, зменшені та доповнені акорди.

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 як 1 char) -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 char

Автономне, зчитується з консольного введення. Якщо вам потрібен stdin, змініть фінал 1на a 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 char

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