Memasukkan

Simbol dari setiap akord triadik (lihat http://en.wikipedia.org/wiki/Chord_(music)#Triads ).

Keluaran

Nada-nada itu merupakan akor yang diberikan.

Contohnya

Input: AM Keluaran:A C# E

Input: C#m Keluaran:C# E G#

Input: Db+ Keluaran:C# F A

Input: C0 Keluaran:C D# F#

Bonus

-50 jika Anda juga bisa menangani akord ketujuh

-150 untuk benar-benar memainkan suara akord

-150 untuk menggunakan karakter yang dapat dicetak untuk menunjukkan cara memainkan akor pada piano; contoh untuk AM:

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

-100 untuk menggunakan karakter yang dapat dicetak untuk menunjukkan cara memainkan chord pada gitar; contoh untuk AM:

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

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

Aturan

• Hasilnya harus berupa program atau skrip baris perintah.

• Input dan output dapat dalam bentuk apa saja, asalkan mengikuti standar notasi musik.

• Representasi gitar atau piano dianggap valid jika dan hanya jika itu berisi tiga (triadik) atau empat (ketujuh) catatan yang diperlukan dan tidak ada yang lain. Catatan yang sama dapat ditampilkan beberapa kali dalam chord.

• Pustaka eksternal tidak diperbolehkan, kecuali untuk generasi suara (dalam hal ini #include, import... arahan tidak ditambahkan ke jumlah karakter).

• Ini golf kode, kode terpendek menang!

Sedikit teori musik ...

Dalam musik nada barat modern, setiap oktaf dibuat dari dua belas not berturut-turut, sering dicatat:

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

Atau:

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

Dalam sistem ini, kami menganggap bahwa dua not berurutan (misalnya Adan A#, atau Edan F) dipisahkan oleh satu semiton. Juga, catatan-catatan itu semacam "perulangan": yang segera menyusul G#adalah A.

Sebuah akor dibentuk oleh beberapa (2, 3, 4, kadang-kadang lebih) catatan bahwa "terdengar bagus bersama". Misalnya, akord triadik berisi tiga not yang berbeda, dan akord ketujuh berisi empat not yang berbeda.

Mari kita mendefinisikan empat akord triadik sebagai:

• Triad utama : berisi akar akor (dalam pertanyaan ini, catatan diberikan sebagai input), sepertiga utama untuk root (4 semitones lebih tinggi dari root), dan kelima sempurna untuk root (7 semitones lebih tinggi dari root ); ini bisa dilambangkan 0-4-7

• Triad kecil , dilambangkan 0-3-7

• Triad augmented , disimbolkan 0-4-8

• Triad berkurang , disimbolkan 0-3-6

Jadi misalnya, jika Anda ingin membuat C triad utama , mencatat C, CM, Cmaj, Anda akan membutuhkan tiga mencatat:

• 0: root , dalam hal ini aC
• 4: sepertiga minor , 4 semiton lebih tinggi dari root; itu sebuahE
• 7: kelima sempurna , 7 semiton lebih tinggi dari root: aG

Ini adalah apa yang 0-4-7, 0-3-7, 0-4-8dan 0-3-6notasi yang digunakan di atas rata-rata! Untuk akord ketujuh, gunakan pola berikut:

Itu untuk hari ini! Sekarang, buat saya takjub dengan kode luar biasa ... Jika Anda memiliki pertanyaan, tambahkan beberapa komentar di bawah.

BBC BASIC

Emulator di bbcbasic.co.uk

Rev 1, 340 - 150 keyboard - 150 bermain = 40

Ini versi terbaru, di mana saya berhasil memasukkan perangkat tambahan berikut sambil memperpanjang hanya dengan beberapa karakter.

Input dapat diedit dengan nyaman di layar sebelum menekan kembali (saya menggunakan GET $ sebelum untuk mendapatkan penekanan tombol tunggal, karena BBC Basic tidak membiarkan Anda mengakses satu karakter dari string seolah-olah string itu array. Sekarang saya menggunakan yang agak fungsi MID $ besar untuk mengekstraksi string satu karakter dari dalam string.

Kedua sisi keyboard ditampilkan serta garis penuh antara E dan F.

Untuk mengimbangi karakter yang ditambahkan oleh di atas, saya menata ulang program untuk menghilangkan pernyataan cetak yang tidak perlu, dan menghapus beberapa ruang putih yang pada pandangan pertama sepertinya tidak bisa dihapus. DI BBC Basic semua fungsi bawaan adalah kata-kata yang dicadangkan, dan Anda dapat meletakkan nama variabel tepat di depannya tanpa ada spasi di antaranya. Nama variabel tidak diizinkan untuk memulai dengan kata yang dipesan. Untuk membuat program kurang membingungkan untuk dibaca, saya mengubah semua variabel menjadi huruf kecil.

Meskipun presentasi terlihat jauh lebih baik, program berikut ini sebenarnya sudah sepenuhnya golf. (Lihat koreksi di bawah.) Umumnya baris baru dan titik dua dapat dipertukarkan, kecuali ketika pernyataan IF digunakan. Dalam hal ini semua pernyataan pada baris yang sama (dipisahkan oleh titik dua) dengan dijalankan secara kondisional. Pernyataan setelah baris baru tidak dikendalikan oleh IF dan akan selalu dieksekusi.

Program rev 1 340 karakter

  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

KOREKSI: BBC BASIC dari RT Russell memungkinkan Anda untuk menghilangkan beberapa baris baru dan titik dua, sehingga totalnya menjadi 327, lihat di bawah. Itu juga menandai kata kunci menjadi karakter tunggal sebelum menyimpan, membawanya ke 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

Output rev 1

Rev 0, 337 - 150 keyboard - 150 bermain = 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

Ini adalah konsep yang mirip dengan jawaban Arduino saya, tetapi saya selalu tahu saya bisa mengalahkan jumlah byte itu dengan dasar BBC. Hanya mengenali benda tajam, tetapi menganggap B # tidak valid, Anda harus meletakkan C. Ini bisa diperbaiki jika itu benar-benar dianggap penting.

Saya meninggalkan ide gitar dan berkonsentrasi pada peningkatan keyboard. Sekarang berjalan dari C ke B, dan saya telah menambahkan di sisi kiri keyboard dan garis antara E dan F. Itu harganya 28 karakter. Sisi kanan tidak akan lebih.

Inilah beberapa contoh output, akor A # yang berkurang (yang memiliki suara yang cukup aneh dalam inversi ini) dan akord B besar. Perhatikan bahwa input tidak digaungkan ke layar. Sesuai jawaban Arduino, putar layar berlawanan arah jarum jam untuk melihat.

Versi tidak disatukan

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

Seperti yang Anda tahu, saya tidak mencoba bermain golf sama sekali. Saya seorang pecandu musik, dan kesayangan saya adalah ketika orang-orang menulis sesuatu menggunakan enharmonics yang salah (mis. Mengatakan bahwa akor C yang berkurang adalah CD # F # daripada C Eb Gb), jadi saya menulis program ini yang mendapatkan enharmonics kanan. Itu melakukannya dengan mewakili setiap nada sebagai jumlah perlima sempurna di atas F.

Untuk apa nilainya, jika Anda ingin membedakan enharmonics, setiap interval musik dapat diwakili dengan baik dalam program komputer sebagai sejumlah perlima sempurna dan sejumlah oktaf. Sebagai tambahan keempat, misalnya, adalah 6 perlima sempurna dan -3 oktaf, dan kelima berkurang adalah -6 perlima sempurna dan 4 oktaf.

Haskell, 441 karakter

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

Beberapa contoh doa:

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

Input / output dikirim ke / diterima dari Arduino melalui port COM. Seorang pengguna dapat berinteraksi dengan ini melalui terminal, atau monitor serial di Arduino IDE. Seperti yang mungkin sudah Anda tebak dari platform pilihan saya, saya berencana untuk memasukkan permainan akor yang sebenarnya (meskipun saya belum melakukannya.)

Saya telah menangani bonus keyboard dengan sukses, dan saya telah mencoba untuk menangani gitar, dengan keberhasilan yang terbatas.

Kotak akor masuk pada 130 byte, yang terlalu lama untuk sia-sia. Karena itu saya telah mencoba cara lain, hanya mencetak nomor fret Tab style. Saat ini 81 byte untuk bonus 81-100 = -19. Jika pendekatan ini dianggap valid, saya dapat mencoba dan memperbaikinya.

Akor yang digunakan adalah semua bentuk tipe-D dengan akar pada string ke-2, kelima pada string ke-3, dan ketiga pada string ke-1 dan ke-4. Senar ke-5 dan ke-6 tidak digunakan dan saya menandainya dengan tanda X di sebelah kanan kotak akor (sebelah kiri akan lebih biasa, tetapi contoh yang ditandai di sebelah kanan dapat ditemukan.)

Karena program menganggap F sebagai not terendah (untuk kompatibilitas dengan keyboard sambil menghindari fret yang terlalu tinggi dengan bentuk chord ini) chord tertinggi adalah E (dengan root pada fret ke-17.) Lihat contoh output.

Keyboard lebih sukses dalam hal bermain golf. Ini berjalan dari FE daripada CB untuk alasan yang dijelaskan di atas. Ini harus dilihat dengan memutar layar 90% berlawanan arah jarum jam, ketika Anda dapat dengan jelas melihat garis besar catatan hitam, dan demarkasi antara catatan putih dengan ---. Garis antara B dan C dapat diperpanjang dengan beberapa ____untuk beberapa byte lagi.

Saya akan mencoba memainkan not selanjutnya. Ini akan menarik karena, walaupun saya percaya Arduino Uno memiliki 3 timer internal, hanya satu not pada satu waktu dapat dimainkan menggunakan perintah nada bawaan. Ada fungsi perpustakaan eksternal yang menggunakan semua pengatur waktu perangkat keras (yang akan mengacaukan serial, tetapi toh itu tidak diperlukan pada tahap itu.) Atau saya dapat mencoba menghasilkan nada dalam softare.

Jika saya berhasil dengan itu, saya akan menurunkannya tetapi saya tidak berpikir itu akan menjadi pemenang secara keseluruhan.

Kode tidak dikunci

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

Output sampel Semakin rendah jarak antar baris teks, semakin baik tampilannya. Oleh karena itu terlihat hebat ketika saya benar-benar mengedit posting, tetapi mengerikan di kotak abu-abu setelah posting. Alih-alih, saya telah memasang tangkapan layar monitor serial Arduino yang merupakan penspasian garis menengah (dan karenanya kualitas tampilan.)

Python3 - 315 char

Pertama kali dalam codegolf! Hanya mendukung akord minor, mayor, diperkecil, dan ditambah saat ini.

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 as 1 char) -150 (sound) -150 (keyboard) = 206

Untuk memutar suara, ia menggunakan pygame.midi. Perhatikan bahwa pygame.midi.get_default_output_id()metode ini tidak berfungsi dengan baik. Jadi Anda dapat mencoba mengubah baris o=Output(get_default_output_id())untuk o=Output(1), o=Output(2), dll Biasanya nilai yang benar adalah antara 0 dan 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))

Hasil

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

Mandiri, dibaca dari input konsol. Jika Anda memerlukan stdin, ubah final 1menjadi a 3. Tidak mengklaim bonus, dan hanya mencakup 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

Alih-alih nada tajam misalnya C#Anda harus menggunakan nama datar yang setara Db. (Memperbaiki untuk ini akan mengembang kode lebih dari sedikit.) Keempat jenis akor adalah 0untuk mengurangi, muntuk minor, Muntuk mayor, dan +untuk ditambah.

Logikanya adalah sebagai berikut: kami menggunakan karakter terakhir untuk menambahkan offset ke basis 0-3-6, yang memilih jenis ketiga dan kelima. Sementara itu, kami menggunakan catatan untuk menemukan di mana dalam skala untuk menarik catatan. The ;:baik membuat catatan kompatibel dengan pengindeksan ke skala di awal, dan kemudian (oleh &.) ternyata catatan ditarik ke ruang string dipisahkan.

Contoh penggunaan:

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

Ini golf kode pertamaku. Saya pikir ini bisa lebih pendek, tetapi saya tidak dapat menemukan byte untuk disimpan.

Mendukung besar, muntuk minor, 0untuk berkurang, +untuk ditambah, atau 37 lebih byte untuk dim, aug.

Python ( 143 134 karakter)

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

Tantangan golf pertama saya :), tidak tahu apakah beberapa byte lagi dapat dicukur.
Notasi yang digunakan di sini adalah * aug / + maj /, min / - redup
Saya layak mendapat poin bonus karena memiliki konstanta 42 dalam kode: P

Python 3: 257 - 150 = 107

Hanya 25 karakter terlalu lama untuk mengalahkan solusi J! Baiklah. Ada beberapa ide bagus di sini, saya pikir.

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

Input seperti contoh, meskipun Anda harus menggunakan nama yang tajam dan bukan nama datar. (mis. Gb harus F #)

Keluaran adalah satu oktaf piano, terlihat dari atas dan ke kiri, dengan nama nada ditumpangkan. Seharusnya hanya hamparan kecil imajinasi.

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

Scala 537 karakter - 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 karakter

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

Hasil

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