在音乐理论中，间隔是两个音高之间的差。每个音高由半步数（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）减小。

• 一个增强间隔是一个半步更高的比重大的或完美的时间间隔。我们拥有增强的Unison（1），增强的Second（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   

这是一些示例I / O：

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。

Ruby，修订版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种类型，因此将index变量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 unison，由于算法基于14个周期而不是12个周期，因此输出14个半步。

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 +
$ *
（。*）w | h
$ 1 $ 1
^ 1 * $
$ .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 =>减小秒

在线尝试！

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