기타 프렛 보드 다이어그램은 다음과 같습니다.

  0  1  2  3  4  5  6  7  8  9 10 11 12   <- Fret number (0 means it's open)
|-E--F--F#-G--G#-A--A#-B--C--C#-D--D#-E
|-B--C--C#-D--D#-E--F--F#-G--G#-A--A#-B 
|-G--G#-A--A#-B--C--C#-D--D#-E--F--F#-G
|-D--D#-E--F--F#-G--G#-A--A#-B--C--C#-D
|-A--A#-B--C--C#-D--D#-E--F--F#-G--G#-A
|-E--F--F#-G--G#-A--A#-B--C--C#-D--D#-E

보시다시피, 첫 번째 문자열 (위에서)은입니다 E. 첫 번째 문자열의 첫 번째 프렛은입니다 F. 세 번째 줄의 네 번째 프렛은입니다 B. 첫 번째 노트는 첫 번째 노트가 아니라 0 번째 프렛입니다.

이것은 형식으로 숫자로 쓰여질 수 있습니다 string, fret. 문자열은 위에서 아래로 1에서 6까지 번호가 매겨집니다. 프렛은 왼쪽에서 오른쪽으로 0에서 12까지 번호가 매겨집니다. 따라서 첫 번째 E는 1, 0입니다. 다른 예 :

1, 0 --> E
1, 1 --> F
3, 5 --> C
5, 1 --> A# 
6, 6 --> A#

도전:

가라 N번호 (쌍 s과 f구분 노트 승계)를 출력.

• 입력은 임의의 적절한 형식 일 수있다. 튜플, 2D 매트릭스, 두 개의 개별 목록, 서로 엮인 목록 (문자열, 프렛, 문자열, 프렛 ...) 등
• 출력 톤을 분리해야하지만 분리 문자는 선택 사항입니다 (쉼표, 공백, 대시 ...). 출력은 대문자 또는 소문자 일 수 있습니다.
• s(문자열의 경우) 범위 내에 있습니다 [1, 6](i 색인을 생성하도록 선택할 수 있음)
• f (프렛의 경우) 범위 내에 있습니다. [0, 12]

테스트 사례 및 예 :

1 4 5 2 1 3   <- String
4 2 6 3 5 1   <- Fret
G# E D# D A G#

6 2 3 1 4 2 3 2 2 2 6 5 2
0 1 2 3 4 5 6 7 8 9 10 11 12
E C A G F# E C# F# G G# D G# B  

3 3 3 3 3 3 3 3 3 3 3 3 3   <- String
0 3 5 0 3 6 5 0 3 5 3 0 0   <- Fret
G A# C G A# C# C G A# C A# G G     

// The same test case, but different input and output format:
(3,0)(3,3)(3,5)(3,3)(3,6)(3,5)(3,0)(3,3)(3,5)(3,3)(3,0)(3,0)    
G,A#,C,G,A#,C#,C,G,A#,C,A#,G,G     

행운과 행복한 골프!

05AB1E , 48 47 43 40 바이트

CP-1252 인코딩을 사용합니다 .

현과 프렛은 모두 0부터 시작합니다.

v7YT5¾7)y`Šè+•™ÎÚ,Ülu•žh'#A«‡•7V3•3BS£è,

설명

v                                # for each pair in input
 7YT5¾7)                         # the list [7,2,10,5,0,7]
 y`                              # flatten the pair [string, fret] and places on stack
 Šè                              # index into the list above using the string
 +                               # add the fret
 •™ÎÚ,Ülu•žh'#A«‡•7V3•3BS£       # list of accords
 è                               # index into the string using the number calculated above
 ,                               # print

온라인으로 사용해보십시오!

Adnan 덕분에 7 바이트 절약

자바 스크립트 (ES6), 79 70 바이트

a=>a.map(([s,f])=>"AA#BCC#DD#EFF#GG#".match(/.#?/g)[(s*7+(s>2)+f)%12])

1 기반 문자열이 필요합니다. 편집 : @nimi의 이전 답변을 기반으로 문자열을 프렛 변환으로 직접 계산하여 9 바이트를 절약했습니다.

Mathematica, 62 바이트 (비경쟁)

<<Music`;MusicScale[100(#2+{24,19,15,10,5,0}[[#]])&@@@#,E2,9]&

{24,19,15,10,5,0}및은 E2(예를 들어, 상부 스트링은 상기 주 E2 24 개 반음이다) 여섯 기타 줄의 개방 문자열 톤을 나타낸다. 노트의 이름을 인쇄하지 않기 때문에 비 경쟁적 입니다 . 일련의 노트를 재생 합니다! (불행히 Mathematica가있는 경우에만) 예를 들어,

<<Music`;MusicScale[100(#2+{24,19,15,10,5,0}[[#]])&@@@#,E2,9]&@
 {{4,0},{3,2},{2,3},{1,2},{5,0},{4,2},{3,2},{2,2},
  {5,2},{4,4},{2,0},{2,3},{6,2},{4,4},{3,2},{2,2},
  {6,3},{4,0},{3,0},{2,0},{4,0},{4,4},{3,2},{2,3},
  {6,3},{3,0},{2,0},{2,3},{5,0},{4,2},{3,2},{2,2},{4,0}}

Pachelbel의 Canon에서 오프닝 4 바 정도를 연주합니다. (그것은 내가 견딜 수있는만큼 Pachelbel의 Canon에 관한 것입니다)

MATL , 48 47 45 바이트

입력 형식에 관한 수정을 위해 @Emigna에게 감사드립니다.

기타와 코드 골프 ... 나는 이것에 대답해야했다!

'$)-27<'i)-'F F# G G# A A# B C C# D D#

입력 형식은 (1 기반) 문자열의 배열과 (0 기반) 프렛의 배열입니다.

온라인으로 사용해보십시오!

설명

이 답변에 사용 된 일부 언어 기능 :

• 일부 산술 연산이 적용되면 문자열이 ASCII 코드 포인트의 숫자 형 배열로 자동 변환 됩니다.
• 산술 연산은 요소별로 작동합니다 ( 예 : 벡터화). 따라서 문자열과 같은 크기의 숫자 배열을 빼면 해당 항목을 빼는 배열이 제공됩니다.
• 인덱싱은 1 기반이며 모듈 식 입니다.
• 셀 어레이는 다른 언어 목록과 같다. 임의의 요소, 다른 유형 또는 크기의 배열을 포함 할 수 있습니다. 여기서 셀형 배열은 길이가 다른 문자열 (음표 이름)을 저장하는 데 사용됩니다.

주석이 달린 코드 :

'$)-27<'                       % Push this string
i                              % Take first input (array of guitar strings)
)                              % Index into the string. For example, input [1 3] gives
                               % the string '$-' (indexing is 1-based)
-                              % Implicitly take second input (array of guitar frets).
                               % Subtract element-wise. This automatically converts the
                               % previous string into an array of ASCII codes. For
                               % example, second input [1 5] gives a result [-35 -40],
                               % which is [1 5] minus [36 45], where 36 and 45 are the
                               % ASCII codes of '$-' 
'F F# G G# A A# B C C# D D# E' % Push this string
Yb                             % Split at spaces. Gives a cell array of 12 (sub)strings:
                               % {'F', 'F#', 'G', ..., 'E'}
w)                             % Swap and index into the cell array of strings.
                               % Indexing is 1-based and modular. In the example, since
                               % the cell array has 12 elements, the indexing array
                               % [-35 -40] is the same [1 8], and thus it gives a 
                               % (sub-)array formed by the first and eighth cells: 
                               % {'F', 'C'}. This is displayed as the cells' contents,
                               % one per line

자바, 174

String f(int[]s,int[]f){String o="";for(int i=0;i<s.length;++i){int n =(7*s[i]-7+f[i]+(s[i]>2?1:0))%12*2;o+="E F F#G G#A A#B C C#D D#".substring(n,n+2).trim()+" ";}return o;}

언 골프 드 :

  String f(int[] s, int[] f) {
    String o = "";
    for (int i = 0; i < s.length; ++i) {
      int n = (7 * s[i] - 7 + f[i] + (s[i] > 2 ? 1 : 0)) % 12 * 2;
      o += "E F F#G G#A A#B C C#D D#".substring(n, n + 2).trim() + " ";
    }
    return o;
  }

(C), 104 (103) 바이트

main(s,f){for(;~scanf("%d%d",&s,&f);printf("%.2s\n",
"E F F#G G#A A#B C C#D D#"+(f+7*~-s+(s>2))%12*2));}

string fretstdin에서 숫자를 쌍으로 취하고 매 쌍마다 노트를 출력합니다. 예 :

1 4
G#
4 2
E 
5 6
D#
2 3
D 

루비, 63 바이트

순서대로 2 요소 배열의 배열을 취합니다 [string,fret].

->x{x.map{|i|"BEADGCF"[6-n=((i[0]-3)%5+2+i[1]*7)%12]+?#*(n/7)}}

설명

표준 튜닝에서 기타는 현 사이의 간격이 일치하지 않는 몇 가지 현악기 (보우 또는 프렛) 중 하나입니다. 대부분은 모든 인접 스트링 쌍 ( "4") 사이에 일관된 5- 세미 톤 간격을 갖거나 모든 인접 스트링 쌍 ( "5") 사이에 일관된 7- 세미 톤 간격을 갖습니다. 이는 3 : 4의 주파수 비율에 해당합니다. 각각 2 : 3이며 주파수 비율이 1 : 2 인 "옥타브"에만 두 번째로 중요합니다.

기타는 대부분 5 반음 간격입니다. 이 중 5 개가 있다면 첫 번째 문자열과 6 번째 문자열 사이에 25 개의 반음 차이가 있습니다. 대신, 2 번째와 3 번째 현 사이의 간격이 4 개의 반음으로 감소하여 24 반음 (2 옥타브)의 차이가 생겨 코드 연주에 더 좋습니다.

프로그램에 불편한 점이 있으므로 1 인덱싱 된 기타 인토네이션을 0 인덱싱 된 5 현베이스 인턴으로 변경하여 5 반음 간격을 갖습니다.

formula (i[0]-3)%5
Before                            After
String      6 5 4 3 2 1           String 4 3 2 1 0
Note        E A D G B E           Note   B E A D G

다음으로 우리는 2를 추가하고 다음과 같이 열린 현의 억양으로 가상의 12 현 저음의 튜닝을 제공하며 모든 간격은 5 반음 (12 현 "베이스"가 존재하지만 정확하게 이것으로 많은 것이 있는지 확실하지 않습니다 동조.)

String       11 10 9  8  7  6  5  4  3  2  1  0 
Note         A# D# G# C# F# B  E  A  D  G  C  F

보다시피, 모든 샤프는 함께 그룹화됩니다. 이 패턴은 무한정 반복 될 수 있습니다. 그것은 "오도 권"로 알려진 인해 사실로 원 닫을 수 조정 조정의 비트와 함께 서양 음계 (근본이다 (3/2)**12과 2**7매우 유사 숫자입니다.

이제 fret 매개 변수를 다룹니다. 문자열 매개 변수를 여러 프렛으로 변환하는 다른 많은 대답과 달리 fret 매개 변수를 여러 문자열로 변환합니다. 위의 표에서 문자열 번호에 7을 추가하면 음표 이름이 반음이 높은 문자열이 표시됩니다. (완전히 다른 옥타브에 있지만 중요하지 않습니다.) 따라서 i[1]*7문자열 번호를 더하고 모듈로 12를 가져옵니다.

n=(i[0]-3)%5+2+i[1]*7)%12

6에서 -5 범위의 숫자를 얻기 위해 이것을 6에서 빼고 BEADGCF(루비는 음수 인덱스를 배열의 끝으로 다시 감쌀 수 있습니다.) 출력을 완료하기 n>=7위해 #기호를 추가 해야하는 경우 .

테스트 프로그램

f=->x{x.map{|i|"BEADGCF"[6-n=((i[0]-3)%5+2+i[1]*7)%12]+?#*(n/7)}}

z=[[6, 2, 3, 1, 4, 2, 3, 2, 2, 2, 6,5,2],[0, 1, 2, 3, 4 ,5 ,6 ,7, 8, 9, 10, 11, 12]].transpose

puts f[z]

산출

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

C #, 131 바이트

string n(int[]s,int[]f){return string.Join(" ",s.Zip(f,(x,y)=>"E,F,F#,G,G#,A,A#,B,C,C#,D,D#".Split(',')[(7*x-7+y+(x<3?0:1))%12]));}

두 개의 별도 목록을 입력하면 문자열은 1을 기준으로합니다.

클로 라 , 55 바이트

@T[0,7,2,10,5,0,7]+N%12@T[,A,A#,B,C#,D,D#,E,F,F#,G,G#]!

설명

@ 숫자 모드 (숫자로 입력 읽기)

T[0,7,2,10,5,0,7] 배열을 사용하여 입력 변환, ex array [Input]

+N 현재 입력에 N (다음 입력 값) 추가

%12 모듈로 12 현재 입력 값

@ 숫자 모드 해제

T[,A,A#,B,C#,D,D#,E,F,F#,G,G#] 입력을 배열로 변환

! 입력 값을 출력값으로 사용

자바 7 197, 163 바이트

void f(int[]s,int[]f){String[]l={"A","A#","B","C","C#","D","D#","E","F","F#","G","G#"};int[]d={0,7,2,10,5,0,7};int j=0;for(int i:s)out.print(l[(d[i]+f[j++])%12]);}

언 골프

  void f(int[]s,int[]f){
 String[]l={"A","A#","B","C","C#","D","D#","E","F","F#","G","G#"};
int[]d={0,7,2,10,5,0,7};
    int j=0;
    for(int i:s)
        out.print(l[(d[i]+f[j++])%12]);



}

파이썬 2, 94, 91 , 88 바이트

for s,f in input():print"A A# B C C# D D# E F F# G G#".split()[([7,2,10,5,0,7][s]+f)%12]

아마도 명백한 개선이있을 것입니다. 입력은 쌍의 목록이며 문자열은 0으로 색인됩니다 (예 :

[0, 4], [3, 2], [4, 6]...

하스켈, 83 82 바이트

zipWith$(!!).(`drop`cycle(words"A# B C C# D D# E F F# G G# A")).([6,1,9,4,11,6]!!)

문자열 목록과 프렛 목록을 모두 0으로 색인화합니다. 사용 예 :

Prelude >  ( zipWith$(!!).(`drop`cycle$words"A# B C C# D D# E F F# G G# A").([6,1,9,4,11,6]!!) ) [0,1,2,3,4,5] [0,0,0,0,0,0]
["E","B","G","D","A","E"]

로 시작하는 무한한 음표 A#목록 [6,1,9,4,11,6]에서 문자열 색인의 목록 에 의해 주어진 음표 수를 버리고 나머지 목록에서 프렛의 색인에있는 음표를 선택하십시오.

자바 스크립트 (ES6), 82 81 바이트

a=>a.map(b=>(q=(b[0]+.3+b[1]*7.3|0)%12/1.7+10.3).toString(17)[0]+(q%1>.5?"#":""))

나는 모든 수학 답변을 시도하고 싶었지만 조금 길었습니다. 어쩌면 골프를 타는 방법이있을 것입니다 ...

테스트 스 니펫

f=a=>a.map(b=>(q=(b[0]+.3+b[1]*7.3|0)%12/1.7+10.3).toString(17)[0]+(q%1>.5?"#":""))
console.log(f([[4,1],[2,4],[6,5],[3,2],[5,1],[1,3]]))

PHP, 102 바이트

<?foreach($_GET[i]as$t)echo[E,F,"F#",G,"G#",A,"A#",B,C,"C#",D,"D#"][[0,7,3,10,5][$t[0]%5]+$t[1]%12]._;

예를 들어 '[[2,0], [5,3], [2,12], [3,8], [0,3]]'을 기준으로 0으로 여러 배열로 입력

모드 7 에 따른 #을 설정하는 좋은 대안 106 바이트

<?foreach($_GET[i]as$t)echo EFFGGAABCCDD[$d=[0,7,3,10,5][$t[0]%5]+$t[1]%12].["","#"][$d%7?$d%7%2?0:1:0]._;