Nella teoria musicale, un intervallo è la differenza tra due toni. Ogni passo è definito dal numero di semipassi (La differenza tra C e C #) o interi passi (La differenza tra C e D). Un intero passaggio equivale a due mezze fasi. Ecco un elenco di tutti gli intervalli predefiniti e il numero di semiprezi che rappresentano:

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

Esistono 3 variazioni sugli intervalli predefiniti, minore , diminuito e aumentato .

• Un intervallo minore è inferiore di un mezzo passo rispetto a un intervallo maggiore, ma non è un intervallo perfetto. Quindi hai un secondo minore (1), un terzo minore (3), un sesto minore (8) e un settimo minore (10). Non esiste una quarta minore, una quinta minore, unisono minore o un'ottava minore poiché sono tutti intervalli perfetti.

• Un intervallo ridotto è inferiore di un mezzo passo rispetto a un intervallo minore o perfetto. Vi è una seconda (0) ridotta, una terza (2) ridotta, una quarta (4), una quinta (6), una sesta (7), una settima (9) e un'ottava ridotta (11).

• Un intervallo aumentato è di mezzo passo in più rispetto a un intervallo maggiore o perfetto. Abbiamo Augmented Unison (1), Augmented Second (3), Augmented Third (5), Augmented Fourth (6), Augmented 5th, (8), Augmented Sixth (10) e Augmented Seventh (12).

La sfida:

È necessario scrivere un programma o una funzione che richiede un numero di mezze fasi o intere fasi e quindi stampa una delle descrizioni inglesi valide di questo intervallo. Non importa quale descrizione scegli, purché corrisponda esattamente alla tabella IO. Puoi prenderlo come una stringa

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

o come un numero e una stringa / carattere.

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

Si può presumere che ogni input sarà compreso tra 0 e 12 mezze fasi.

Tabella IO

Ecco un elenco completo che associa il numero di semipassi a tutti gli output accettabili.

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   

Ecco alcuni esempi di I / O:

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

Rubino, Rev B 138 byte

->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 byte salvati non ripetendo Augmented/Diminished. 1 byte salvato utilizzando ?h.

Rubino, Rev. A 144 byte

->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'idea è di ridurre al minimo il numero di intervalli di base (solo settimo quinto terzo e unisono) e sfruttare il fatto che settimo e quinto hanno una relazione analoga a quella tra terzi e unisono.

Esistono quattro tipi di settimo / terzo e 3 tipi di quinto / unisono, quindi la variabile indice iè impostata su 12 meno il numero di mezze fasi, in modo che il primo termine dell'espressione i%7/4 + i/7*2selezionerà correttamente il tipo di intervallo di base.

non golfato nel programma di 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']
}

produzione

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

Input comportamentali non diminished uniondefiniti : la funzione fornisce la risposta corretta di -1 half-step, ma fallisce per input superiori a 12. Ad esempio, genera output perfect unisonper 14 half-step, poiché l'algoritmo si basa su un ciclo di 14 anziché 12.

Python 2, 149 byte

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]

Innanzitutto, interi passaggi vengono convertiti in mezze fasi.

Quindi, viene stampato Diminishedvs. AugmentedQuesti si alternano per adiacente ntranne quello n=5e n=6danno lo stesso, che si ottiene mettendo prima un modulo dispari su un confine.

Infine, la distanza viene stampata, calcolata tramite una tabella di ricerca a tre bit. Questo è più breve del fare int('6746543230210'[n]).

Python 2.7, 155 byte

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 byte

\ D +
$ *
w (*.) | h
$ 1 $ 1
^ 1 * $
$ .0
^ [02479] | 11
Diminuito $ 0
^ \ D
Aumentato $ 0
10 | 7
sesto
11
ottava
12 | 9
settimo
8
quinto
4 | 6
il quarto
5 | 2
terzo
1
unisono
\ d
secondo

Il numero di input viene prima convertito in unario, quindi raddoppiato se seguito da w, e le lettere vengono rimosse, lasciando solo il numero unario. Questo numero viene quindi riconvertito in decimale. Infine, viene applicato un po 'di ricerca e sostituzione per costruire l'output finale.

Esempi di esecuzione:

6w => 111111w => 111111111111 => 12 => Aumentato 12 => Aumentato settimo
7h => 1111111h => 1111111 => 7 => Diminuito 7 => Diminuito sesto
3w => 111w => 111111 => 6 => Aumentato 6 => Aumentato quarto
0h => h => => 0 => Diminuito 0 => Diminuito secondo

Provalo online!

Vitsy , 166 byte

Bene, questo può sicuramente essere ulteriormente golfato.

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

Questo funziona definendo la quantità minima di elementi possibile, quindi chiamando tali elementi attraverso la sintassi del metodo.

Provalo online!

Javascript 189 byte

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 byte

Deve esserci un modo migliore per impacchettare queste stringhe ma non ne ho 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];}

rientrato:

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