Trong lý thuyết âm nhạc, một khoảng là sự khác biệt giữa hai cao độ. Mỗi bước được xác định bởi số lượng nửa bước (Sự khác biệt giữa C và C #) hoặc toàn bộ các bước (Sự khác biệt giữa C và D). Một bước hoàn toàn giống như hai nửa bước. Dưới đây là danh sách tất cả các khoảng mặc định và số lượng nửa bước mà chúng đại diện:

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

Có 3 biến thể trên các khoảng mặc định, nhỏ , giảm dần và tăng cường .

• Một khoảng nhỏ là một nửa bước thấp hơn một khoảng chính, nhưng không phải là một khoảng hoàn hảo. Vì vậy, bạn có một giây nhỏ (1), một phần ba nhỏ (3), một phần sáu nhỏ (8) và một phần bảy nhỏ (10). Không có thứ gọi là thứ tư nhỏ, thứ năm nhỏ, unison nhỏ hoặc quãng tám nhỏ vì đây là tất cả các khoảng hoàn hảo.

• Một khoảng giảm dần là một nửa bước so với một khoảng nhỏ hoặc hoàn hảo. Có giảm thứ hai (0), giảm thứ ba (2), giảm thứ tư (4), giảm thứ năm (6), giảm thứ sáu (7), giảm thứ bảy (9) và giảm quãng tám (11).

• Một Augmented khoảng là một nửa bước cao hơn một khoảng thời gian lớn hay hoàn hảo. Chúng tôi có Augmented Unison (1), Augmented Second (3), Augmented third (5), Augmented Fourth (6), Augmented five, (8), Augmented sixth (10), và Augmented 7th (12).

Các thách thức:

Bạn phải viết một chương trình hoặc chức năng thực hiện một số bước hoặc toàn bộ các bước và sau đó in một trong những mô tả tiếng Anh hợp lệ của khoảng này. Không quan trọng bạn chọn mô tả nào, miễn là nó khớp chính xác với bảng IO. Bạn có thể coi đây là một chuỗi

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

hoặc như một số và một chuỗi / char.

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

Bạn có thể giả định rằng mọi đầu vào sẽ nằm trong khoảng từ 0 đến 12 nửa bước.

Bảng IO

Dưới đây là danh sách đầy đủ ánh xạ số lượng nửa bước cho tất cả các đầu ra chấp nhận được.

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   

Đây là một số mẫu I / O:

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

Ruby, 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 được lưu bằng cách không lặp lại Augmented/Diminished. 1 byte được lưu bằng cách sử dụng ?h.

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

Ý tưởng là để giảm thiểu số lượng các khoảng cơ bản (chỉ thứ ba thứ ba và chỉ unison) và tận dụng thực tế là thứ bảy và thứ năm có mối quan hệ tương tự như giữa thứ ba và unisons.

Có bốn loại thứ bảy / thứ ba và 3 loại thứ năm / unison, vì vậy biến chỉ số iđược đặt thành 12 trừ đi số nửa bước, do đó, thuật ngữ đầu tiên của biểu thức i%7/4 + i/7*2sẽ chọn chính xác loại khoảng thời gian cơ bản.

vô dụng trong chương trình thử nghiệm

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

đầu ra

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

Đầu vào hành vi không xác định: Hàm đưa ra câu trả lời đúng diminished unioncho -1 nửa bước, nhưng không thành công cho đầu vào trên 12. Ví dụ: nó xuất ra perfect unison14 nửa bước, vì thuật toán dựa trên chu kỳ 14 thay vì 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]

Đầu tiên, toàn bộ các bước được chuyển đổi thành một nửa bước.

Sau đó, Diminishedvs Augmentedđược in. Chúng thay thế cho liền kề nngoại trừ điều đó n=5và n=6đưa ra tương tự, điều này đạt được bằng cách trước tiên đặt chúng trên một modulo biên một số lẻ.

Cuối cùng, khoảng cách được in, tính toán thông qua bảng tra cứu ba bit. Điều này ngắn hơn làm 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]

Võng mạc, 153 byte

\ d +
$ *
(. *) w | h
$ 1 $ 1
^ 1 * $
$ .0
^ [02479] | 11
Giảm 0 đô la
^ \ d
Tăng $ 0
10 | 7
thứ sáu
11
quãng tám
12 | 9
thứ bảy
số 8
thứ năm
4 | 6
thứ tư
5 | 2
ngày thứ ba
1
đồng thanh
\ d
thứ hai

Đầu vào số đầu tiên được chuyển đổi thành unary, sau đó nhân đôi nếu theo sau wvà bất kỳ chữ cái nào cũng bị xóa, chỉ để lại số unary. Số này sau đó được chuyển đổi thành số thập phân. Cuối cùng, một số tìm kiếm và thay thế được áp dụng để xây dựng đầu ra cuối cùng.

Ví dụ chạy:

6w => 111111w => 111111111111 => 12 => Augmented 12 => Augmented Seventh
7h => 1111111h => 1111111 => 7 => Giảm 7 => Giảm thứ sáu
3w => 111w => 111111 => 6 => Đã tăng 6 => Thứ tư tăng
0h => h => => 0 => Giảm 0 => Giảm thứ hai

Hãy thử trực tuyến!

Vitsy , 166 byte

Vâng, điều này chắc chắn có thể được tiếp tục chơi golf.

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

Điều này hoạt động bằng cách xác định số lượng mục tối thiểu có thể, sau đó gọi các mục đó thông qua cú pháp phương thức.

Hãy thử trực tuyến!

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

Có một cách tốt hơn để đóng gói các chuỗi này nhưng tôi không có ý tưởng nào.

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

Thụt lề:

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