En théorie musicale, un intervalle est la différence entre deux hauteurs. Chaque pas est défini par le nombre de demi-pas (la différence entre C et C #) ou de pas entiers (la différence entre C et D). Une étape entière équivaut à deux demi-étapes. Voici une liste de tous les intervalles par défaut et du nombre de demi-pas qu'ils représentent:

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

Il existe 3 variations sur les intervalles par défaut, mineures , diminuées et augmentées .

• Un intervalle mineur est inférieur d'un demi-pas à un intervalle majeur, mais pas un intervalle parfait. Vous avez donc une seconde mineure (1), une troisième mineure (3), une mineure sixième (8) et une mineure septième (10). Il n'y a pas de quatrième mineur, cinquième mineur, unisson mineur ou octave mineure, car ce sont tous des intervalles parfaits.

• Un intervalle diminué est inférieur d'un demi-pas à un intervalle mineur ou parfait. Il y a la seconde diminuée (0), la troisième diminuée (2), la quatrième diminuée (4), la cinquième diminuée (6), la sixième diminuée (7), la septième diminuée (9) et l'octave diminuée (11).

• Un intervalle augmenté est un demi-pas plus haut qu'un intervalle majeur ou parfait. Nous avons l'union augmentée (1), la seconde augmentée (3), la troisième augmentée (5), la quatrième augmentée (6), la cinquième augmentée, (8), la sixième augmentée (10) et la septième augmentée (12).

Le défi:

Vous devez écrire un programme ou une fonction qui prend un certain nombre de demi-étapes ou des étapes entières, puis imprime l' une des descriptions anglaises valides de cet intervalle. Peu importe la description que vous choisissez, tant qu'elle correspond exactement à la table d'E / S. Vous pouvez prendre cela comme une chaîne

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

ou sous forme de nombre et de chaîne / caractère.

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

Vous pouvez supposer que chaque entrée sera comprise entre 0 et 12 demi-pas.

Table IO

Voici une liste complète mappant le nombre de demi-étapes à toutes les sorties acceptables.

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   

Voici quelques exemples d'E / S:

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

Ruby, Rev B 138 octets

->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 octets enregistrés en ne se répétant pas Augmented/Diminished. 1 octet enregistré en utilisant ?h.

Ruby, Rev A 144 octets

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

L'idée est de minimiser le nombre d'intervalles de base (septième cinquième tiers et à l'unisson seulement) et de profiter du fait que les septièmes et les cinquièmes ont une relation analogue à celle entre les tiers et les unisons.

Il existe quatre types de septième / troisième et 3 types de cinquième / unisson, de sorte que la variable d'index iest définie sur 12 moins le nombre de demi-pas, de sorte que le premier terme de l'expression i%7/4 + i/7*2sélectionne correctement le type d'intervalle de base.

non golfé dans le programme de test

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

production

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

Entrées de comportement indéfinies: la fonction donne la bonne réponse diminished unionpour -1 demi-pas, mais échoue pour les entrées supérieures à 12. Par exemple, elle génère perfect unison14 demi-étapes, car l'algorithme est basé sur un cycle de 14 plutôt que de 12.

Python 2, 149 octets

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]

Tout d'abord, des étapes entières sont converties en demi-étapes.

Ensuite, Diminishedvs Augmentedest imprimé. Ceux-ci alternent pour adjacents nsauf cela n=5et n=6donnent le même, ce qui est obtenu en les plaçant d'abord à travers un module modulo limite un nombre impair.

Enfin, la distance est imprimée, calculée via une table de recherche à trois bits. C'est plus court que de le faire int('6746543230210'[n]).

Python 2.7, 155 octets

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]

Rétine, 153 octets

\ d +
$ *
(. *) w | h
1 $ 1 $
^ 1 * $
0,0 $
^ [02479] | 11
Diminué 0 $
^ \ d
0 $ augmenté
10 | 7
sixième
11
octave
12 | 9
septième
8
cinquième
4 | 6
Quatrième
5 | 2
troisième
1
unisson
\ré
seconde

Le numéro d'entrée est d'abord converti en unaire, puis doublé s'il est suivi de w, et toutes les lettres sont supprimées, ne laissant que le numéro unaire. Ce nombre est ensuite reconverti en décimal. Enfin, une recherche et un remplacement sont appliqués pour construire la sortie finale.

L'exemple s'exécute:

6w => 111111w => 111111111111 => 12 => augmenté 12 => augmenté septième
7h => 1111111h => 1111111 => 7 => Diminué 7 => Diminué sixième
3w => 111w => 111111 => 6 => augmenté 6 => quatrième augmenté
0h => h => => 0 => diminué 0 => deuxième diminué

Essayez-le en ligne!

Vitsy , 166 octets

Eh bien, cela peut certainement être approfondi.

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

Cela fonctionne en définissant la quantité minimale d'éléments possible, puis en appelant ces éléments via la syntaxe de la méthode.

Essayez-le en ligne!

Javascript 189 octets

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 octets

Il doit y avoir une meilleure façon d'emballer ces cordes mais je n'ai aucune idée.

(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];}

Dentelé:

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