Đầu vào

Biểu tượng của bất kỳ hợp âm ba (xem http://en.wikipedia.org/wiki/Chord_(music)#Triads ).

Đầu ra

Các nốt tạo thành hợp âm đã cho.

Ví dụ

Đầu vào: AM Đầu ra:A C# E

Đầu vào: C#m Đầu ra:C# E G#

Đầu vào: Db+ Đầu ra:C# F A

Đầu vào: C0 Đầu ra:C D# F#

Tiền thưởng

-50 nếu bạn cũng có thể đối phó với hợp âm thứ bảy

-150 để thực sự chơi âm thanh của hợp âm

-150 để sử dụng các ký tự có thể in để hiển thị cách chơi hợp âm trên đàn piano; ví dụ cho AM:

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

-100 để sử dụng các ký tự có thể in để hiển thị cách chơi hợp âm trên guitar; ví dụ cho AM:

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

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

Quy tắc

• Kết quả phải là một chương trình dòng lệnh hoặc tập lệnh.

• Đầu vào và đầu ra có thể ở bất kỳ dạng nào, miễn là tuân theo tiêu chuẩn ký hiệu âm nhạc.

• Một đại diện cho guitar hoặc piano được coi là hợp lệ khi và chỉ khi nó chứa ba nốt (bộ ba) hoặc bốn (thứ bảy) cần thiết và không có gì khác. Cùng một lưu ý có thể được trình bày nhiều lần trong hợp âm.

• Thư viện bên ngoài không được phép, ngoại trừ việc tạo âm thanh (trong trường hợp đó #include, import... các lệnh không được thêm vào số lượng ký tự).

• Đây là mã golf, mã ngắn nhất sẽ thắng!

Một chút lý thuyết âm nhạc ...

Trong âm nhạc phương Tây hiện đại, mỗi quãng tám được tạo thành mười hai nốt liên tiếp, thường được ghi chú:

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

Hoặc là:

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

Trong hệ thống này, chúng ta xem xét rằng hai ghi chú liên tiếp (ví dụ Avà A#hay Evà F) được ngăn cách bởi một semitone. Ngoài ra, các ghi chú là loại "vòng lặp": những gì ngay sau đó G#là A.

Một hợp âm được cấu thành bởi một vài (2, 3, 4, đôi khi nhiều hơn) ghi chú rằng "âm thanh tốt với nhau". Chẳng hạn, hợp âm ba có ba nốt khác nhau và hợp âm thứ bảy chứa bốn nốt khác nhau.

Chúng ta hãy định nghĩa bốn hợp âm ba là:

• Bộ ba chính : chứa gốc của hợp âm (trong câu hỏi này, ghi chú được đưa ra làm đầu vào), thứ ba chính cho gốc (4 semitones cao hơn gốc) và thứ năm hoàn hảo cho gốc (7 semitones cao hơn gốc ); điều này có thể được ký hiệu 0-4-7

• Bộ ba nhỏ , tượng trưng 0-3-7

• Bộ ba tăng cường , tượng trưng 0-4-8

• Bộ ba giảm dần , tượng trưng 0-3-6

Vì vậy, ví dụ, nếu bạn muốn thực hiện một C bộ ba lớn , ghi nhận C, CM, Cmaj, bạn sẽ cần ba lưu ý:

• 0: gốc , trong trường hợp này làC
• 4: thứ ba nhỏ , 4 nửa cung cao hơn gốc; đó là mộtE
• 7: thứ năm hoàn hảo , 7 nửa cung cao hơn gốc: aG

Đây là những gì 0-4-7, 0-3-7, 0-4-8và 0-3-6ký hiệu sử dụng trên trung bình! Đối với hợp âm thứ bảy, sử dụng mẫu sau:

Điều này là dành cho hôm nay! Bây giờ, làm tôi ngạc nhiên với mã tuyệt vời ... Nếu bạn có bất kỳ câu hỏi nào, hãy thêm một số ý kiến ​​dưới đây.

BBC CƠ BẢN

Trình giả lập tại bbcbasic.co.uk

Rev 1, 340 - 150 bàn phím - 150 phát = 40

Đây là phiên bản mới nhất, trong đó tôi quản lý để bao gồm các cải tiến sau trong khi kéo dài chỉ bằng một vài ký tự.

Đầu vào có thể được chỉnh sửa thoải mái trên màn hình trước khi nhấn return (Tôi đã sử dụng GET $ trước đây để nhận các phím bấm đơn, vì BBC Basic không cho phép bạn truy cập một ký tự từ một chuỗi như thể chuỗi là một mảng. Bây giờ tôi sử dụng thay thế Hàm MID $ cồng kềnh để trích xuất một chuỗi gồm một ký tự từ bên trong chuỗi.

Cả hai mặt của bàn phím được hiển thị cũng như dòng đầy đủ giữa E và F.

Để bù đắp cho các ký tự được thêm vào ở trên, tôi đã sắp xếp lại chương trình để loại bỏ các câu lệnh in không cần thiết và xóa một số khoảng trắng mà thoạt nhìn trông như không thể xóa được. IN BBC Basic tất cả các hàm được xây dựng đều là các từ dành riêng và bạn có thể đặt một tên biến ngay trước chúng không có khoảng trắng ở giữa. Tên biến không được phép bắt đầu bằng một từ dành riêng. Để làm cho chương trình bớt khó hiểu hơn, tôi đã thay đổi tất cả các biến thành chữ thường.

Mặc dù bài thuyết trình có vẻ tốt hơn nhiều, nhưng chương trình sau đây thực sự đã được chơi đầy đủ. (Xem phần chỉnh sửa bên dưới.) Nói chung các dòng mới và dấu hai chấm có thể hoán đổi cho nhau, trừ khi sử dụng câu lệnh IF. Trong trường hợp đó, tất cả các câu lệnh trên cùng một dòng (được phân tách bằng dấu hai chấm) được thực hiện theo điều kiện. Các báo cáo sau dòng mới không được kiểm soát bởi IF và sẽ luôn được thực thi.

Chương trình rev 1 340 ký tự

  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

ĐÚNG: BBC BASIC cho Windows của RT Russell cho phép bạn loại bỏ một số dòng mới và dấu hai chấm, đưa tổng số xuống còn 327, xem bên dưới. Ngoài ra, nó mã hóa các từ khóa thành các ký tự đơn trước khi lưu, đưa nó xuống 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

Đầu ra rev 1

Rev 0, 337 - 150 bàn phím - 150 phát = 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

Đây là một khái niệm tương tự như câu trả lời Arduino của tôi, nhưng tôi luôn biết rằng tôi có thể đánh bại số byte đó với BBC cơ bản. Chỉ nhận ra các vật sắc nhọn, nhưng coi B # không hợp lệ, bạn phải đặt C. Điều này có thể được sửa nếu nó thực sự được coi là quan trọng.

Tôi từ bỏ ý tưởng về guitar và tập trung vào việc cải thiện bàn phím. Bây giờ nó chạy từ C đến B, và tôi đã thêm vào bên trái bàn phím và dòng giữa E và F. Có giá 28 ký tự. Phía bên tay phải sẽ không nhiều hơn nữa.

Đây là một số đầu ra mẫu, một hợp âm giảm dần A # (có âm thanh khá quái đản trong sự đảo ngược này) và một hợp âm B chính. Lưu ý rằng đầu vào không được lặp lại với màn hình. Theo câu trả lời của Arduino, xoay màn hình ngược chiều kim đồng hồ để xem.

Phiên bản ung dung

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

Như bạn có thể nói, tôi đã không cố gắng chơi golf này. Tôi là một người đam mê âm nhạc, và một tiểu thư thú cưng của tôi là khi mọi người viết những thứ sử dụng sai giai điệu (ví dụ, nói rằng một hợp âm giảm âm C là CD # F # thay vì C Eb Gb), vì vậy tôi đã viết chương trình này có được sự tăng cường đúng. Nó làm như vậy bằng cách đại diện cho mỗi ghi chú là số thứ năm hoàn hảo trên F.

Đối với giá trị của nó, nếu bạn muốn phân biệt các giai điệu, bất kỳ khoảng âm nhạc nào cũng có thể được biểu diễn độc đáo trong một chương trình máy tính như một số phần năm hoàn hảo và một số quãng tám. Ví dụ, một phần tư tăng thêm là 6 phần năm và -3 quãng tám hoàn hảo, và phần năm giảm dần là -6 phần năm hoàn hảo và 4 quãng tám.

Haskell, 441 ký tự

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

Một số ví dụ:

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

Đầu vào / đầu ra được gửi đến / nhận từ Arduino thông qua cổng COM. Người dùng có thể tương tác với điều này thông qua một thiết bị đầu cuối hoặc màn hình nối tiếp trong Arduino IDE. Như bạn có thể đoán từ sự lựa chọn nền tảng của mình, tôi đang lên kế hoạch bao gồm cả việc chơi hợp âm thực sự (mặc dù tôi chưa thực hiện được.)

Tôi đã giải quyết phần thưởng bàn phím thành công và tôi đã cố gắng giải quyết guitar, với thành công hạn chế.

Hộp hợp âm có 130 byte, quá dài để có giá trị. Vì vậy, tôi đã thử một cách khác, chỉ in các kiểu băn khoăn kiểu Tab. Hiện tại, đây là 81 byte cho phần thưởng là 81-100 = -19. Nếu phương pháp này được coi là hợp lệ, tôi có thể thử và cải thiện nó.

Các hợp âm được sử dụng là tất cả các hình dạng loại D với gốc trên chuỗi thứ 2, thứ năm trên chuỗi thứ 3 và thứ ba trên chuỗi thứ 1 và thứ 4. Các chuỗi thứ 5 và 6 không được sử dụng và tôi đánh dấu chuỗi này bằng X ở bên phải hộp hợp âm (bên trái sẽ bình thường hơn, nhưng có thể tìm thấy các ví dụ được đánh dấu ở bên phải.)

Bởi vì chương trình coi F là nốt thấp nhất (về khả năng tương thích với bàn phím trong khi tránh các phím đàn quá cao với hình dạng hợp âm này), hợp âm cao nhất là một E (có gốc trên phím thứ 17).

Bàn phím thành công hơn về mặt chơi golf. Nó chạy từ FE chứ không phải CB vì những lý do được mô tả ở trên. Nó phải được xem bằng cách xoay màn hình 90% ngược chiều kim đồng hồ, khi bạn có thể thấy rõ đường viền của các ghi chú màu đen và phân chia giữa các ghi chú màu trắng với ---. Dòng giữa B một C có thể được mở rộng với một số ____cho thêm vài byte.

Tôi sẽ thử chơi các ghi chú tiếp theo. Điều này sẽ rất thú vị bởi vì, mặc dù tôi tin rằng Arduino Uno có 3 bộ định thời bên trong, mỗi lần chỉ có thể phát một ghi chú bằng cách sử dụng lệnh tích hợp sẵn. Có một chức năng thư viện bên ngoài sử dụng tất cả các bộ định thời phần cứng (sẽ làm xáo trộn nối tiếp, nhưng dù sao thì nó cũng không cần thiết ở giai đoạn đó.) Ngoài ra, tôi có thể thử tạo ra các âm báo trong softare.

Nếu tôi thành công với điều đó, tôi sẽ đánh nó xuống nhưng tôi không nghĩ nó sẽ là người chiến thắng chung cuộc.

Mã bị đánh cắp

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

Đầu ra mẫu Khoảng cách giữa các dòng văn bản càng thấp, cái này trông càng đẹp. Do đó, nó trông thật tuyệt khi tôi thực sự chỉnh sửa bài đăng, nhưng thật kinh khủng trong hộp màu xám sau khi đăng. Thay vào đó, tôi đã đăng một ảnh chụp màn hình của màn hình nối tiếp Arduino có khoảng cách dòng trung gian (và do đó chất lượng hiển thị.)

Python3 - 315 char

Lần đầu tiên ở codegolf! Chỉ hỗ trợ các hợp âm nhỏ, chính, giảm dần và tăng cường ngay bây giờ.

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 là 1 char) -150 (âm thanh) -150 (bàn phím) = 206

Để chơi âm thanh, nó sử dụng pygame.midi. Lưu ý rằng pygame.midi.get_default_output_id()phương pháp này không hoạt động tốt. Vì vậy, bạn có thể thử thay đổi dòng o=Output(get_default_output_id())để o=Output(1), o=Output(2)vv Thông thường các giá trị chính xác là giữa 0 và 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))

Các kết quả

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

Độc lập, đọc từ đầu vào giao diện điều khiển. Nếu bạn cần stdin, thay đổi cuối cùng 1thành a 3. Yêu cầu không có tiền thưởng, và chỉ bao gồm các bộ ba.

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

Thay vì một ghi chú sắc nét, ví dụ C#bạn phải sử dụng tên phẳng tương đương Db. (Sửa lỗi này sẽ làm tăng mã hơn một chút.) Bốn loại hợp âm là 0để giảm dần, mcho nhỏ, Mcho chính và +tăng cường.

Logic như sau: chúng tôi sử dụng ký tự cuối cùng để thêm phần bù vào gốc 0-3-6, chọn loại thứ ba và thứ năm. Trong khi đó, chúng tôi sử dụng ghi chú để tìm vị trí trong thang đo để kéo ghi chú từ đó. Cả ;:hai làm cho ghi chú tương thích với việc lập chỉ mục vào thang đo khi bắt đầu và sau đó (bằng cách &.) biến các ghi chú đã kéo thành một chuỗi phân tách không gian.

Ví dụ sử dụng:

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

Đây là mã golf đầu tiên của tôi. Tôi nghĩ rằng nó có thể ngắn hơn, nhưng tôi không thể tìm thấy bất kỳ byte nào để lưu.

Hỗ trợ chính, mcho nhỏ, 0giảm dần, +tăng hoặc thêm 37 byte cho dim, aug.

Con trăn ( 143 134 ký tự)

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

Thử thách chơi gôn đầu tiên của tôi :), không biết có thể xóa thêm vài byte nữa không.
Ký hiệu được sử dụng ở đây là * aug / + maj /, min / - dim
Tôi xứng đáng được điểm thưởng vì có hằng số 42 trong mã: P

Con trăn 3: 257 - 150 = 107

Chỉ cần 25 ký tự quá lâu để đánh bại giải pháp J! Ồ tốt Có một số ý tưởng gọn gàng ở đây, tôi nghĩ.

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

Đầu vào giống như các ví dụ, mặc dù bạn phải sử dụng tên sắc nét thay vì tên phẳng. (ví dụ: Gb phải là F #)

Đầu ra là một quãng tám của một cây đàn piano, nhìn từ phía trên và bên trái, với các tên ghi chú được đặt chồng lên nhau. Nên chỉ là một sự kéo dài nhỏ bé của trí tưởng tượng.

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

Scala 537 ký tự - 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 ký tự

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

Các kết quả

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