У музичній теорії інтервал - це різниця між двома смолами. Кожен крок визначається кількістю півкроків (Різниця між C і C #) або цілими кроками (Різниця між C і D). Один цілий крок - це те саме, що два півкроки. Ось список усіх інтервалів за замовчуванням та кількості напівкроків, які вони представляють:

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

Існують 3 варіанти інтервалів за замовчуванням, незначні , зменшені та збільшені .

• Мінорний інтервал один півкроку нижче основного інтервалу, але не ідеальний інтервал. Таким чином, у вас є другорядний (1), другорядний третій (3), другорядний шостий (8), а неповнолітній сьомий (10). Немає такого поняття, як другорядний четвертий, мінорний п'ятий, мінорний унісон або мінорна октава, оскільки це все ідеальні інтервали.

• Зменшений інтервал один півкроку нижче , ніж неповнолітній або досконалий інтервал. Є зменшене Друге (0), зменшене третє (2), зменшене четверте (4), зменшене п'яте (6), зменшене шосте (7), зменшене сьоме (9) і зменшене октава (11).

• Доповненої інтервал один півкроку вище , ніж основний або ідеальний інтервал. Ми збільшили Унісон (1), Доповнене друге (3), Доповнене третє (5), Доповнене четверте (6), Доповнене п'яте, (8), Доповнене шосте (10), і Доповнене сьоме (12).

Змагання:

Ви повинні написати програму або функцію, яка займає кількість півтора кроків або цілих кроків, а потім друкує один з дійсних англійських описів цього інтервалу. Не має значення, який опис ви виберете, якщо він точно відповідає таблиці IO. Ви можете прийняти це як один рядок

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

або як число і рядок / знак.

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

Можна припустити, що кожен вхід буде від 0 до 12 половинних кроків.

Стол IO

Ось повний список, який відображає кількість півкроків до всіх прийнятних результатів.

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   

Ось декілька зразків вводу / виводу:

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

Ruby, об. B 138 байт

->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 байт збережено, не повторюючи Augmented/Diminished. 1 байт збережено за допомогою ?h.

Рубі, об. А 144 байти

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

Ідея полягає в тому, щоб мінімізувати кількість базових інтервалів (лише сьома п’ята третина та унісон) та скористатися тим фактом, що сьома та п’ята частини мають аналогічну залежність між третьою та унізонною.

Існує чотири типи сьомий / третій і 3 типи п'ятий / унісон, тому змінна індексу iвстановлюється на 12 мінус кількість половини кроків, так що перший член виразу i%7/4 + i/7*2буде правильно вибирати тип базового інтервалу.

unolfolf у тестовій програмі

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

вихід

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

Не визначені введення поведінки: функція дає правильну відповідь diminished unionдля -1 півкроку, але не відповідає для входів більше 12. Наприклад, вона виводить perfect unisonза 14 півкроків , оскільки алгоритм заснований на циклі 14, а не 12.

Python 2, 149 байт

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]

Спочатку цілі етапи перетворюються на півкроки.

Потім, друкується Diminishedvs. AugmentedВони чергуються за суміжними, nокрім цього, n=5і n=6дають те саме, що досягається спочатку переведення їх через граничний модуль непарного числа.

Нарешті, відстань друкується, обчислюється за допомогою трибітної таблиці пошуку. Це коротше, ніж робити int('6746543230210'[n]).

Python 2.7, 155 байт

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]

Сітківка, 153 байти

\ d +
$ *
(. *) ш | год
$ 1 $ 1
^ 1 * $
$ .0
^ [02479] | 11
Зменшено $ 0
^ \ д
Додано $ 0
10 | 7
шостий
11
октава
12 | 9
сьомий
8
п'ятий
4 | 6
четвертий
5 | 2
третій
1
унісон
\ d
другий

Номер введення спочатку перетворюється на одинарний, потім подвоюється, якщо слідує за ним w, а будь-які літери видаляються, залишаючи лише одинарне число. Потім це число перетворюється назад у десятковий. Нарешті, деякий пошук і заміна застосовується для побудови кінцевого результату.

Приклад виконання:

6w => 111111w => 111111111111 => 12 => Доповнений 12 => Доданий сьомий
7h => 1111111h => 1111111 => 7 => Зменшено 7 => Зменшено шосте
3w => 111w => 111111 => 6 => Доповнене 6 => Доповнене четверте
0h => h => => 0 => Зменшено 0 => Зменшено секунду

Спробуйте в Інтернеті!

Віци , 166 байт

Ну, це, безумовно, може бути додатково гольф.

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

Це працює, визначаючи мінімальну кількість можливих елементів, потім викликаючи ці елементи через синтаксис методу.

Спробуйте в Інтернеті!

Javascript 189 байт

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 байт

Має бути кращий спосіб упакувати ці рядки, але я не маю жодних ідей.

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

Відступ:

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