입력

3 음 코드의 상징 ( 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 참조 )

규칙

• 결과는 명령 행 프로그램 또는 스크립트 여야합니다.

• 음악 표기법 표준을 따르는 한 입력 및 출력은 어떤 형태로든 가능합니다.

• 기타 또는 피아노 표현은 3 개 또는 3 개의 필수 음표를 포함하고 다른 것이없는 경우에만 유효한 것으로 간주됩니다. 같은 음이 코드에 여러 번 나타날 수 있습니다.

• 사운드 생성을 제외하고 외부 라이브러리는 허용되지 않습니다 (이 경우 #include, import... 지시문은 문자 수에 추가되지 않습니다).

• 이것은 코드 골프이며, 가장 짧은 코드가 승리합니다!

약간의 음악 이론 ...

현대 서양 음색 음악에서 모든 옥타브는 12 개의 연속 음으로 만들어지며 종종 다음과 같이 지적합니다.

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, 때로는 더 많은) 음표로 구성됩니다. 예를 들어, 3 음 코드 에는 3 개의 다른 음이 포함되어 있으며 7 번째 코드 에는 4 개의 다른 음이 있습니다.

3 개의 3 가지 코드 를 다음과 같이 정의 해 봅시다 :

• 메이저 트라이어드 : 코드의 근음 (이 질문에서 입력으로 주어진 음표), 근음의 주요 3 분의 1 (근음보다 4 반음 높음) 및 근음의 5 분의 1 (근음보다 7 반음 높음)을 포함합니다 ); 이것은 0-4-7로 상징 될 수있다

• 작은 트라이어드 ( 기호 0-3-7)

• 증강 트라이어드 , 상징화 된 0-4-8

• 축소 된 트라이어드 , 상징화 된 0-3-6

당신이 만들고 싶어한다면, 예를 들어, C 메이저 3 화음 언급을, C, CM, Cmaj, 세 가지가주의해야합니다 :

• 0 : 루트 ,이 경우C
• 4 : 마이너 3 , 루트보다 4 반음 높음; 그건E
• 7 : 루트보다 높은 5 분 의 7 반음 :G

이것은 무엇인가 0-4-7, 0-3-7, 0-4-8및 0-3-6표기법이 평균 이상 사용! 일곱 번째 화음에는 다음 패턴을 사용하십시오.

그게 오늘이야! 이제 놀라운 코드로 놀라게 해주세요. 궁금한 점이 있으면 아래에 의견을 추가하십시오.

BBC 기본

bbcbasic.co.uk의 에뮬레이터

개정 1, 340-150 키보드-150 연주 = 40

여기에 몇 가지 문자 만 더 늘리면서 다음 개선 사항을 포함시킬 수있는 최신 버전이 있습니다.

Return 키를 누르기 전에 화면에서 입력을 편안하게 편집 할 수 있습니다 (BBC Basic에서는 문자열이 배열 인 것처럼 문자열에서 단일 문자에 액세스 할 수 없기 때문에 단일 키를 누르기 전에 GET $를 사용했습니다). bulky MID $ 함수는 문자열 내에서 한 문자의 문자열을 추출합니다.

키보드의 양쪽과 E와 F 사이의 전체 라인이 표시됩니다.

위에서 추가 한 문자를 보완하기 위해 불필요한 인쇄 문을 제거하기 위해 프로그램을 재정렬하고 처음에는 삭제할 수없는 것처럼 보이는 공백을 삭제했습니다. BBC Basic에서는 모든 내장 함수가 예약어이며, 그 사이에 공백없이 변수 이름을 바로 붙일 수 있습니다. 변수 이름은 예약어로 시작할 수 없습니다. 프로그램을 읽기 어렵게 만들기 위해 모든 변수를 소문자로 변경했습니다.

프레젠테이션은 훨씬 나아 보이지만 다음 프로그램은 실제로 완전히 골프입니다. IF 문을 사용하는 경우를 제외하고 일반적으로 줄 바꿈과 콜론은 서로 바꿔 사용할 수 있습니다 (아래 수정 참조). 이 경우 같은 줄에있는 모든 명령문 (콜론으로 구분)이 조건부로 실행됩니다. 개행 이후의 명령문은 IF에 의해 제어되지 않으며 항상 실행됩니다.

프로그램 개정 1340 자

  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

수정 : RT Russell의 Windows 용 BBC BASIC을 사용하면 줄 바꿈과 콜론을 제거하여 총계를 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

출력 레브 1

Rev 0, 337-150 키보드-150 연주 = 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 답변과 비슷한 개념이지만 BBC 기본으로 바이트 수를 이길 수 있다는 것을 항상 알고있었습니다. 샤프 만 인식하지만 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 감소 코드는 C Eb Gb 대신 CD # F #이라고 말함). 권리. 각 음표를 F 이상의 완벽한 5 분의 수로 표현하면됩니다.

가치있는 것에 대해, 당신이 조화를 구별하고 싶다면, 어떤 음악 간격도 컴퓨터 프로그램에서 완벽한 5 분의 1과 많은 옥타브로 멋지게 표현 될 수 있습니다. 예를 들어, 증가 된 4 번째는 6 퍼펙트 5와 -3 옥타브이고, 감소 된 5 번째는 -6 퍼펙트 5와 4 옥타브입니다.

하스켈, 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

아두 이노

입력 / 출력은 COM 포트를 통해 Arduino와 송수신됩니다. 사용자는 터미널 또는 Arduino IDE의 직렬 모니터를 통해 이와 상호 작용할 수 있습니다. 내가 선택한 플랫폼에서 짐작할 수 있듯이 실제 코드 연주를 포함시킬 계획입니다 (아직 수행하지는 않았지만).

나는 키보드 보너스를 성공적으로 다루었 고 제한된 성공으로 기타를 다루려고 노력했습니다.

코드 박스는 130 바이트로 제공되므로 너무 길어 가치가 없습니다. 따라서 프렛 번호 탭 스타일을 인쇄하는 다른 방법을 시도했습니다. 현재 이것은 81-100 = -19의 보너스로 81 바이트입니다. 이 접근법이 유효한 것으로 간주되면 시도하고 개선 할 수 있습니다.

사용 된 화음은 두 번째 줄에 근이, 세 번째 줄에 다섯 번째, 첫 번째와 네 번째 줄에 세 번째 뿌리가있는 모든 D 형 도형입니다. 5 번째와 6 번째 문자열은 사용되지 않으며 코드 상자의 오른쪽에 X로 표시합니다 (왼쪽이 더 일반적이지만 오른쪽에 표시된 예는 찾을 수 있습니다).

프로그램은 F를 가장 낮은 음으로 간주하기 때문에 (이 코드 모양으로 과도하게 높은 프렛을 피하면서 키보드와의 호환성을 위해) 가장 높은 코드는 E입니다 (17 프렛에 근음이 있습니다). 출력 예를 참조하십시오.

골프면에서 키보드가 더 성공적입니다. 위에서 설명한 이유로 CB가 아닌 FE에서 실행됩니다. 검은 색 음표의 윤곽과 흰색 음표 사이의 경계를 명확하게 볼 수있을 때 화면을 시계 반대 방향으로 90 % 돌려서 확인해야합니다 ---. B와 C 사이의 선은 ____몇 바이트 더 연장 될 수 있습니다 .

다음에 음을 연주 해 보겠습니다. Arduino Uno에는 3 개의 내부 타이머가 있다고 생각하지만 내장 톤 명령을 사용하여 한 번에 하나의 음만 연주 할 수 있기 때문에 이것은 흥미로울 것입니다. 모든 하드웨어 타이머를 사용하는 외부 라이브러리 기능이 있습니다 (직렬을 엉망으로 만들지 만 어쨌든 그 단계에서는 필요하지 않습니다). 그렇지 않으면 softare에서 톤을 생성하려고 시도 할 수 있습니다.

내가 그 일에 성공하면 골프를 밟을 것이지만 그것이 전체 승자가 될 것이라고는 생각하지 않습니다.

Ungolfed 코드

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 (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이 필요한 경우 마지막 1을로 변경하십시오 3. 보너스를 청구하지 않고 트라이어드 만 포함합니다.

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

자바 스크립트, 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 바이트를 더 지원dim , aug.

파이썬 ( 143134 문자)

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가있는 보너스 포인트가 필요합니다.

파이썬 3 : 257-150 = 107

J 솔루션을 이길 수있는 길이는 25 자입니다! 오 잘 여기에는 몇 가지 깔끔한 아이디어가 있습니다.

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}

하스켈, 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"]