Супутнє: Музика: що в цьому акорді? , Примітки до табулатури , Генерування вкладок гітари? , Перекладіть парні числа на ноти гітари

З огляду на гітару, виведіть акорд, який він представляє. Ви можете використовувати стандартний вхід і вихід або написати функцію, яка повертає рядок.

Вхідні відбитки будуть класифіковані як один із наступних акордів, який виражатиметься наступним чином (якщо коренева нота була С):

• основна тріада: C
• незначна тріада: Cm
• (домінуюча) сьома: C7
• незначна сьома: Cm7

Акорд може бути перевернутий, тому ви не можете розраховувати на найнижчу ноту, що є коренем. Не можна також розраховувати на те, що це справжній легкий або звичайний фінгер в реальному світі. Більш загально, результат вашої програми повинен ігнорувати октави пітчів, а всі пітчі, які відповідають одній музичній ноті (тобто A) , розглядаються як рівні.

Це код-гольф , тому найкоротший код у байтах виграє.

Формат введення

Вхід - це серія з 6 значень, які вказують для кожної струни 6-струнної гітари в стандартній настройці (EADGBE), яка заважає, що ця струна буде відтворюватися. Це також може означати, що рядок взагалі не відтворюється. «Нульова» лада також відома як відкрита позиція, і звідти число підкреслюється. Припустимо, гітара має 21 лад позиції, таким чином, найвища лада позиція 20.

Наприклад, введення X 3 2 0 1 0означає розміщення одним пальцем у наступних положеннях у верхній частині шиї гітари:

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

і стрибування 2-ї по 6-й струнах. Це відповідає цій вкладці ASCII :

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

Ви маєте певну гнучкість у виборі потрібного типу введення: кожне положення ладу може бути виражено рядком або числом. Рядки гітари, які не відтворюються, зазвичай позначаються символом X, але ви можете вибрати інше значення вартового, якщо це полегшує вам (наприклад, -1якщо ви використовуєте цифри). Серія з 6 позицій ладу може бути введена як будь-який список, масив чи тип послідовності, окремий рядок, розділений пробілом, або як стандартне введення - ще раз, на ваш вибір.

Ви можете розраховувати на вхід, що відповідає одному з 4 згаданих вище типів акордів.

Будь ласка, поясніть у своєму дописі, яку форму введення приймає ваше рішення.

Формат виводу

Потрібно або повернути, або надрукувати на стандартний висновок рядок, що описує акорд, для якого потрібен пальчик. Цей рядок складається з двох з'єднаних між собою частин. Капіталізація має значення. Доступний пробіл пробігу дозволений.

Перша частина вказує на основну ноту , один з 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##). Іншими словами, ви повинні звести до мінімуму кількість випадкових випадків (різкостей або квартир) у назві нотатки.

Друга частина вказує тип акорду, або порожній для великої тріади, mдля другорядної тріади, 7для домінуючої сьомої, або m7для другорядної сьомої. Отже, G-мажор виводиться просто так G, тоді як D-мінор сьомий може виводитися як або, D#m7або Ebm7. Більше прикладів можна знайти в тестових випадках наприкінці.

Теорія та підказки

Музичні ноти

Хроматична шкала має 12 смол на октаву. Налаштований на рівний темперамент, кожен з цих тонів однаково віддалений від своїх сусідів ¹ . Піски, що мають 12 півтонів (октава), вважаються такою ж музичною нотою. Це означає, що ми можемо ставитися до нотаток, як цілі числа по модулю 12, від 0 до 11. Сім з них мають літерні назви ² від А до G. Цього недостатньо для того, щоб назвати всі 12 пунктів, але додавання виправлень випадкових випадків: додавання ♯ ( різка) до ноти робить її на один півтону вищою, а додавання ♭ (плоскої) робить її на один півтону нижче.

Акорди

Акорд - це 2 або більше нот, що граються разом. Тип акорду залежить від зв’язків між нотами, які можна визначити за відстані між ними. У хорді є коренева нота, про яку говорилося раніше. Ми розглянемо кореневу ноту як 0 у цих прикладах, але це довільно, і все, що має значення в цьому виклику, - це відстань між нотами в модульній арифметиці. Завжди буде один унікальний тип акорду для відповіді - тріада або сьомий акорд . Коренева нота не завжди буде найвищою частотою кроку; виберіть кореневу ноту таким чином, щоб ви могли описати акорд як один із чотирьох наступних типів акордів:

• Мажорний тризвук це акорд з нотами 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 24, модуль 12 якого еквівалентний 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)

¹ за логарифмами їх частот

² або, в solfège , такі імена, як do, re, mi . У цьому виклику використовуйте буквені назви.

³ Це також можна назвати головним шостим акордом з різним вибором кореневої ноти. У цьому виклику назвіть його другорядним сьомим ім'ям.

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.

Спробуйте в Інтернеті! Або перевірте всі тестові випадки в двох частинах, щоб уникнути вичерпання часу онлайн-компілятора:

• Тестові справи 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. Невикористана рядок представлена ​​фальшивим значенням (єдиними фальшивими значеннями в рубіні є 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}}

Пояснення

Я використовую представлення 12 смол на основі кола п'ятих . Це означає, що за кожним кроком слідує крок на 7 семітонів вище (або на 5 півтонів нижче), що дає послідовність F C G D A E B F# C# G# D# A#. У цьому є 2 переваги. Одне полягає в тому, що всі гострики з’являються разом. Інша полягає в тому, що ноти з 5-струнного басу на відкритому струні з'являються разом: GDAEB (гітара пов'язана, але трохи складніша, див. Нижче).

Перша петля виконується 6 разів. Вираз 6--~j%5(еквівалентно 6-(j+1)%5) дає значення ноти для відкритих струн: E=5 A=4 D=3 G=2 B=6 E=5. До цього додаємо число ладу, помножене на 7 (як видно вище, додаючи один півтон переміщує нас на 7 місць вперед у послідовності.) Потім беремо всю модуль 12 і робимо растрову карту нотаток, які є в наявності (ми використання4097<<note value для отримання двох октав поспіль.)

Склавши растрову карту, ми готові шукати акорд і виводити його.

Нас цікавлять наступні примітки:

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, ми перевіряємо, чи є корінь і п'ятий: біти 0 і 1 (рахуючи найменш значущі: біти 1 і 2). Для того, щоб відхилити шість акордів, ми також повинні перевірити, що шостий відсутня: біт 3 (8 біт.), тому ми перевіряємо це r&&11==3і якщо так, то друкуємо акорд.

Ми ігноруємо основну третину і повністю розраховуємо на біт 9 (другорядний третій) і біт 10 (мінорний 7-й), щоб опрацювати тип акорду. Вираз r>>9&3використовується для вибору правильного типу акорду з масиву.

В кінці циклу, ми зрушити растровий вправо на один біт , r/=2щоб перевірити можливі коріння акордів в наступній послідовності: F C G D A E B F# C# G# D# A#.

Ungolfed в тестовій програмі

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! Це мій перший гольф - пропозиції вітаються, оскільки я впевнений, що його можна було б значно покращити. (збив 2 байти, оскільки я включив f = у число)

Функція 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 */
}