Questo è il contrario di Music: cosa c'è in questo accordo? , ovvero stampare le note in un determinato accordo. Questa volta l'input è un elenco di note in un accordo e il tuo compito è quello di produrre quale accordo è.

Il tuo programma dovrebbe supportare i seguenti accordi triadici. Esempi sono dati con la radice C. Gli accordi con altre radici sono gli stessi accordi con tutte le note ruotate in modo che C diventerà quella nota di radice, ad esempio Dmaj è composta da D, F # e A.

        C C#D D#E F F#G G#A A#B
          Db  Eb    Gb  Ab  Bb
Cmaj    C       E     G
Cm      C     D#      G
Caug    C       E       G#
Cdim    C     D#    F#
Csus4   C         F   G
Csus2   C   D         G

Nota che Caug è uguale a Eaug e G # ago e Csus4 è lo stesso di Fsus2. Puoi produrne uno ma c'è un bonus se li produci tutti.

E i settimi accordi per il bonus sono elencati nella seguente tabella:

        C C#D D#E F F#G G#A A#B
          Db  Eb    Gb  Ab  Bb
C7      C       E     G     A#
Cm7     C     D#      G     A#
Cmmaj7  C     D#      G       B
Cmaj7   C       E     G       B
Caug7   C       E       G#  A#
Cdim7   C     D#    F#    A

Regole

• È possibile scrivere un programma completo o una funzione.
• L'input è un elenco di note, separate da uno spazio o un altro carattere conveniente. Può anche essere una matrice di stringhe (se accetta input dall'argomento della funzione) o la rappresentazione di stringhe di tale matrice.
• L'input non deve essere nell'ordine specifico.
• Potrebbero essere presenti note duplicate nell'input. Devono essere trattati nello stesso modo in cui ne esiste solo uno.
• L'output è il nome dell'accordo. Nel caso in cui vengano generati più nomi, si applica la stessa regola per l'input.
• Se l'input non è un accordo supportato, è necessario stampare le note così come sono. Il tuo programma può supportare anche altri accordi non elencati nelle tabelle sopra (che è valido ma non ha bonus).
• Puoi usare altre notazioni elencate nell'articolo di Wikipedia . Ma se scegli Cper do maggiore, dovresti aggiungere in entrambi i casi un prefisso leggibile per distinguere un accordo con una singola nota.
• Non è possibile utilizzare le funzioni integrate per questa attività (se presente).
• Questo è code-golf. Vince il codice più breve in byte.

Esempi

• Ingresso: C D# GUscita: Cm.
• Ingresso: C Eb GUscita: Cm.
• Ingresso: C Eb F#Uscita: Cdim.
• Ingresso: F A C#Uscita: Faug, Aaug, C#aug, Dbaugo Faug Aaug C#aug, Faug Aaug Dbaugin qualsiasi ordine.
• Ingresso: F D F F F F A A FUscita: Dm.
• Ingresso: C DUscita: C D.

bonus

• -30 se li stampa tutti se ci sono più interpretazioni (per aug, sus4 / sus2 e dim7).
• -70 se supporta anche gli accordi del settimo.
• -200 se accetta input MIDI e stampa tutti gli accordi che ha ricevuto. Nota che le note non devono iniziare o finire contemporaneamente. Decidi tu cosa succede negli stati intermedi (purché non si blocchi o smetta di funzionare). Puoi presumere che non ci siano note nei canali di percussione (o c'è solo un canale se è conveniente). Si consiglia di fornire anche una versione testuale (o array) per i test, soprattutto se dipende dalla piattaforma.

Pyth 190 carattere - 30 - 70 = 90

=Q{cQdL+x"C D EF G A B"hb&tlbt%hx" #b"eb3FZQJx[188 212 199 213 200 224 2555 2411 2412 2556 2567 2398)u+*G12hHSm%-dyZ12mykQ0IhJ+Z@c"sus2 maj dim aug m sus4 7 m7 mmaj7 maj7 aug7 dim7"dJ=T0;ITQ

Non molto contento. Accordi hard-coded usati.

Uso:

Provalo qui: Pyth Compiler / Executor . Disabilita la modalità debug e usa "C D# G"come input.

Spiegazione:

Prima un po 'di preparazione:

=Q{cQd
   cQd  split chord into notes "C D# G" -> ["C", "D#", "G"]
  {     set (eliminate duplicates)
=Q      Q = ...

Quindi una funzione che converte le note in numeri interi

L+x"C D EF G A B"hb&tlbt%hx" #b"eb3
defines a function g(b),
  returns the sum of 
     index of "D" in "C D EF G A B"
     and the index of "#" in " #b" 
       (if b than use -1 instead of 2)

Quindi per ogni nota, sposta il coord e cercalo in una tabella

FZQJx[188 ...)u+*G12hHSm%-dyZ12mykQ0IhJ+Z@c"sus2 ..."dJ=T0;ITQ
               implicit T=10
FZQ            for note Z in chord Q:
   mykQ         map each note of Q to it's integer value
   m%-dyZ12     shift it by the integer value of Z modulo 12 
   S            sort it
   u+*G12hH 0   convert it to an integer in base 12
   x[188 ...)   look it up in the list (-1 if not in list)
   J            and store the value in J

   IhJ               if J>=0:
   +Z@c"sus2 ..."dJ   print the note Z and the chord in the list
=T0                   and set T=0
;            end loop
ITQ          if T:print chord (chord not in list)

Perl 5: 183 - 100 = 83

Modifica: sono riuscito a tagliare alcuni caratteri extra, quindi ho anche modificato i nomi degli accordi come nella soluzione Python, quindi posso fingere per un momento che sto guidando.

#!perl -pa
for$z(0..11){$x=0;$x|=1<<((/#/-/b/+$z+1.61*ord)%12or$o=$_)for@F;$x-/\d+_?/-$_*4||push@r,$o.$'
for qw(36M 34- 68+ 18o 40sus2 33sus4 292_7 290-7 546-M7 548M7 324+7 146o7)}$_="@r
"if@r

Esempio:

$ perl chord.pl <<<"C D# G"
C-

Python 2, 335 byte - 30 - 70 = 235

Primo tentativo di giocare a golf leggermente più lungo, quindi potrei mancare alcuni trucchi ovvi.

def f(s,N="C D EF G A B",r=range,u=1):
 for i in r(12):
  for t in r(12):
   if(set((N.find(n[0])+" #".find(n[1:]))%12for n in s.split())==set(map(lambda n:(int(n,16)+i)%12,"0"+"47037048036057027047A37A37B47B48A369"[3*t:3*t+3]))):print(N[i],N[i+1]+"b")[N[i]==" "]+"M - + o sus4 sus2 7 -7 -M7 M7 +7 o7".split()[t];u=0
 if(u):print s

Commenti:

• Ho usato nomi di accordi alternativi dalla pagina Wiki (vedere la fine della linea lunga) per risparmiare spazio.
• Gli accordi sono rappresentati da 3 offset esadecimali ciascuno (0 non è richiesto ma incluso per le triadi per farli allineare).
• "#". find (n [1:]) funziona poiché "#". find ("b") è -1 e "#". find ("") è 0.

Uscita campione

>>> f("C D# G")
C-
>>> f("C Eb G")
C-
>>> f("C Eb F#")
Co
>>> f("F A C#")
Db+
F+
A+
>>> f("F D F F F F A A F")
D-
>>> f("C D")
C D
>>> f("C Eb Gb A")
Co7
Ebo7
Gbo7
Ao7