В теории музыки интервал - это разница между двумя высотами. Каждый шаг определяется количеством полушагов (разница между 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).

Соревнование:

Вы должны написать программу или функцию, которая выполняет несколько полушагов или целых шагов, а затем печатает одно из действительных английских описаний этого интервала. Неважно, какое описание вы выберете, если оно точно соответствует таблице ввода-вывода. Вы можете принять это как одну строку

"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, Rev 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.

Ruby, Rev A 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правильно выбирал тип базового интервала.

разряженный в тестовой программе

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 unison14 полушагов , поскольку алгоритм основан на цикле 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]

Сначала целые шаги преобразуются в полшага.

Затем Diminishedпротив 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,0
^ [02479] | 11
Уменьшенный 0 $
^ \ D
Дополненный $ 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];
};