関連：音楽：この和音には何が含まれていますか？、タブ譜の注意事項、ギターのタブを生成する？、数字のペアをギターの音に変換する

ギターの運指が与えられたら、それが表すコードを出力します。標準の入出力を使用することも、文字列を返す関数を作成することもできます。

入力運指は、次のコードのいずれかに分類され、次のように表現されます（ルートノートがCの場合）。

• メジャートライアド： C
• マイナートライアド： Cm
• （支配的）7番目： C7
• マイナー7： Cm7

コードが反転している可能性があるため、ルートである最低音に依存することはできません。また、これが現実の世界で簡単または一般的な運指であることを信頼することもできません。より一般的には、プログラムの出力はピッチのオクターブを無視し、同じ音符（つまりA）に対応するすべてのピッチを等しいものとして扱う必要があります。

これはcode-golfであるため、バイト単位の最短コードが優先されます。

入力形式

入力は、標準チューニング（EADGBE）の6弦ギターの各弦について、その弦が演奏されるフレットを示す一連の6つの値です。また、文字列がまったく再生されないことを示す場合もあります。「ゼロ」フレットはオープンポジションとも呼ばれ、フレット番号はそこからカウントアップされます。ギターに21フレットのポジションがあり、最高のフレットポジションが20番であるとします。

たとえば、入力X 3 2 0 1 0とは、ギターの首の上の次の位置に1本の指を置くことを意味します。

(6th) |---|---|---|---|---
      |-X-|---|---|---|---
      |---|---|---|---|---
      |---|-X-|---|---|---
      |---|---|-X-|---|---
(1st) |---|---|---|---|---

2番目から6番目の弦をかき鳴らします。このASCIIタブに対応します。

e |-0-|
B |-1-|
G |-0-|
D |-2-|
A |-3-|
E |---|

希望する種類の入力を選択する柔軟性があります。各フレットの位置は、文字列または数値として表現できます。演奏されないギターの弦は、一般的にで示されXますが、それがあなたにとってより簡単になるなら（-1数字を使っている場合など）、別のセンチネル値を選択できます。一連の6フレットポジションは、任意のリスト、配列、またはシーケンスタイプ、単一のスペース区切り文字列、または標準入力として入力できます。

上記の4つのコードタイプのいずれかに対応する入力に依存できます。

投稿でソリューションにどのような入力が必要かを説明してください。

出力フォーマット

運指の対象となるコードを説明する文字列を標準出力に戻すか、印刷する必要があります。この文字列は、連結された2つの部分で構成されています。大文字は重要です。末尾の空白は許可されます。

最初の部分が示すルートノート、のいずれかをA、A#/ Bb、B、C、C#/ Db、D、D#/ Eb、E、F、F#/ Gb、GまたはG#/ Ab。（私が使用している#代わりに♯、とbの代わりに、♭Unicodeを必要避けるために、。）それらなしで表現しなければならないシャープやフラットずに表現することができるルートノートを（決して出力B#、FbまたはDbb）。できないものは、単一のシャープまたはフラットシンボルで表現する必要があります（つまり、C#またはのいずれかDbで、決してB##）つまり、音符の名前に含まれる臨時記号（シャープまたはフラット）の数を最小限に抑える必要があります。

2番目の部分は、メジャートライアド、mマイナートライアド、7ドミナントセブン、またはm7マイナーセブンスのいずれかのコードのタイプを示します。したがって、Gメジャーは単にとしてG出力されますが、D♯マイナー7番目はD#m7またはとして出力されますEbm7。最後のテストケースには、さらに多くの例があります。

理論とヒント

音符

半音階には、オクターブごとに12ピッチあります。等しい気質に調整されたとき、これらのピッチのそれぞれは、その隣人¹から等しく離れています。12 半音（1オクターブ）離れたピッチは、同じ音符と見なされます。これは、0から11までの12を法とする整数のような音符を扱うことができることを意味します。これらの7つは、AからGまでの文字名²を与えられます。シャープ）は音に1半音高く、and（フラット）を追加すると1半音低くなります。

和音

コードは、2つ以上のノートが一緒に演奏されます。和音の種類は、音符間の関係によって決まります。音符間の距離は音符間の距離によって決まります。前述のように、コードにはルートノートがあります。これらの例ではルートノートを0として扱いますが、これは任意であり、この課題で重要なのはモジュロ演算でのノート間の距離です。答えには常に1つのユニークなコードタイプ、トライアドまたは7番目のコードがあります。ルートノートは常に最低周波数のピッチではありません。次の4つのコードタイプのいずれかとしてコードを説明できるようにルートノートを選択します。

• 主要なトライアドはノートと和音です0 4 7。
• マイナーなトライアドはノートと和音です0 3 7。
• 支配的な（またはメジャー/マイナー）第七の和音は、ノートを持っています0 4 7 10。
• マイナー（またはマイナー/マイナー）第七の和音は、ノートを持っています0 3 7 10。³

ギターのチューニング

6弦ギターの標準的なチューニングは、最も低い弦のEから始まり、5、5、5、4、5弦の間隔で音符を弾き、弦を上に上げます。最低のEを0とすると、これはギターのすべての弦をかき鳴らして、0 5 10 15 19 2412を法とする番号付きのピッチ0 5 10 3 7 0、またはノートを与えることを意味しますE A D G B E。

実施例

あなたの入力した場合0 2 2 0 0 0、ノートのこの対応E B E G B Eなので、ちょうどE、B、およびG.これらのフォームのコードEmたちを与え、Eなどのルートでそれらに番号を付けることで見ることができ、0 3 7。（これはのために同じであるX 2 X 0 X 0、または12 14 14 12 12 12）。

入力がの場合、4 4 6 4 6 4これらをC♯のルートで番号付けすると7 0 7 10 4 7、またはが得られる0 4 7 10ため、答えはC#7（またはDb7）です。それは代わりにした場合は4 4 6 4 5 4、番号が与える7 0 7 10 3 7、または0 3 7 10、であるC#m7（またはDbm7）。

テストケース

X 3 2 0 1 0  --->  C
0 2 2 0 0 0  --->  Em
X 2 X 0 X 0  --->  Em
4 4 6 4 6 4  --->  C#7  (or Db7)
4 4 6 4 5 4  --->  C#m7 (or Dbm7)
0 2 2 1 0 0  --->  E
0 0 2 2 2 0  --->  A
X X 4 3 2 2  --->  F#   (or Gb)
3 2 0 0 0 1  --->  G7
X X 0 2 1 1  --->  Dm7
3 3 5 5 5 3  --->  C
4 6 6 5 4 4  --->  G#   (or Ab)
2 2 4 4 4 5  --->  B7
0 7 5 5 5 5  --->  Am7
7 6 4 4 X X  --->  B
8 6 1 X 1 3  --->  Cm
8 8 10 10 9 8 -->  Fm
0 19 5 16 8 7 -->  Em
6 20 0 3 11 6 -->  A#   (or Bb)
X 14 9 1 16 X -->  G#m  (or Abm)
12 14 14 12 12 12 --> Em
15 14 12 12 12 15 --> G
20 X 20 20 20 20  --> Cm7
X 13 18 10 11 10  --> A#7 (or Bb7)

¹周波数の対数で

²または、ソルフェージュでは、do、re、miなどの名前。このチャレンジでは、レター名を使用します。

³これは主要な第6和音とも呼ばれ、ルートノートの選択が異なります。このチャレンジでは、マイナー7番目の名前で呼び出します。

MATL、115 114バイト

[OAXICO]+tZN~)Y@!"@t1)XH- 12\XzXJK7hm?O.]JI7hm?'m'.]J[KCX]m?'7'.]J[ICX]m?'m7'.]]'FF#GG#AA#BCC#DD#E'l2741B~QY{HX)wh

入力形式は[N 3 2 0 1 0]で、N未使用の文字列を示します。

出力文字列は常にでは#なくを使用しbます。

オンラインでお試しください！または、オンラインコンパイラのタイムアウトを回避するために、2つの部分ですべてのテストケースを検証します。

• テストケース1‒12 ;
• テストケース13-24。

説明

[OAXICO]            % Push [0 5 10 3 7 0]. This represents the pitch of each open
                    % string relative to the lowest string, modulo 12
+                   % Add to implicit input. May contain NaN's, for unused strings
tZN~)               % Remove NaN's
Y@!                 % Matrix of all permutations, each in a column
"                   % For each column
  @                 %   Push current column
  t1)               %   Duplicate and get first entry
  XH                %   Copy into clipboard H
  - 12\             %   Subtract. This amounts to considering that the first note
                    %   of the current permutation is the root, and computing
                    %   all intervals with respect to that
  12\               %   Modulo 12
  Xz                %   Remove zeros
  XJ                %   Copy into clipboard J
  K7hm?             %   Are all intervals 4 or 7? If so: it's a major chord
    O               %     Push 0 (will become space when converted to char)
    .               %     Break for loop
  ]                 %   End if
  J                 %   Push array of nonzero intervals again
  I7hm?             %   Are all intervals 3 or 7? If so: it's a minor chord
    'm'             %     Push this string
    .               %     Break for loop
  ]                 %   End if
  J                 %   Push array of nonzero intervals again
  [KCX]m?           %   Are all intervals 4, 7 or 10? If so: it's a dominant-7th
                    %   chord
    '7'             %     Push this string
    .               %     Break for loop
  ]                 %   End if
  J                 %   Push array of nonzero intervals again
  [ICX]m?           %   Are all intervals 3, 7 or 10? If so: it's a minor 7th chord
    'm7'            %     Push this string
    .               %     Break for loop
  ]                 %   End if
]                   % End for. The loop is always exited via one of the 'break'
                    % statements. When that happens, the stack contains 0, 'm',
                    % '7' or 'm7', indicating the type of chord; and clipboard H
                    % contains a number that tells the root note using the lowest 
                    % string as base (1 is F, 2 is F# etc)
'FF#GG#AA#BCC#DD#E' % Push this string. Will be split into strings of length 1 or 2
l                   % Push 1
2741B~Q             % Push [1 2 1 2 1 2 1 1 2 1 2 1] (obtained as 2741 in binary,
                    % negated, plus 1)
Y{                  % Split string using those lengths. Gives a cell array of
                    % strings: {'F', 'F#', ..., 'E'}
H                   % Push the identified root note
X)                  % Index into cell array of strings
wh                  % Swap and concatenate. Implicitly display

MS-DOS .COMファイル（179バイト）

ファイル（ここではHEXとして表示）：

fc be 81 00 bf 72 01 31 db b9 06 00 51 e8 73 00
59 e2 f9 b9 0c 00 be 48 01 ad 39 c3 74 0d 40 75
f8 d1 fb 73 03 80 c7 08 e2 ec c3 31 db 88 cb 8a
87 59 01 e8 42 00 8a 87 65 01 e8 3b 00 81 c6 08
00 ac e8 33 00 ac eb 30 91 00 89 00 91 04 89 04
ff ff 00 00 6d 00 37 00 6d 37 42 41 41 47 47 46
46 45 44 44 43 43 00 23 00 23 00 23 00 00 23 00
23 00 04 09 02 07 0b 04 84 c0 74 06 b4 02 88 c2
cd 21 c3 8a 0d 47 ac 3c 20 76 fb 30 ed 3c 41 73
22 2c 30 72 0b 86 c5 b4 0a f6 e4 00 c5 ac eb ed
88 e8 00 c8 30 e4 b1 0c f6 f1 88 e1 b8 01 00 d3
e0 09 c3

入力はコマンドラインを介して与えられます。無効な入力は、無効なプログラムの動作につながります！

アセンブラコードは次のようになります。

.text
.code16
ComFileStart:
    cld
    mov $0x81, %si
    mov $(TuneTable-ComFileStart+0x100), %di
    xor %bx, %bx
    # 6 strings: Build the mask of played tones
    mov $6, %cx
NextStringRead:
    push %cx
    call InsertIntoMask
    pop %cx
    loop NextStringRead

    # Check all base tones...
    mov $12, %cx
TestNextTone:
    mov $0x100+ChordTable-ComFileStart, %si
TestNextChord:
    lodsw
    # Is it the chord we are searching for?
    cmp %ax, %bx
    je FoundChord 
    # Is it the end of the table?
    inc %ax
    jnz TestNextChord
    # Transpose the chord we really play
    # and go to the next tone
    # This code rotates the low 12 bits of
    # BX one bit right
    sar $1, %bx
    jnc NoToneRotated
    add $8, %bh
NoToneRotated:
    loop TestNextTone
EndOfProgram:
    ret

FoundChord:
    # Get and print the tone name
    xor %bx, %bx
    mov %cl, %bl
    mov (ToneNamesTable+0x100-1-ComFileStart)(%bx),%al
    call printChar
    mov (ToneNamesTable+0x100+12-1-ComFileStart)(%bx),%al
    call printChar
    # Get the chord name suffix and print it
    add $(ChordNamesTable-ChordTable-2),%si
    lodsb
    call printChar
    lodsb
    # Note: Under MS-DOS 0x0000 is the first word on
    # the stack so the "RET" of printChar will jump
    # to address 0x0000 which contains an "INT $0x21"
    # (end of program) instruction
    jmp printChar

ChordTable:
    # Major, Minor, Major-7, Minor-7
    .word 0x91, 0x89, 0x491, 0x489, 0xFFFF
ChordNamesTable:
    .byte 0,0,'m',0,'7',0,'m','7'
ToneNamesTable:
    .ascii "BAAGGFFEDDCC"
    .byte 0,'#',0,'#',0,'#',0,0,'#',0,'#',0
TuneTable:
    .byte 4,9,2,7,11,4

#
# Subfunction: Print character AL;
#              Do nothing if AL=0
#
printChar:
    test %al, %al
    jz noPrint
    mov $2, %ah
    mov %al, %dl
    int $0x21
noPrint:
    ret

#
# Subfunction: Get one finger position
#              and insert it into a bit mask
#              of tones being played
#
# Input:
#
#   [DS:DI] = 
#        Tuning of current string (0=C, 1=C#, ..., 11=B)
#        Actually only 2=D, 4=E, 7=G, 9=A and 11=B are used
#
#   DS:SI = Next character to read
#
#   DF = Clear
#
# Input and Output:
#
#    BX = Bit mask
#    DI = Will be incremented
#
# Destroys nearly all registers but SI and BX
#
InsertIntoMask:
    mov (%di), %cl
    inc %di
SkipSpaces:
    lodsb
    cmp $' ', %al
    jbe SkipSpaces
# Now evaluate each digit
    xor %ch, %ch
GetNextDigit:
    # Number = 10*Number+Digit
    cmp $'A', %al
    jae DigitIsX
    sub $'0', %al
    jb DigitsDone
    xchg %al, %ch
    mov $10, %ah
    mul %ah
    add %al, %ch
    lodsb
    jmp GetNextDigit
DigitsDone:
    # Add the tune of the string
    # and perform modulus 12
    mov %ch, %al
    add %cl, %al
    xor %ah, %ah
    mov $12, %cl
    div %cl
    mov %ah, %cl
    mov $1, %ax
    shl %cl, %ax
    or %ax, %bx
DigitIsX:
    ret

テストケース：

6 20 0 3 11 6 -->  A#   (or Bb)

二人のピアノ奏者がピアノで「フォーハンド」で一緒に演奏しているのを見ました。

このテストケースは、これを行うギタリストについて初めて読んだものです。

右手でタップしても、このようなコードを演奏することはできません！

ルビー、129バイト

前のバージョンと同じですが、構文解析ステップと出力ステップの間を順序付ける三項演算子を使用した単一のループを使用します。この作業を行うには、いくつかの他の小さな変更が必要でした。

->a{r=0
18.times{|j|j<6?a[j]&&r|=8194<<(6--~j%5+a[j]*7)%12:(r/=2)&11==3&&puts("CGDAEBF"[j%7]+?#*(j/13)+['',?m,?7,'m7'][r>>9&3])}}

ルビー、136バイト

Llamda関数は、引数として6つの数値の配列を受け入れ、stdoutに出力します。未使用の文字列がfalsy値で表される（ルビーでのみfalsy値であるnilとfalse）。

->a{r=0
6.times{|j|a[j]&&r|=4097<<(6--~j%5+a[j]*7)%12}
12.times{|j|r&11==3&&puts("FCGDAEB"[j%7]+?#*(j/7)+['',?m,?7,'m7'][r>>9&3]);r/=2}}

説明

5分の1の円に基づいて12ピッチの表現を使用します。これは、各ピッチの後に7セミトーン高い（または5セミトーン低い）ピッチが続くことを意味しますF C G D A E B F# C# G# D# A#。これには2つの利点があります。1つは、すべてのシャープが一緒に表示されることです。もう1つは、5弦ベースのオープンストリングノートが一緒に表示されることです。

最初のループは6回実行されます。式6--~j%5（同等6-(j+1)%5）は、開いている文字列の音価を示しますE=5 A=4 D=3 G=2 B=6 E=5。これに、フレット番号に7を掛けた値を追加します（上記のように、半音を1つ追加すると、シーケンス内で7桁前方に移動します）。4097<<note value2つの連続したオクターブを与えるために使用します。）

ビットマップを作成したら、コードを検索して出力する準備ができました。

次の注意事項に関心があります。

Note       position in      position in             Note      position in 
           semitone domain  circle of fifths                  circle of fifths 
Root       0                0                       Root      0
Minor 3rd  3                9                       Fifth     1
Major 3rd  4                4                       Sixth     3
Fifth      7                1                       Major 3rd 4
Sixth      9                3                       Minor 3rd 9
Minor 7th  10               10                      Minor 7th 10

コードFをチェックすることから始めて、ルートと5番目が存在するかどうかをテストします：ビット0と1（最下位からカウント：1と2のビット）。6番目のコードを拒否するには、6番目のコードビット3（8のビット）がないので、それをチェックしr&&11==3、そうであればコードを出力します。

メジャー3分の1を無視し、ビットタイプ9（マイナー3分の1）とビット10（マイナー7分の1）のみに依存してコードタイプを決定します。この式r>>9&3は、配列から正しいコードタイプを選択するために使用されます。

ループの最後で、ビットマップを右に1ビットシフトして、r/=2コードのルートの可能性を順番にテストしますF C G D A E B F# C# G# D# A#。

テストプログラムでゴルフをしていない

f=->a{                            #Accept array of 6 numbers as argument.
  r=0                             #Setup an empty bitmap.

  6.times{|j|                     #For each string
    a[j]&&                        #if the fret value is truthy (not nil or false)
    r|=4097<<(6--~j%5+a[j]*7)%12  #calculate the note value in the circle of fifths and add to the bitmap.
  }

  12.times{|j|                    #For each possible root note
    r&11==3&&                     #if root and fifth are present (bits 0 and 1) and sixth is absent (bit 3) 
    puts("FCGDAEB"[j%7]+?#*(j/7)+ #output the note name and a sharp symbol if necessary, followed by
    ['',?m,?7,'m7'][r>>9&3])      #m and/or 7 as indicate by bits 9 and 10.
    r/=2
  }
}

print 1;f[[nil,3,2,0,1,0]]       #  C
print 2;f[[0,2,2,0,0,0]]         #  Em
print 3;f[[nil,2,nil,0,nil,0]]   #  Em
print 4;f[[4,4,6,4,6,4]]         #  C#7 
print 5;f[[4,4,6,4,5,4]]         #  C#m7 
print 6;f[[0,2,2,1,0,0]]         #  E
print 7;f[[0,0,2,2,2,0]]         #  A
print 8;f[[nil,nil,4,3,2,2]]     #  F#  
print 9;f[[3,2,0,0,0,1]]         #  G7
print 10;f[[nil,nil,0,2,1,1]]    #  Dm7
print 11;f[[3,3,5,5,5,3]]        #  C
print 12;f[[4,6,6,5,4,4]]        #  G#  
print 13;f[[2,2,4,4,4,5]]        #  B7
print 14;f[[0,7,5,5,5,5]]        #  Am7
print 15;f[[7,6,4,4,nil,nil]]    #  B
print 16;f[[8,6,1,nil,1,3]]      #  Cm
print 17;f[[8,8,10,10,9,8]]      #  Fm
print 18;f[[0,19,5,16,8,7]]      #  Em
print 19;f[[6,20,0,3,11,6]]      #  A#  
print 20;f[[nil,14,9,1,16,nil]]  #  G#m 
print 21;f[[12,14,14,12,12,12]]  #  Em
print 22;f[[15,14,12,12,12,15]]  #  G
print 23;f[[20,nil,20,20,20,20]] #  Cm7
print 24;f[[nil,13,18,10,11,10]] #  A#7

Javascript（ES6）、335 333バイト

このチャレンジとPPCG SEが大好きです！これは私の最初のゴルフです-改善できると確信しているので、提案を歓迎します。（カウントにf =を含めたため、2バイトをノックしました）

関数fは、数字と「X」を表す文字列の配列を受け取り、のようなf(['X','3','2','0','1','0'])コード（自然またはシャープ）を返しますE#m7。わかりやすくするために改行が追加されました（バイトカウントには含まれません）

f=c=>[s=new Map([[435,''],[345,'m'],[4332,7],[3432,'m7']]),
n=[...new Set(c.map((e,i)=>e?(+e+[0,5,10,3,7,0][i])%12:-1)
.filter(e=>++e).sort((a,b)=>a>b))],d=[...n,n[0]+12].reduce(
(a,c,i)=>i?[...a,(c-n[i-1]+12)%12]:[],0).join``.repeat(2),
m=+d.match(/(34|43)(5|32)/g)[0],'E0F0F#0G0G#0A0A#0B0C0C#0D0D#'
.split(0)[n[d.indexOf(m)]]+s.get(m)][4]

使用例：

console.log(f(['0','2','2','0','0','0'])); // Em

テストケースを実行するには：

tests=`X 3 2 0 1 0 ---> C
0 2 2 0 0 0 ---> Em
X 2 X 0 X 0 ---> Em
4 4 6 4 6 4 ---> C#7 (or Db7)
4 4 6 4 5 4 ---> C#m7 (or Dbm7)`; // and so on...

tests.split`\n`.forEach(e=>{
    console.log(`Test: ${e}
      Result: ${f(e.split(' ').slice(0,6))}`)
})

説明付きのゴルフバージョン：

f = (c) => {
    s = new Map([
        [435,''], [345,'m'], [4332,7], [3432,'m7'] 
    ]) /* Each key in s describes the intervals (semitones)
          between consecutive notes in a chord, when it is
          reduced to a single octave, including the interval
          from highest back to lowest. The values describe
          the corresponding chord suffix. E.g. C-E-G has
          intervals C-4-E-3-G-5-C. 435=major=no suffix. */

    n = [ ...new Set(
        c.map( 
         (e,i) => e ? ( +e + [0,5,10,3,7,0][i] )%12 : -1 
         ).filter( (e) => ++e ).sort( (a,b) => a>b )
        ) ] /* take the input array, c, and transform each fret
               position into a note. remove non-notes (-1), sort
               in tone order, remove duplicates. An input of
               positions X 13 18 10 11 10 becomes notes
               (-1) 6 4 1 6 10 then 1 4 6 10. */

    d = [ ...n, n[0] + 12 ].reduce(
        (a,c,i) => i ? [ ...a, (c - n[i-1] + 12)%12 ] : [], 0
    ).join``.repeat(2)
    /* convert the note array, n, into an interval string, d,
       including the lowest note repeated above it to capture
       all intervals. Repeat it twice so that, regardless of the
       inversion played, the intervals will appear in root order
       somewhere. E.g. notes 1-4-6-10 and 13 (1+12)
       become intervals 3 2 4 3, and string for searching
       32433243 */

    m = +d.match( /(34|43)(5|32)/g )[0];
      /* m is the matched chord pattern. In this case, 4332. */

    return 'E0F0F#0G0G#0A0A#0B0C0C#0D0D#'.split(0)[
    n[ d.indexOf(m) ]
    /* get the position in the interval string where the root
       interval first occurs. this corresponds to the position
       of the chord root note in the note array, n. convert this
       number 0-12 to a note name E - D# */
    ] + s.get(m)
       /* add the suffix corresponding to the matched
       chord interval pattern */
}