อินพุต

สัญลักษณ์ของคอร์ด triadic ใด ๆ (ดู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, และอื่น ๆ อีกมากมาย) บันทึกว่า "ฟังดูดีด้วยกัน" ตัวอย่างเช่นคอร์ด triadicมีสามโน้ตที่แตกต่างกันและคอร์ดที่เจ็ดมีสี่โน้ตที่แตกต่างกัน

มานิยามคอร์ด triadicสี่อันกัน:

• พันตรีสาม : มีรากของเสียงประสาน (ในคำถามนี้โน้ตที่ให้เป็นอินพุต) หลักสามสำหรับราก (4 semitones สูงกว่าราก) และที่ห้าที่สมบูรณ์แบบสำหรับราก (7 semitones สูงกว่าราก ); สิ่งนี้สามารถเป็นสัญลักษณ์ 0-4-7

• ผู้เยาว์กลุ่มที่สามมีสัญลักษณ์ 0-3-7

• เพิ่มสามกลุ่มสัญลักษณ์ 0-4-8

• ลดน้อยลงทั้งสามเป็นสัญลักษณ์ 0-3-6

ดังนั้นสำหรับตัวอย่างเช่นถ้าคุณต้องการที่จะทำให้หลักสามซีตั้งข้อสังเกตC, CM, Cmajคุณจะต้องสามสังเกต:

• 0: รากในกรณีนี้C
• 4: ผู้เยาว์ที่สาม , 4 semitones สูงกว่าราก นั่นคือE
• 7: ห้าสมบูรณ์ 7 semitones สูงกว่าราก:G

นี่คือสิ่งที่0-4-7, 0-3-7, 0-4-8และ0-3-6สัญลักษณ์ที่ใช้เหนือ! สำหรับคอร์ดที่เจ็ดให้ใช้รูปแบบต่อไปนี้:

แค่นี้แหละวันนี้! ตอนนี้แปลกใจฉันด้วยรหัสที่น่าอัศจรรย์ ... หากคุณมีคำถามใด ๆ เพิ่มความคิดเห็นด้านล่าง

บีบีซีขั้นพื้นฐาน

Emulator ที่ bbcbasic.co.uk

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

นี่คือเวอร์ชั่นล่าสุดที่ฉันจัดการเพื่อรวมการปรับปรุงต่อไปนี้ในขณะที่เพิ่มความยาวโดยตัวละครอีกไม่กี่ตัว

อินพุตสามารถแก้ไขได้อย่างสะดวกสบายบนหน้าจอก่อนกด return (ฉันใช้ GET $ ก่อนเพื่อรับ keypresses เดี่ยวเพราะ BBC Basic ไม่อนุญาตให้คุณเข้าถึงอักขระเดี่ยวจากสตริงราวกับว่าสตริงเป็นอาร์เรย์ตอนนี้ฉันใช้ ฟังก์ชัน MID $ ขนาดใหญ่เพื่อแยกสตริงของอักขระหนึ่งตัวจากภายในสตริง

ทั้งสองด้านของแป้นพิมพ์ที่แสดงเช่นเดียวกับเส้นเต็มระหว่าง E และ F

เพื่อชดเชยอักขระที่เพิ่มไว้ข้างต้นฉันได้จัดเรียงโปรแกรมใหม่เพื่อกำจัดข้อความสั่งที่ไม่จำเป็นออกและลบพื้นที่สีขาวซึ่งแรกเห็นว่าไม่สามารถลบได้ ใน BBC Basic ฟังก์ชันทั้งหมดที่มีในตัวเป็นคำสงวนและคุณสามารถใส่ชื่อตัวแปรไว้ข้างหน้าโดยไม่ต้องเว้นวรรค ชื่อตัวแปรไม่ได้รับอนุญาตให้เริ่มต้นด้วยคำที่สงวนไว้ เพื่อให้โปรแกรมสับสนน้อยลงในการอ่านฉันเปลี่ยนตัวแปรทั้งหมดเป็นตัวพิมพ์เล็ก

แม้ว่างานนำเสนอจะดูดีขึ้นมาก แต่โปรแกรมต่อไปนี้ได้รับการตีกอล์ฟอย่างสมบูรณ์แล้ว (ดูการแก้ไขด้านล่าง) โดยทั่วไปบรรทัดใหม่และโคลอนสามารถใช้แทนกันได้ยกเว้นเมื่อใช้คำสั่ง IF ในกรณีนั้นคำสั่งทั้งหมดในบรรทัดเดียวกัน (คั่นด้วยโคลอน) ที่มีการดำเนินการตามเงื่อนไข งบหลังการขึ้นบรรทัดใหม่ไม่ได้ถูกควบคุมโดย IF และจะถูกดำเนินการเสมอ

โปรแกรม rev 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

เอาต์พุต rev 1

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

นี่เป็นแนวคิดที่คล้ายกับคำตอบ Arduino ของฉัน แต่ฉันรู้อยู่เสมอว่าฉันสามารถเอาชนะจำนวนไบต์นั้นด้วยพื้นฐานบีบีซี รับรู้เฉพาะชาร์ปเท่านั้น แต่ถือว่า B # ไม่ถูกต้องคุณต้องใส่ C ซึ่งสามารถแก้ไขได้หากถือว่าสำคัญจริงๆ

ฉันเลิกคิดเรื่องกีตาร์และจดจ่อกับการปรับปรุงแป้นพิมพ์ ตอนนี้ทำงานจาก C ถึง B และฉันได้เพิ่มที่ด้านซ้ายของแป้นพิมพ์และเส้นแบ่งระหว่าง E และ F นั่นมีค่า 28 ตัวอักษร ด้านขวาจะไม่มากไปกว่านี้

นี่คือตัวอย่างเอาต์พุต, คอร์ด A # ลดลง (ซึ่งมีเสียงค่อนข้างประหลาดในการผกผันนี้) และคอร์ดหลักของ 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) ดังนั้นฉันจึงเขียนโปรแกรมนี้ ขวา. มันเป็นเช่นนั้นโดยการเป็นตัวแทนของแต่ละบันทึกเป็นจำนวนที่สมบูรณ์แบบที่ห้าข้างต้นเอฟ

สำหรับสิ่งที่คุ้มค่าถ้าคุณต้องการแยกความแตกต่างของระบบเพิ่มเสียงดนตรีช่วงเวลาใด ๆ ที่สามารถแสดงได้ดีในโปรแกรมคอมพิวเตอร์เป็นจำนวนหนึ่งในห้าที่สมบูรณ์แบบและจำนวนอ็อกเทฟ ตัวอย่างเช่นการเติมที่สี่คือ 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

อินพุต / เอาต์พุตถูกส่งไป / รับจาก Arduino ผ่านพอร์ต COM ผู้ใช้สามารถโต้ตอบกับสิ่งนี้ผ่านทางเทอร์มินัลหรือมอนิเตอร์อนุกรมใน Arduino IDE เนื่องจากคุณอาจเดาได้จากแพลตฟอร์มที่ฉันเลือกฉันกำลังวางแผนที่จะรวมการเล่นคอร์ดจริง (แต่ฉันยังไม่ได้ทำ)

ฉันได้จัดการโบนัสคีย์บอร์ดอย่างประสบความสำเร็จและฉันพยายามเล่นกีตาร์ด้วยความสำเร็จที่ จำกัด

กล่องเสียงประสานอยู่ที่ 130 ไบต์ซึ่งยาวเกินกว่าจะคุ้มค่า ดังนั้นฉันจึงได้ลองวิธีอื่นเพียงแค่พิมพ์รูปแบบตัวเลขแท็บหงุดหงิด ปัจจุบันนี้คือ 81 ไบต์สำหรับโบนัส 81-100 = -19 หากวิธีนี้ถือว่าใช้ได้ฉันสามารถลองและปรับปรุงได้

คอร์ดที่ใช้เป็นรูปร่าง D-type ทั้งหมดที่มีรูทบนสตริงที่ 2, ที่ห้าในสตริงที่ 3 และที่สามในสตริงที่ 1 และ 4 ไม่ได้ใช้สตริงที่ 5 และ 6 และฉันทำเครื่องหมายด้วย X ที่ด้านขวาของกล่องเสียงประสาน (ด้านซ้ายจะเป็นปกติมากกว่า แต่ตัวอย่างที่ทำเครื่องหมายไว้ที่ด้านขวาสามารถพบได้)

เนื่องจากโปรแกรมถือว่า F เป็นโน้ตต่ำสุด (สำหรับความเข้ากันได้กับแป้นพิมพ์ในขณะที่หลีกเลี่ยงเฟร็ตที่สูงเกินไปด้วยรูปร่างที่มีคอร์ดนี้) คอร์ดที่สูงที่สุดคือ E (โดยมีรูทบนเฟร็ตที่ 17) ดูตัวอย่างเอาต์พุต

แป้นพิมพ์ประสบความสำเร็จมากขึ้นในแง่ของการเล่นกอล์ฟ มันทำงานจาก FE มากกว่า CB ด้วยเหตุผลที่อธิบายไว้ข้างต้น มันต้องดูด้วยการเปลี่ยนหน้าจอ 90% ---ทวนเข็มนาฬิกาเมื่อคุณสามารถเห็นได้ชัดเจนเค้าร่างของบันทึกสีดำและแบ่งเขตระหว่างโน้ตสีขาวด้วย เส้นแบ่งระหว่าง B และ 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 อักขระ

ครั้งแรกใน codegolf! รองรับเฉพาะคอร์ดรอง, เมเจอร์, ลดลงและเติมเท่านั้น

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 อักขระ) -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 ตัวอักษร

อยู่ในตัวเองอ่านจากอินพุตคอนโซล หากคุณต้องการ stdin เปลี่ยนขั้นตอนสุดท้าย13กับ ไม่มีการอ้างสิทธิ์โบนัสและครอบคลุมเฉพาะ triads เท่านั้น

+/&(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 อักขระ

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 ไบต์สำหรับ,dimaug

Python ( 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

Python 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#_ 
____ 

สกาล่า 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"]