Correlati: Musica: cosa c'è in questo accordo? , Note sulla tablatura , Generazione di tablature per chitarra? , Traduci coppie di numeri in note di chitarra

Data una diteggiatura della chitarra, emette l'accordo che rappresenta. È possibile utilizzare input e output standard oppure scrivere una funzione che restituisce una stringa.

Le diteggiature di input saranno classificabili come uno dei seguenti accordi, da esprimere come segue (se la nota di radice fosse C):

• triade maggiore: C
• triade minore: Cm
• (dominante) settimo: C7
• settima minore: Cm7

L'accordo potrebbe essere invertito, quindi non puoi fare affidamento sul fatto che la nota più bassa sia la radice. Né puoi fare affidamento sul fatto che questa è una diteggiatura facile o comune nel mondo reale. Più in generale, l'output del tuo programma deve ignorare le ottave dei toni e trattare tutti i toni che corrispondono alla stessa nota musicale (cioè, A) come uguali.

Questo è code-golf , quindi vince il codice più breve in byte.

Formato di input

L'ingresso è una serie di 6 valori che indicano, per ciascuna corda di una chitarra a 6 corde in accordatura standard (EADGBE), a quale tasto verrà suonata quella corda. Potrebbe anche indicare che la corda non è affatto suonata. Il tasto "zeroth" è anche conosciuto come la posizione aperta, e da quel momento i numeri dei tasti contano. Supponiamo che la chitarra abbia 21 posizioni dei tasti, in modo tale che la posizione più alta sia il numero 20.

Ad esempio, l'ingresso X 3 2 0 1 0significa posizionare le dita nelle seguenti posizioni nella parte superiore del collo della chitarra:

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

e strimpellando la seconda attraverso la sesta corda. Corrisponde a questa scheda ASCII :

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

Hai una certa flessibilità nella scelta del tipo di input che desideri: ogni posizione del tasto può essere espressa come una stringa o un numero. Le stringhe di chitarra che non vengono suonate sono comunemente indicate con un X, ma puoi scegliere un diverso valore sentinella se questo ti rende più facile (ad esempio -1se stai usando dei numeri). La serie di 6 posizioni dei tasti può essere immessa come qualsiasi elenco, matrice o tipo di sequenza, una singola stringa separata da spazio o come input standard, ancora una volta, la tua scelta.

Puoi fare affidamento sull'input corrispondente a uno dei 4 tipi di accordi sopra menzionati.

Spiega nel tuo post quale forma di input prende la tua soluzione.

Formato di output

È necessario restituire o stampare sull'output standard una stringa che descriva l'accordo per la diteggiatura. Questa stringa è composta da due parti concatenate insieme. La capitalizzazione conta. È consentito lo spazio bianco finale.

La prima parte indica la nota fondamentale , una delle A, A#/ Bb, B, C, C#/ Db, D, D#/ Eb, E, F, F#/ Gb, Go G#/ Ab. (Sto usando #al posto di ♯, e binvece di ♭, per evitare che richiedono Unicode.) Note Root che possono essere espressi senza un brusco o appartamento deve essere espresso senza di loro (mai uscita B#, Fbo Dbb); quelli che non possono essere espressi con un singolo simbolo acuto o piatto (cioè o C#o Db, ma mai B##). In altre parole, è necessario ridurre al minimo il numero di incidenti (oggetti taglienti o piatti) nel nome della nota.

La seconda parte indica il tipo di accordo, vuoto per una triade maggiore, mper una triade minore, 7per la settima dominante o m7per la settima minore. Quindi un G maggiore viene emesso semplicemente come G, mentre un D 7 minore potrebbe essere emesso come uno D#m7o Ebm7. Altri esempi sono disponibili nei casi di test alla fine.

Teoria e suggerimenti

Note musicali

La scala cromatica ha 12 tonalità per ottava. Quando sintonizzato su un temperamento uguale, ciascuno di questi passi è ugualmente distante dai vicini ¹ . Le tonalità distanti 12 semitoni (un'ottava) sono considerate la stessa nota musicale. Questo significa che possiamo trattare le note come numeri interi modulo 12, da 0 a 11. A sette di questi vengono dati i nomi di lettere ² da A a G. Questo non è sufficiente per nominare tutti i 12 passi, ma l'aggiunta di accidenti corregge che: l'aggiunta di un ♯ ( sharp) a una nota lo rende più alto di un semitono e l'aggiunta di un flat (piatto) lo rende più basso di un semitono.

Chords

Un accordo è composto da 2 o più note suonate insieme. Il tipo di accordo dipende dalle relazioni tra le note, che possono essere determinate dalle distanze tra loro. Un accordo ha una nota di radice, come menzionato in precedenza. Tratteremo la nota radice come 0 in questi esempi, ma questo è arbitrario e tutto ciò che conta in questa sfida è la distanza tra le note nell'aritmetica del modulo. Ci sarà sempre un unico tipo di accordo per la risposta, una triade o una settima . La nota radice non sarà sempre l'intonazione della frequenza più bassa; scegli la nota fondamentale in modo da poter descrivere l'accordo come uno dei quattro seguenti tipi di accordo:

• Una triade maggiore è un accordo con le note 0 4 7.
• Una triade minore è un accordo con le note 0 3 7.
• Un settimo accordo dominante (o maggiore / minore) ha le note 0 4 7 10.
• Un settimo accordo minore (o minore / minore) ha le note 0 3 7 10. ³

Accordatura per chitarra

L'accordatura standard su una chitarra a 6 corde inizia con E sulla corda più bassa, quindi suona le note a intervalli di 5, 5, 5, 4, quindi 5 semitoni salendo le corde. Prendendo la E più bassa come 0, questo significa strimpellare tutte le corde della chitarra per ottenere toni numerati 0 5 10 15 19 24, a cui modulo 12 è equivalente 0 5 10 3 7 0, o le note E A D G B E.

Esempi lavorati

Se il tuo input è 0 2 2 0 0 0, questo corrisponde alle note E B E G B E, quindi solo E, B e G. Questi formano l'accordo Em, che può essere visto numerandoli con la radice come E, dandoci 0 3 7. (Il risultato sarebbe lo stesso per X 2 X 0 X 0, o 12 14 14 12 12 12.)

Se il tuo input è 4 4 6 4 6 4, numerando questi con una radice di C♯ dà 7 0 7 10 4 7, o 0 4 7 10, quindi la risposta è C#7(o Db7). Se fosse invece 4 4 6 4 5 4, la numerazione darebbe 7 0 7 10 3 7, o 0 3 7 10, che è C#m7(o Dbm7).

Casi test

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)

¹ dai logaritmi delle loro frequenze

² o, in solfège , nomi come do, re, mi . In questa sfida, usa i nomi delle lettere.

³ Questo potrebbe anche essere chiamato un sesto accordo maggiore, con una diversa scelta della nota di radice. In questa sfida, chiamalo con il suo settimo nome minore.

MATL , 115 114 byte

[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

Il formato di input è [N 3 2 0 1 0], dove Nindica una stringa non utilizzata.

La stringa di output utilizza sempre #, non b.

Provalo online! Oppure verifica tutti i casi di test, in due parti per evitare il timeout del compilatore online:

• Casi di test 1‒12 ;
• Casi di prova 13‒24 .

Spiegazione

[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

File .COM MS-DOS (179 byte)

Il file (qui visualizzato come esadecimale):

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

L'input viene fornito tramite riga di comando. Un input non valido comporterà un comportamento del programma non valido!

Il codice dell'assemblatore è simile al seguente:

.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

Casi test:

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

Ho già visto due pianisti suonare insieme "a quattro mani" su un piano.

Questo caso di test è la prima volta che leggo che i chitarristi lo fanno!

Anche toccando con la mano destra non puoi suonare una corda come questa!

Rubino, 129 byte

Come versione precedente ma utilizza un singolo loop, con operatore ternario per la sequenza tra il passo di analisi e il passo di uscita. Alcune modifiche minori sono state necessarie per far funzionare questo.

->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])}}

Rubino, 136 byte

La funzione Llamda accetta un array di 6 numeri come argomento e genera in stdout. La stringa inutilizzata è rappresentata da un valore di falsy (gli unici valori di falsy in ruby ​​sono nile 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}}

Spiegazione

Uso una rappresentazione dei 12 passi basata sul cerchio dei quinti . Questo significa che ogni tono è seguito dal tono 7 semitoni più in alto (o 5 semitoni in basso) che dà la sequenza F C G D A E B F# C# G# D# A#. Ci sono 2 vantaggi in questo. Uno è che tutti gli oggetti taglienti compaiono insieme. L'altro è che le note a corda aperta del basso a 5 corde appaiono insieme: GDAEB (la chitarra è correlata ma leggermente più complessa, vedi sotto).

Il primo ciclo viene eseguito 6 volte. L'espressione 6--~j%5(in modo equivalente 6-(j+1)%5) fornisce i valori di nota per le corde a vuoto: E=5 A=4 D=3 G=2 B=6 E=5. A questo aggiungiamo il numero di tasti moltiplicato per 7 (come si può vedere sopra, l'aggiunta di un semitono ci sposta di 7 posizioni in avanti nella sequenza). Quindi prendiamo tutto il modulo 12 e facciamo una bitmap delle note presenti (noi usare 4097<<note valueper dare 2 ottave consecutive.)

Avendo composto la bitmap, siamo pronti a cercare l'accordo e emetterlo.

Siamo interessati alle seguenti note:

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

Iniziando controllando l'accordo F, testiamo se sono presenti la radice e la quinta: bit 0 e 1 (contando dal meno significativo: i bit 1 e 2). Per rifiutare gli accordi sesto dobbiamo anche verificare che il sesto è assente: bit 3 (bit 8), quindi lo controlliamo r&&11==3e in tal caso stampiamo l'accordo.

Ignoriamo il terzo maggiore e facciamo affidamento interamente sul bit 9 (terzo minore) e sul bit 10 (minore 7) per elaborare il tipo di accordo. L'espressione r>>9&3viene utilizzata per scegliere il tipo di accordo corretto da un array.

Alla fine del ciclo, spostiamo la bitmap quella giusta po ' r/=2per testare le possibili radici di accordi in sequenza: F C G D A E B F# C# G# D# A#.

Non registrato nel programma di test

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 byte

Adoro questa sfida e PPCG SE! Questo è il mio primo golf - i suggerimenti sono ben accetti poiché sono sicuro che potrebbero essere migliorati molto. (eliminato 2 byte come avevo incluso f = nel conteggio)

La funzione faccetta una matrice di stringhe, che rappresentano numeri e "X", come f(['X','3','2','0','1','0'])e restituisce un accordo (naturale o nitido) E#m7. Newline aggiunti per chiarezza (non inclusi nel conteggio dei byte)

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]

Esempio di utilizzo:

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

Per eseguire casi di test:

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))}`)
})

Versione non golfata con spiegazione:

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 */
}