Giriş

Üçlü bir akorun simgesi (bkz. Http://en.wikipedia.org/wiki/Chord_(music)#Triads ).

Çıktı

Verilen akoru oluşturan notlar.

Örnekler

Giriş: AM Çıkış:A C# E

Giriş: C#m Çıkış:C# E G#

Giriş: Db+ Çıkış:C# F A

Giriş: C0 Çıkış:C D# F#

Bonuslar

-50 Eğer yedinci akorlarla da başa çıkabilirseniz

Akorun sesini gerçekten çaldığı için -150

Akorun bir piyanoda nasıl çalınacağını göstermek için basılabilir karakterlerin kullanılması için -150 ; örnek AM:

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

-100 akorun bir gitarda çalınmasını göstermek için basılabilir karakterleri kullanmak için; örnek AM:

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

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

kurallar

• Sonuç, bir komut satırı programı veya komut dosyası olmalıdır.

• Giriş ve çıkış, müzik notasyon standardını takip ettiği sürece herhangi bir biçimde olabilir.

• Bir gitar veya piyano gösterimi, yalnızca üç (üçlü) veya dört (yedinci) gerekli notayı ve başka hiçbir şeyi içermesi halinde geçerli sayılır. Aynı nota akorda birkaç kez bulunabilir.

• Ses kütüphanesi dışında harici kütüphanelere izin verilmez (bu durumda #include, import... direktifleri karakter sayısına eklenmez).

• Bu kod golf, en kısa kod kazanıyor!

Biraz müzik teorisi ...

Modern Batı ton müziğinde, her oktav, sık sık not edilen, arka arkaya on iki notadan oluşur:

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

Veya:

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

Bu sistemde, söz konusu iki ardışık notlar (örn düşünün Ave A#ya Eve F) bir yarım ton ile ayrılır. Ayrıca, notlar bir nevi "ilmek" tir: hemen takip eden G#şey A.

Bir akor, "birlikte iyi geldiğini" belirten birkaç (2, 3, 4, bazen daha fazla) notadan oluşur. Örneğin, üçlü akorlar üç farklı nota içerir ve yedinci akorlar dört farklı nota içerir.

Dört üçlü akoru şöyle tanımlayalım :

• Binbaşı triad : akorun kökünü (bu soruda, girdi olarak verilen notu), kökün üçüncüsü (kökten 4 yarı ton) ve kök için mükemmel beşinci (kökten 7 yarı ton) içerir ); bu 0-4-7 sembolize edilebilir

• Küçük triad , 0-3-7 sembolize

• Artırılmış triad , 0-4-8 sembolize

• Azaltılmış triad , 0-3-6 sembolize

Bir yapmak istiyorsanız Yani örneğin, C Majör beşli kaydetti C, CM, Cmaj, üç kaydetti gerekir:

• 0: Kök , bu durumda birC
• 4: küçük üçüncü , kökten 4 yarı ton daha yüksek; bu birE
• 7: Mükemmel beşinci , kökünden daha yüksek 7 yarı ton: aG

Bu nedir 0-4-7, 0-3-7, 0-4-8ve 0-3-6gösterimler ortalama yukarıda kullanılan! Yedinci akorlar için aşağıdaki modeli kullanın:

Bugünlük bu kadar! Şimdi şaşırtıcı kodla beni şaşırtın ... Herhangi bir sorunuz varsa, aşağıya bazı yorumlar ekleyin.

BBC TEMEL

Bbcbasic.co.uk şirketinde Emulator

Rev 1, 340 - 150 klavye - 150 çalma = 40

İşte sadece birkaç karakter daha uzatarak aşağıdaki gelişmeleri dahil etmeyi başardığım en son sürüm.

Girdi basmadan önce ekranda rahatça düzenlenebilir (tek tuşlara basmadan önce GET $ kullanmıştım, çünkü BBC Basic diziden tek bir karaktere erişmenize izin vermiyor çünkü dize dizideydi. bulky MID $ işlevi, bir karakter dizesini dize içinden çıkarmak için kullanılır.

Klavyenin her iki tarafı da E ve F arasındaki tam çizgiyi gösterir.

Yukarıdakilerin eklediği karakterleri telafi etmek için, gereksiz baskı ifadelerini ortadan kaldırmak için programı yeniden düzenledim ve ilk bakışta silinememiş gibi görünen beyaz boşlukları sildim. BBC Basic'te tüm yerleşik fonksiyonlar ayrılmış sözcüklerdir ve aralarında boşluk kalmadan hemen önce değişken bir ad girebilirsiniz. Değişken isimlerinin ayrılmış bir kelimeyle başlaması yasaktır. Programı okumak için daha az kafa karıştırıcı hale getirmek için tüm değişkenleri küçük harf olarak değiştirdim.

Sunum çok daha iyi görünse de, takip eden program aslında tamamen golf oynamaktadır. (Aşağıdaki düzeltmeye bakın.) Genel olarak yeni satırlar ve iki nokta üst üste, bir IF ifadesinin kullanıldığı durumlar dışında değiştirilebilir. Bu durumda, aynı satırdaki (iki nokta üst üste) tüm ifadeler koşullu olarak yürütülür. Newline'dan sonraki ifadeler, IF tarafından kontrol edilmez ve daima uygulanır.

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

DÜZELTME: RT Russell'ın Windows için BBC BASIC'i, bazı yeni hatları ve kolonları ortadan kaldırarak toplamı 327'ye düşürmenizi sağlar, aşağıya bakınız. Ayrıca, kaydetmeden önce anahtar kelimeleri tek karakterlerde gösterir ve 279'a indirir.

  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

Çıkış rev 1

Rev 0, 337 - 150 klavye - 150 çalma = 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

Bu Arduino cevabına benzer bir kavram, ancak her zaman bu bayt sayısını BBC basic ile yenebileceğimi biliyordum. Sadece keskinleri tanır, fakat B # 'nın geçersiz olduğunu düşünür, C' yi koymalısınız. Gerçekten önemli sayılırsa bu düzeltilebilir.

Gitar fikrini bıraktım ve klavyeyi geliştirmeye konsantre oldum. Şimdi C'den B'ye çalışıyor ve klavyenin sol tarafına ekledim ve E ile F arasındaki çizgiyi ekledim. Bu 28 karaktere mal oluyor. Sağ taraf daha fazla olmazdı.

İşte bazı örnek çıktılar, bir A # azalmış akor (bu inversiyonda oldukça garip bir sese sahip) ve bir B ana akor. Girişin ekrana yansıtılmadığını unutmayın. Arduino'nun cevabına göre, görüntülemek için ekranı saat yönünün tersine çevirin.

Ungolfed versiyonu

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

Anlatabileceğiniz gibi, bunu hiç golf oynamaya çalışmadım. Ben bir müzik geekiyim ve bir hayvan kuyularım, insanların yanlış enharmonik kullanarak bir şeyler yazdıkları zamandır (örneğin, C azalmış bir akorun C Eb Gb yerine CD # F # olduğunu söyler), bu yüzden enharmoniyi alan bu programı yazdım. sağ. Bunu, her notu F'nin üzerindeki kusursuz beşinci sayı olarak temsil ederek yapar.

Ne olursa olsun, enharmonikleri ayırt etmek istiyorsanız, herhangi bir müzikal aralık bir bilgisayar programında mükemmel bir beşinci ve birkaç oktav olarak gösterilebilir. Örneğin, artırılmış bir dördüncü 6 mükemmel beşinci ve -3 oktav, azalan beşinci ise -6 mükemmel beşinci ve 4 oktav.

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

Bazı örnek çağrılar:

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

Giriş / çıkış, Arduino'dan bir COM portu üzerinden gönderilir / alınır. Bir kullanıcı bununla bir terminal veya Arduino IDE'deki seri monitör aracılığıyla etkileşime girebilir. Benim platform seçimimden tahmin edebileceğiniz gibi, akorun gerçek çalınmasını dahil etmeyi planlıyorum (henüz yapmamış olmama rağmen).

Klavye bonusunu başarıyla ele aldım ve sınırlı bir başarı ile gitarla uğraşmaya çalıştım.

Akor kutusu 130 baytta geliyor ve buna değmeyecek kadar uzun. Bu yüzden başka bir yol denedim, sadece fret sayıları Tab stilini yazdırarak. Şu anda 81-100 = -19 bonus için 81 bayttır. Eğer bu yaklaşım geçerli sayılırsa, onu deneyip iyileştirebilirim.

Kullanılan akorlar, tüm kökleri 2. dize, 3. diziye beşinci ve 1. ve 4. dizilere üçüncü olan D tipi şekillerdir. 5. ve 6. diziler kullanılmaz ve bunu akor kutusunun sağında X'lerle işaretlerim (sol daha normal olurdu, ama sağda işaretli örnekler bulunabilir.)

Program, F'nin en düşük nota olduğunu düşündüğü için (klavye ile uyumluluk için bu akor şekliyle aşırı yüksek perdelerden kaçınırken) en yüksek akor, bir E'dir (17. perdede kök ile).

Klavye, golf açısından daha başarılı. Yukarıda açıklanan nedenlerden dolayı CB'den değil FE'den çalışır. Ekranı% 90 saat yönünün tersine çevirerek, siyah notaların ana hatlarını ve beyaz notalar arasındaki mesafeyi net bir şekilde görebiliyorsanız görüntülenmelidir ---. B ve C arasındaki çizgi ____, birkaç bayt için uzatılabilir .

Bir sonraki notaları çalmayı deneyeceğim. Bu ilginç olacak, çünkü Arduino Uno'nun 3 dahili zamanlayıcıya sahip olduğunu düşünmeme rağmen, yerleşik ton komutunu kullanarak bir seferde yalnızca bir nota çalınabilir. Tüm donanım zamanlayıcıları kullanan (seriyi bozacak, ancak yine de bu aşamada gerekli olmayacak) harici bir kütüphane işlevi vardır. Alternatif olarak, tonları softare olarak üretmeye çalışabilirim.

Eğer bu konuda başarılı olursam, golf oynayacağım ama genel galibi olacağını sanmıyorum.

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

Örnek çıktı Metin satırları arasındaki boşluk ne kadar düşük olursa, bu o kadar iyi görünür. Bu nedenle, gönderiyi düzenlerken harika görünüyor, ancak gönderdikten sonra gri kutu içinde korkunç. Bunun yerine, Arduino seri monitörünün ara satır aralığı (ve dolayısıyla görüntü kalitesi) olan bir ekran görüntüsünü gönderdim.

Python3 - 315 karakter

Codegolf'ta ilk defa! Şu anda yalnızca küçük, büyük, azalan ve artırılmış akorları destekliyor.

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 karakter olarak unicode) -150 (ses) -150 (klavye) = 206

Ses çalmak için kullanır pygame.midi. pygame.midi.get_default_output_id()Yöntemin çok iyi çalışmadığını unutmayın . Hat değiştirmeden deneyebilirsiniz Yani o=Output(get_default_output_id())üzere o=Output(1), o=Output(2)vb Genellikle doğru değeri 0 ile 5 arasında olduğunu.

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

Sonuçlar

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 karakter

Kendi kendine yeten, konsol girişinden okur. Stdin'e ihtiyacınız varsa, finali 1a olarak değiştirin 3. Bonus istemiyor ve sadece triadları kapsıyor.

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

Keskin bir not yerine, örneğin C#eşdeğer düz ismi kullanmanız gerekir Db. (Bunun düzeltilmesi, kodu bir miktardan daha fazla oranda şişirir.) Dört tür akor, 0azalan, mküçük, Mbüyük ve +artmış olanlar içindir.

Mantık şöyledir: Biz üçüncü ve beşinci türlerini seçen 0-3-6 tabanına ofset eklemek için son karakteri kullanırız. Bu arada notu, ölçeğin notları nereden çekeceğini bulmak için kullanırız. Her ;:ikisi de notu başlangıçta ölçeğe endeksleme ile uyumlu hale getirir ve daha sonra (by &.), çekilen notları boşlukla ayrılmış bir dizgeye dönüştürür.

Örnek kullanım:

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

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

Bu benim ilk golf kodum. Daha kısa olabileceğini düşünüyorum, fakat tasarruf edilecek bayt bulamıyorum.

Destekler, majör m, minör için 0azalmış için, +amaçlı güçlendirme veya daha fazla 37 için bayt 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]) 

İlk golf mücadelem :), daha fazla baytın tıraş edilip edilmeyeceğini bilmiyorum.
Burada kullanılan notasyon * aug / + maj /, min / - dim
Kodun 42 nolu sabitine sahip olmak için bir bonus puanını hakediyorum: P

Python 3: 257 - 150 = 107

J çözümünü yenmek için sadece 25 karakter çok uzun! Oh iyi. Bence bazı güzel fikirler var.

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

Girdi örnekler gibidir, ancak düz isimler yerine keskin isimler kullanmanız gerekir. (örneğin, Gb F # olmalıdır)

Çıktı, notaları üst üste gelecek şekilde yukarıdan ve soldan görülen, piyanonun tek bir oktavıdır. Sadece hayal gücünün küçük bir parçası olmalı.

$ 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

Sonuçlar

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