Wkład

Symbol dowolnego triadycznego akordu (patrz http://en.wikipedia.org/wiki/Chord_(music)#Triads ).

Wydajność

Nuty składające się na dany akord.

Przykłady

Wejście: AM Wyjście:A C# E

Wejście: C#m Wyjście:C# E G#

Wejście: Db+ Wyjście:C# F A

Wejście: C0 Wyjście:C D# F#

Bonusy

-50, jeśli poradzisz sobie również z siódmymi akordami

-150 za faktyczne odtwarzanie dźwięku akordu

-150 za użycie znaków do wydrukowania, aby pokazać, jak grać akord na pianinie; przykład dla AM:

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

-100 za użycie znaków do wydrukowania, aby pokazać, jak grać akord na gitarze; przykład dla AM:

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

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

Zasady

• Wynik musi być programem wiersza polecenia lub skryptem.

• Dane wejściowe i wyjściowe mogą mieć dowolną formę, o ile są zgodne ze standardem notacji muzycznej.

• Reprezentacja gitary lub fortepianu jest uważana za ważną tylko wtedy, gdy zawiera trzy (triadyczne) lub cztery (siódme) wymagane nuty i nic więcej. Ta sama nuta może występować kilka razy w akordzie.

• Zewnętrzne biblioteki nie są dozwolone, z wyjątkiem generowania dźwięku (w którym to przypadku #include, import... Dyrektywy nie są dodawane do liczby znaków).

• To jest kod golfowy, wygrywa najkrótszy kod!

Trochę teorii muzyki ...

We współczesnej zachodniej muzyce tonalnej każda oktawa składa się z dwunastu następujących po sobie nut:

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

Lub:

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

W tym systemie uważamy, że dwie kolejne nuty (np. AI A#, lub Ei F) są oddzielone jednym półtonem. Ponadto, notatki są rodzajem „zapętlenie”: co natychmiast następuje G#to A.

Akord składa się z kilku (2, 3, 4, czasem więcej) nut, które „brzmią razem dobrze”. Na przykład akordy triadowe zawierają trzy różne nuty, a siódmy akord zawiera cztery różne nuty.

Zdefiniujmy cztery triady akordowe jako:

• Major triada : zawiera pierwiastek akordu (w tym pytaniu nutę podaną jako dane wejściowe), trzecią część główną dla rdzenia (4 półtony wyższe od rdzenia) i idealną piątą dla rdzenia (7 półtonów powyżej rdzenia ); może to być symbolizowane 0-4-7

• Drobna triada , symbolizowana 0-3-7

• Rozszerzona triada , symbolizowana 0-4-8

• Zmniejszona triada , symbolizowana 0-3-6

Tak na przykład, jeśli chcesz dokonać C-dur triadę , zauważył C, CM, Cmaj, trzeba będzie trzy zauważył:

• 0: root , w tym przypadku aC
• 4: mniejsza trzecia , 4 półtony wyższe niż korzeń; to jestE
• 7: idealna piąta , 7 półtonów wyższa od rdzenia: aG

To właśnie 0-4-7, 0-3-7, 0-4-8i 0-3-6notacje użyte powyżej średniej! W przypadku siódmego akordu użyj następującego wzoru:

To tyle na dzisiaj! Teraz zadziwi mnie niesamowitym kodem ... Jeśli masz jakieś pytania, dodaj kilka komentarzy poniżej.

BBC BASIC

Emulator na bbcbasic.co.uk

Rev 1, 340 - 150 klawiatura - 150 gra = 40

Oto najnowsza wersja, w której udało mi się wprowadzić następujące ulepszenia, wydłużając je tylko o kilka dodatkowych postaci.

Dane wejściowe można wygodnie edytować na ekranie przed naciśnięciem klawisza return (wcześniej użyłem GET $, aby uzyskać pojedyncze naciśnięcia klawiszy, ponieważ BBC Basic nie pozwala na dostęp do pojedynczego znaku z ciągu znaków, tak jakby ciąg był tablicą. Teraz używam raczej nieporęczna funkcja MID $, aby wyodrębnić ciąg jednego znaku z ciągu.

Wyświetlane są obie strony klawiatury, a także pełna linia między literami E i F.

Aby zrekompensować znaki dodane przez powyższe, przestawiłem program, aby wyeliminować niepotrzebne instrukcje drukowania, i usunąłem białe znaki, które na pierwszy rzut oka wyglądały, jakby nie można było ich usunąć. W BBC Basic wszystkie wbudowane funkcje są zastrzeżonymi słowami i możesz umieścić przed nimi nazwę zmiennej bez spacji. Nazwy zmiennych nie mogą zaczynać się od słowa zarezerwowanego. Aby program był mniej skomplikowany w czytaniu, zmieniłem wszystkie zmienne na małe litery.

Chociaż prezentacja wygląda znacznie lepiej, następujący program jest już w pełni golfowy. (Patrz korekta poniżej.) Zasadniczo znaki nowej linii i dwukropki są wymienne, z wyjątkiem przypadków użycia instrukcji IF. W takim przypadku wszystkie instrukcje w tym samym wierszu (oddzielone dwukropkami) należy wykonać warunkowo. Instrukcje po nowej linii nie są kontrolowane przez IF i zawsze będą wykonywane.

Program wer. 1 340 znaków

  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

KOREKTA: BBC BASIC RT Russella dla systemu Windows pozwala wyeliminować niektóre znaki nowej linii i dwukropki, zmniejszając całkowitą liczbę do 327, patrz poniżej. Również zapisuje słowa kluczowe w pojedyncze znaki przed zapisaniem, co obniża je do 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

Wyjście rev 1

Rev 0, 337 - 150 klawiatura - 150 gra = 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

Jest to podobna koncepcja do mojej odpowiedzi Arduino, ale zawsze wiedziałem, że mogę pokonać tę liczbę bajtów za pomocą BBC basic. Rozpoznaje tylko ostre narzędzia, ale uważa B # za nieważne, musisz wpisać C. Można to naprawić, jeśli naprawdę uważa się to za ważne.

Zrezygnowałem z gitary i skoncentrowałem się na ulepszeniu klawiatury. Teraz biegnie od C do B, a ja dodałem po lewej stronie klawiatury i linii między E i F. To kosztuje 28 znaków. Prawa strona nie byłaby niczym więcej.

Oto przykładowe wyjście, akord o zmniejszonej A # (który ma dość dziwaczny dźwięk w tej inwersji) i akord B-dur. Pamiętaj, że dane wejściowe nie są wyświetlane na ekranie. Zgodnie z odpowiedzią Arduino obróć ekran w kierunku przeciwnym do ruchu wskazówek zegara, aby wyświetlić.

Wersja bez golfa

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

Jak widać, wcale nie próbowałem grać w golfa. Jestem maniakiem muzyki, a mój wkurzony ptaszek ma miejsce, gdy ludzie piszą rzeczy używając niewłaściwego enharmoniki (np. Mówiąc, że akord zmniejszony C to CD # F # zamiast C Eb Gb), więc napisałem ten program, który dostaje enharmonikę dobrze. Robi to, reprezentując każdą nutę jako liczbę idealnych piątych powyżej F.

Jeśli chodzi o to, co warto, jeśli chcesz rozróżnić enharmonikę, każdy interwał muzyczny może być ładnie reprezentowany w programie komputerowym jako liczba doskonałych piątych i liczba oktaw. Na przykład powiększona czwarta to 6 idealnych piątych i -3 oktawy, a zmniejszona piąta to -6 idealnych piątych i 4 oktaw.

Haskell, 441 znaków

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

Niektóre przykładowe wywołania:

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

Wejście / wyjście jest wysyłane do / odbierane z Arduino przez port COM. Użytkownik może wchodzić w interakcje z tym za pośrednictwem terminala lub monitora szeregowego w Arduino IDE. Jak mogłeś się domyślić z mojego wyboru platformy, planuję uwzględnić faktyczną grę akordu (chociaż jeszcze tego nie zrobiłem).

Z powodzeniem rozwiązałem problem z klawiaturą i próbowałem zmierzyć się z gitarą, z ograniczonym sukcesem.

Pole akordów ma 130 bajtów, co jest zbyt długie, aby było tego warte. Dlatego wypróbowałem inny sposób, po prostu drukując styl tabulatorów liczb progów. Obecnie jest to 81 bajtów dla premii 81-100 = -19. Jeśli to podejście zostanie uznane za prawidłowe, mogę spróbować je ulepszyć.

Wszystkie użyte akordy to kształty typu D z rdzeniem na 2. strunie, piąte na 3. strunie i trzecie na 1. i 4. strunie. Piąta i szósta struna nie są używane i zaznaczam to X po prawej stronie pola akordów (lewy byłby bardziej zwyczajny, ale przykłady zaznaczone po prawej stronie można znaleźć).

Ponieważ program uważa F za najniższą nutę (dla zgodności z klawiaturą, unikając jednocześnie zbyt wysokich progów z tym kształtem akordu), najwyższym akordem jest E (z rdzeniem na 17. progu.) Zobacz przykładowe wyjście.

Klawiatura odnosi większe sukcesy pod względem golfowym. Działa z FE, a nie z CB z powodów opisanych powyżej. Musi być oglądany przez obrócenie ekranu o 90% w kierunku przeciwnym do ruchu wskazówek zegara, kiedy wyraźnie widać kontury czarnych nut i rozgraniczenie białych nut za pomocą ---. Linia między B i C może zostać przedłużona o ____kilka dodatkowych bajtów.

Następnie spróbuję zagrać nuty. Będzie to interesujące, ponieważ chociaż uważam, że Arduino Uno ma 3 wewnętrzne timery, tylko jedna nuta może być odtwarzana za pomocą wbudowanego polecenia tonu. Istnieje funkcja zewnętrznej biblioteki, która wykorzystuje wszystkie timery sprzętowe (które zepsują serial, ale i tak nie będą potrzebne na tym etapie.) Alternatywnie mogę spróbować wygenerować dźwięki w softare.

Jeśli mi się to uda, zagram w golfa, ale nie sądzę, że to będzie ogólny zwycięzca.

Nieskluczony kod

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

Przykładowe dane wyjściowe Im mniejsze odstępy między wierszami tekstu, tym lepiej to wygląda. Dlatego wygląda świetnie, kiedy faktycznie edytuję post, ale jest okropny w szarym polu po opublikowaniu. Zamiast tego opublikowałem zrzut ekranu monitora szeregowego Arduino, który ma pośrednie odstępy między wierszami (a tym samym jakość wyświetlania).

Python3 - 315 znaków

Pierwszy raz w codegolf! Obsługuje obecnie tylko drobne, większe, zmniejszone i wzmocnione akordy.

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 jako 1 znak) -150 (dźwięk) -150 (klawiatura) = 206

Do odtwarzania dźwięku używa pygame.midi. Zauważ, że pygame.midi.get_default_output_id()metoda nie działa zbyt dobrze. Możesz więc spróbować zmienić linię o=Output(get_default_output_id())na o=Output(1), o=Output(2)itp. Zwykle poprawna wartość wynosi od 0 do 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))

Wyniki

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 znak

Samodzielny, odczytuje z wejścia konsoli. Jeśli potrzebujesz stdin, zmień finał 1na a 3. Żądanie żadnych bonusów i tylko pokrycie triad.

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

Zamiast ostrej notatki, np. C#Musisz użyć równoważnej płaskiej nazwy Db. (Korekcja za to będzie nadmuchać kodu przez więcej niż trochę). Cztery rodzaje akordów są 0do pomniejszenia, mdla małoletniego, Mza główny, a +na powiększone.

Logika jest następująca: używamy ostatniego znaku, aby dodać przesunięcie do bazy 0-3-6, która wybiera rodzaj trzeciej i piątej. Tymczasem używamy nuty, aby znaleźć miejsce w skali, z którego można pobrać nuty. ;:Zarówno sprawia notatkę zgodną z indeksowania w skali na początku, a później (o &.) zamienia wyciągnął notes w przestrzeń oddziela łańcuch.

Przykładowe użycie:

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

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

To jest mój pierwszy golfowy kod. Myślę, że może być krótszy, ale nie mogę znaleźć bajtów do zapisania.

Podpory główne, mdla moll 0na zmniejszony, +dla powiększona lub 37 bajtów więcej dim, aug.

Python ( 143 134 znaków)

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

Moje pierwsze wyzwanie w golfa :), nie wiem, czy uda się wygolić więcej bajtów.
Stosowana tutaj notacja to * aug / + maj /, min / - dim
Zasługuję na punkt bonusowy za to, że mam stałą 42 w kodzie: P

Python 3: 257 - 150 = 107

Tylko 25 znaków za długo, aby pokonać rozwiązanie J! No cóż. Myślę, że jest tu kilka fajnych pomysłów.

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

Dane wejściowe są jak w przykładach, ale musisz używać ostrych nazw zamiast płaskich nazw. (np. Gb musi być F #)

Wyjście to pojedyncza oktawa fortepianu, widziana z góry i po lewej, z nałożonymi nazwami nut. Powinien to być tylko niewielki odcinek wyobraźni.

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

Scala 537 znaków - 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 znaków

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

Wyniki

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