W teorii muzyki odstęp jest różnicą między dwoma tonami. Każdy skok jest zdefiniowany przez liczbę pół kroków (Różnica między C i C #) lub całych kroków (Różnica między C i D). Jeden cały krok jest taki sam jak dwa pół-kroki. Oto lista wszystkich domyślnych interwałów i liczby reprezentowanych przez nie kroków:

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

Istnieją 3 warianty domyślnych przedziałów, niewielkie , zmniejszone i rozszerzone .

• Moll przedział jest pół kroku niższy niż poważnej przerwie, ale nie idealny przedział. Masz więc małą sekundę (1), małą trzecią (3), małą szóstą (8) i małą siódmą (10). Nie ma czegoś takiego jak pomniejsza czwarta, pomniejsza piąta, pomniejsza unisona lub pomniejsza oktawa, ponieważ są to idealne odstępy.

• Zmniejszony odstęp jest pół kroku niższy niż małoletniego lub idealnego przedziału. Istnieje zmniejszona druga (0), zmniejszona trzecia (2), zmniejszona czwarta (4), zmniejszona piąta (6), zmniejszona szósta (7), zmniejszona siódma (9) i zmniejszona oktawa (11).

• Augmented przedział jest pół kroku wyższa niż poważnej lub idealnego przedziału. Mamy Rozszerzony Unison (1), Rozszerzony Drugi (3), Rozszerzony trzeci (5), Rozszerzony Czwarty (6), Rozszerzony Piąty, (8), Rozszerzony Szósty (10) i Rozszerzony Siódmy (12).

Wyzwanie:

Musisz napisać program lub funkcję, która wykonuje kilka kroków o połowę lub całość, a następnie drukuje jeden z poprawnych angielskich opisów tego przedziału. Nie ma znaczenia, który opis wybierzesz, o ile dokładnie pasuje do tabeli We / Wy. Możesz wziąć to jako jeden ciąg

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

lub jako liczba i ciąg / char.

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

Możesz założyć, że każde wejście będzie miało wartość od 0 do 12 pół kroku.

Stół IO

Oto pełna lista odwzorowująca liczbę kroków o krok do wszystkich dopuszczalnych wyników.

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   

Oto kilka przykładowych operacji we / wy:

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

Ruby, Rev B 138 bajtów

->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 bajtów zapisanych przez brak powtarzania Augmented/Diminished. 1 bajt zapisany przy użyciu ?h.

Ruby, Rev A 144 bajty

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

Chodzi o to, aby zminimalizować liczbę podstawowych przedziałów (tylko siódma piąta trzecia i tylko unison) i wykorzystać fakt, że siódme i piąte mają analogiczny związek z tym, co pomiędzy trzecimi i unisons.

Istnieją cztery typy siódmego / trzeciego i 3 typy piątego / unisonu, więc zmienna indeksu ijest ustawiona na 12 minus liczba pół kroków, tak aby pierwszy termin wyrażenia i%7/4 + i/7*2poprawnie wybrał typ podstawowego interwału.

nie wziął udziału w programie testowym

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

wynik

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

Nieokreślone dane wejściowe zachowania: Funkcja daje poprawną odpowiedź diminished uniondla -1 pół kroku, ale nie powiedzie się dla danych wejściowych powyżej 12. Na przykład daje wynik perfect unisondla 14 pół kroków, ponieważ algorytm opiera się na cyklu 14 zamiast 12.

Python 2, 149 bajtów

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]

Po pierwsze, całe kroki są konwertowane na pół kroki.

Następnie drukowane jest Diminishedvs. AugmentedTe zamieniają się na sąsiednie nz wyjątkiem tego n=5i n=6dają to samo, co osiąga się przez umieszczenie ich w poprzek modułu granicznego nieparzystej liczby.

Na koniec drukowana jest odległość obliczona za pomocą trzybitowej tabeli odnośników. To jest krótsze niż robienie int('6746543230210'[n]).

Python 2.7, 155 bajtów

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]

Siatkówka, 153 bajty

\ d +
$ *
(. *) w | h
1 USD 1 USD
^ 1 * $
0,0 $
^ [02479] | 11
Zmniejszone 0 USD
^ \ d
Zwiększony o 0 USD
10 | 7
szósty
11
oktawa
12 | 9
siódmy
8
piąty
4 | 6
czwarty
5 | 2
trzeci
1
unisono
\re
druga

Numer wejściowy jest najpierw konwertowany na unarny, a następnie podwojony, po którym następuje w, a wszelkie litery są usuwane, pozostawiając tylko liczbę jednoargumentową. Liczba ta jest następnie konwertowana z powrotem na dziesiętną. Na koniec zastosowano wyszukiwanie i zamianę w celu skonstruowania ostatecznego wyniku.

Przykładowe przebiegi:

6w => 111111w => 111111111111 => 12 => Rozszerzony 12 => Rozszerzony siódmy
7h => 1111111h => 1111111 => 7 => Zmniejszony 7 => Zmniejszony szósty
3w => 111w => 111111 => 6 => Rozszerzony 6 => Rozszerzony czwarty
0h => h => => 0 => Zmniejszony 0 => Zmniejszony drugi

Wypróbuj online!

Vitsy , 166 bajtów

Cóż, zdecydowanie można to pograć w golfa.

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

Działa to poprzez zdefiniowanie minimalnej możliwej liczby elementów, a następnie wywołanie tych elementów za pomocą składni metody.

Wypróbuj online!

JavaScript 189 bajtów

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 bajty

Musi być lepszy sposób na spakowanie tych ciągów, ale nie mam żadnych pomysłów.

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

Zębaty:

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