En teoría musical, un intervalo es la diferencia entre dos tonos. Cada tono se define por el número de medios pasos (La diferencia entre C y C #) o pasos completos (La diferencia entre C y D). Un paso completo es lo mismo que dos medios pasos. Aquí hay una lista de todos los intervalos predeterminados y el número de medios pasos que representan:

0     Perfect Unison
2     Major Second
4     Major Third
5     Perfect Fourth
7     Perfect Fifth
9     Major Sixth
11    Major Seventh
12    Perfect Octave

Hay 3 variaciones en los intervalos predeterminados, menores , disminuidos y aumentados .

• Un intervalo menor es medio paso más bajo que un intervalo mayor, pero no es un intervalo perfecto. Entonces tienes un segundo menor (1), un tercero menor (3), un sexto menor (8) y un séptimo menor (10). No existe un cuarto menor, un quinto menor, unísono menor u octava menor, ya que todos estos son intervalos perfectos.

• Un intervalo disminuido es medio paso más bajo que un intervalo menor o perfecto. Hay segundo disminuido (0), tercero disminuido (2), cuarto disminuido (4), quinto disminuido (6), sexto disminuido (7), séptimo disminuido (9) y octava disminuida (11).

• Un intervalo aumentado es medio paso más alto que un intervalo mayor o perfecto. Hemos aumentado Unison (1), Aumento de segundo (3), Aumento de tercero (5), Aumento de cuarto (6), Aumento de quinto, (8), Aumento de sexto (10) y Aumento de séptimo (12).

El reto:

Debe escribir un programa o función que tome varios medios pasos o pasos completos y luego imprima una de las descripciones válidas en inglés de este intervalo. No importa qué descripción elija, siempre que coincida exactamente con la tabla IO. Puedes tomar esto como una cadena

"5w" == 5 whole steps
"3h" == 3 half steps

o como un número y una cadena / char.

5, "w" == 5 whole steps
3, "h" == 3 half steps.

Puede suponer que cada entrada tendrá entre 0 y 12 medios pasos.

Mesa IO

Aquí hay una lista completa que asigna el número de medios pasos a todas las salidas aceptables.

0       Perfect unison, Diminished second   
1       Minor second, Augmented unison  
2       Major second, Diminished third  
3       Minor third, Augmented second   
4       Major third, Diminished fourth  
5       Perfect fourth, Augmented third     
6       Diminished fifth, Augmented fourth  
7       Perfect fifth, Diminished sixth 
8       Minor sixth, Augmented fifth        
9       Major sixth, Diminished seventh 
10      Minor seventh, Augmented sixth      
11      Major seventh, Diminished octave    
12      Perfect octave, Augmented seventh   

Aquí hay algunos ejemplos de E / S:

5w      Minor Seventh
5h      Augmented Third
12h     Perfect Octave
12w     UNDEFINED
1w      Diminished third
2h      Major Second

Ruby, Rev B 138 bytes

->n,s{i=12-n-n*(s<=>?h)
[a='Augmented','Major','Minor',d='Diminished',a,'Perfect',d][i%7]+' '+%w{seventh fifth third unison}[i%7/4+i/7*2]}

5 bytes guardados al no repetir Augmented/Diminished. 1 byte guardado mediante el uso de ?h.

Ruby, Rev A 144 bytes

->n,s{i=12-n-n*(s<=>'h')
%w{Augmented Major Minor Diminished Augmented Perfect Diminished}[i%7]+' '+%w{seventh fifth third unison}[i%7/4+i/7*2]}

La idea es minimizar el número de intervalos básicos (séptimo quinto tercio y solo al unísono) y aprovechar el hecho de que los séptimos y quintos tienen una relación análoga a la de los tercios y las uniones.

Hay cuatro tipos de séptimo / tercero y 3 tipos de quinto / unísono, por lo que la variable de índice ise establece en 12 menos el número de medios pasos, de modo que el primer término de la expresión i%7/4 + i/7*2seleccionará correctamente el tipo de intervalo básico.

sin golf en el programa de prueba

f=->n,s{                 #n = number of steps. s= step size, w or h
  i=12-n-n*(s<=>'h')     # i=12-n. If s is later in the alphabet than 'h' subtract again for whole steps
  %w{Augmented Major Minor Diminished Augmented Perfect Diminished}[i%7]+
  ' '+%w{seventh fifth third unison}[i%7/4+i/7*2]
}

-1.upto(12){|j|
puts f[j,'h']
}  

0.upto(6){|j|
puts f[j,'w']
}

salida

Diminished unison
Perfect unison
Augmented unison
Diminished third
Minor third
Major third
Augmented third
Diminished fifth
Perfect fifth
Augmented fifth
Diminished seventh
Minor seventh
Major seventh
Augmented seventh

Perfect unison
Diminished third
Major third
Diminished fifth
Augmented fifth
Minor seventh
Augmented seventh

Entradas de comportamiento indefinido: la función proporciona la respuesta correcta de diminished union-1 medios pasos, pero falla para las entradas superiores a 12. Por ejemplo, genera perfect unison14 medios pasos, ya que el algoritmo se basa en un ciclo de 14 en lugar de 12.

Python 2, 149 bytes

def f(n,c):n*=1+(c>'h');print(n-6)%13%2*"Diminished"or"Augmented",'octave seventh sixth fifth fourth third second unison'.split()[71056674174>>3*n&7]

Primero, los pasos completos se convierten en medios pasos.

Entonces, Diminishedvs Augmentedse imprime. Estos se alternan para adyacentes, nexcepto eso, n=5y n=6dan lo mismo, lo cual se logra al colocarlos primero en un módulo de límite un número impar.

Finalmente, la distancia se imprime y se calcula mediante una tabla de búsqueda de tres bits. Esto es más corto que hacerlo int('6746543230210'[n]).

Python 2.7, 155 bytes

s='second unison third fourth sixth fifth seventh octave Diminished Augmented'.split()
def f(n,c):x=0xDE9CB87561430>>[4,8][c>'h']*n;print s[x%2+8],s[x/2%8]

Retina, 153 bytes

\ d +
PS
(. *) w | h
$ 1 $ 1
^ 1 * $
$ .0
^ [02479] | 11
Disminuido $ 0
^ \ d
Aumentado $ 0
10 | 7
sexto
11
octava
12 | 9
séptimo
8
quinto
4 | 6
cuarto
5 | 2
tercero
1
unísono
\re
segundo

El número de entrada se convierte primero en unario, luego se duplica si se sigue wy se eliminan las letras, dejando solo el número unario. Este número se convierte de nuevo a decimal. Finalmente, se aplica alguna búsqueda y reemplazo para construir el resultado final.

Ejecuciones de ejemplo:

6w => 111111w => 111111111111 => 12 => Aumentado 12 => Aumentado séptimo
7h => 1111111h => 1111111 => 7 => Disminuido 7 => Disminuido sexto
3w => 111w => 111111 => 6 => Aumentado 6 => Cuarto aumentado
0h => h => => 0 => Disminuido 0 => Disminuido segundo

Pruébalo en línea!

Vitsy , 166 bytes

Bueno, esto definitivamente puede ser más golfizado.

WW2M1+*a+mZ
'dehsinimiD'
'roniM'
'rojaM'
'tcefreP'
'detnemguA'
'dnoces '
'htruof '
'htxis '
'evatco '
6m1m
6m2m
6m3m
6m5m
7m1m
7m4m
7m5m
8m1m
8m2m
8m3m
8m5m
9m1m
9m4m

Esto funciona definiendo la cantidad mínima de elementos posibles, y luego llamando esos elementos a través de la sintaxis del método.

Pruébalo en línea!

Javascript 189 bytes

a=>(n='sutsftfxFvxov'[N=parseInt(a)*(a.slice(-1)>'v'?2:1)])&&((N>5?N+1:N)%2?'Augmented ':'Dimished ')+'unison,second,third,fourth,fifth,sixth,seventh,octave'.split`,`['ustfFxvo'.indexOf(n)]



 F=
  a=>
    (n='sutsftfxFvxov' //using the right side of the possible answers
                       //set n = the letter representing
                       //unison, first, second ...

       //set N to 12 for 12h, but 24 for 12w
       [N=parseInt(a)*(a.slice(-1)>'v'?2:1)])

  &&   //if we were out of range (12w) we'll return undefined


    (
      (N>5?N+1:N)%2?  //get Aug or Dim (right side goes)
                      //DADADAADADADA
                      //     ^^ makes this a pain
       'Augmented ':'Dimished '
     )
     +
            //turn n (which is u for unison, x for sixth, etc
            //into it's full name
       'unison,second,third,fourth,fifth,sixth,seventh,octave'
         .split`,`
     ['ustfFxvo'.indexOf(a)]

Java, 225 224 bytes

Tiene que haber una mejor manera de empacar estas cadenas, pero no tengo ninguna idea.

(i,s)->{String A="Augmented",M="Major",m="Minor",P="Perfect",D="Diminished",d=" Second",f=" Fourth",a=" Sixth",C=" Octave";String[]o=new String[]{D+d,m+d,M+d,A+d,P+f,A+f,D+a,m+a,M+a,A+a,D+C,P+C};i*=s=='w'?2:1;return o[i-1];}

Sangrado:

static BiFunction<Integer, Character, String> interval = (i,s) -> {
    String A="Augmented",M="Major",m="Minor",P="Perfect",D="Diminished",
            d=" Second",f=" Fourth",a=" Sixth",C=" Octave";
    String[] o = new String[] {D+d,m+d,M+d,A+d,P+f,A+f,D+a,m+a,M+a,A+a,D+C,P+C};
    i *= s=='w' ? 2 : 1;
    return o[i-1];
};