Đưa ra hai tên ghi chú, bạn phải viết một chương trình xác định xem khoảng thời gian được tạo bởi hai ghi chú này là phụ âm hay phụ âm.

Giới thiệu

Trong âm nhạc phương Tây, chỉ có 12 âm "khác nhau". Tên của họ, được sắp xếp từ thấp nhất đến cao nhất, là : C, C#, D, D#, E, F, F#, G, G#, A, A#, B. Trình tự là theo chu kỳ, tức là nó tiếp tục với cái khác Csau B, vô tận.

Khoảng cách giữa hai âm được gọi là một khoảng . Khoảng cách giữa bất kỳ hai ghi chú rằng là liền kề trong loạt trên (ví dụ C — C#hay E — F) được gọi là một semitone . Khoảng thời gian giữa các ghi chú xa hơn được định nghĩa là số bước nửa cung cần thiết để có được từ lần đầu tiên đến lần thứ hai (trong khi có thể bao quanh chuỗi). Một số ví dụ: D to E= 2 semitones, C to G= 7 semitones, B to D#= 4 semitones (phần này bao quanh chuỗi). ¹

Bây giờ, các khoảng này được chia thành hai loại: phụ âm (âm thanh dễ chịu nếu bạn chơi hai nốt cùng một lúc) và không đồng nhất (không quá nhiều).

Hãy xác định các khoảng phụ âm là: 0, 3, 4, 5, 7, 8 và 9 semitones.

Phần còn lại của chúng là không đồng nhất, cụ thể là: 1, 2, 6, 10 và 11 semitones.

Các thách thức

Viết một "chương trình" (theo nghĩa rộng thông thường của từ này: một hàm hoàn toàn ổn) để làm như sau:

• Lấy hai tên ghi chú (chuỗi từ chuỗi trên) làm đầu vào. Bạn có thể lấy chúng theo cách bạn thích (từ stdin, làm đối số, được phân tách bằng bất cứ thứ gì bạn muốn, thậm chí thoải mái lấy chúng làm danh sách các ký tự (ví dụ ["C","#"]). Tuy nhiên, bạn không được gán bất kỳ tên nào khác cho ghi chú (đặc biệt là bạn không được đánh số chúng từ 0 đến 11 và sử dụng các số).

• Đối với bạn những người đam mê âm nhạc ngoài kia, các ghi chú sẽ được chỉ định mà không có quãng tám. Trong trường hợp này, nó cũng không quan trọng theo thứ tự các ghi chú đến và thấp hơn và cao hơn. Cuối cùng, bạn không cần phải xử lý bất kỳ tên nào không có trong danh sách trên. Không có cải tiến khác như E#, không có căn hộ, thay đổi kép và như vậy.

• Chọn bất kỳ hai giá trị khác nhau. Chương trình của bạn phải xuất một trong số chúng bất cứ khi nào khoảng thời gian được hình thành bởi hai ghi chú trong đầu vào là phụ âm và cái còn lại nếu không. (Có thể Truevà False, nhưng thậm chí là π và e nếu bạn muốn :))

• Đây là một mã golf. Chương trình ngắn nhất tính theo byte trong mỗi ngôn ngữ sẽ thắng. Chúc vui vẻ!

Ví dụ và trường hợp thử nghiệm

Note 1    Note 2    Output    Interval [semitones]
  C          D     Dissonant   2
  A#         A#    Consonant   0
  G          D     Consonant   7 (wraparound)
  D#         A     Dissonant   6
  F          E     Dissonant   11
  A          C     Consonant   3

Tôi không thêm nhiều người trong số họ vì không có trường hợp đặc biệt nguy hiểm nào trong việc này.

Đây là một thử thách đầu tiên của tôi, vì vậy mọi lời chỉ trích mang tính xây dựng đều được chào đón nồng nhiệt:. Nếu bạn thấy lý thuyết cẩu thả, hãy đặt câu hỏi. Cuối cùng, xin đừng nói với tôi rằng đây là bản sao của cái này hay cái này . Tôi chắc chắn là không. (Cái sau khá giống nhưng phức tạp hơn. Tôi nghĩ rằng việc đưa ra một thử thách đơn giản hơn một chút sẽ giúp mọi người tham gia dễ dàng hơn.)

Thạch , 21 byte

Lấy đầu vào là một danh sách của hai chuỗi. Trả về cho phụ âm 0hoặc 1cho phụ âm.

OḢ6×%21_Lµ€IA“¬ɠṘ’æ»Ḃ

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

OḢ6×%21_Lµ€IA“¬ɠṘ’æ»Ḃ   - main link
         µ€             - for each note             e.g. ["A#", "C"]
O                       -   convert to ASCII codes  -->  [[65, 35], 67]
 Ḣ                      -   keep the first element  -->  [65, 67]
  6×                    -   multiply by 6           -->  [390, 402]
    %21                 -   modulo 21               -->  [12, 3]
       _L               -   subtract the length     -->  [12, 3] - [2, 1] = [10, 2]
           IA           - absolute difference       -->  8
             “¬ɠṘ’      - the integer 540205
                  æ»    - right-shift               -->  540205 >> 8 = 2110
                    Ḃ   - isolate the LSB           -->  2110 & 1 = 0

Tạo nên

Trước tiên chúng ta nên lưu ý rằng hàm F mà chúng ta đang tìm kiếm là giao hoán: đối với bất kỳ cặp ghi chú nào (A, B) , chúng ta có F (A, B) = F (B, A) .

Vì không có quá nhiều đầu vào khả dĩ và chỉ có 2 đầu ra khả dĩ để xử lý, nên có thể tìm thấy hàm băm khá đơn giản H , sao cho | H (A) - H (B) | tạo ra một phạm vi giá trị giới hạn và không va chạm cho tất cả các cặp ghi chú có thể có (A, B) đối với đầu ra dự kiến.

Chúng tôi sẽ kiểm tra tập hợp các hàm H (mul, mod) , được định nghĩa là:

H(mul, mod)(s) = ((ORD(s[0]) * mul) MOD mod) - LEN(s)

ORD(s[0])Mã ASCII ở đâu là ký tự đầu tiên của ghi chú và LEN(s)là độ dài của ghi chú ( 2 nếu có a '#'và 1 nếu không).

Dưới đây là một phiên bản nhận xét của mã JS đã được sử dụng để tìm một cặp cặp hợp lệ (mul, mod) và bitmasks kết quả. Có nhiều giải pháp khả thi, nhưng * 6 % 21là giải pháp ngắn nhất với phương pháp này.

// all 12 notes
note = ['C','C#','D','D#','E','F','F#','G','G#','A','A#','B'];

// reference implementation that takes 2 notes
// and returns 0 for dissonant or 1 for consonant
F = (a, b) =>
  +!~[1, 2, 6, 10, 11].indexOf((note.indexOf(a) - note.indexOf(b) + 12) % 12)

for(mul = 1; mul < 100; mul++) {
  for(mod = 1; mod < 31; mod++) {
    // hash function
    H = s => s.charCodeAt() * mul % mod - s.length;

    table = {};

    // for all possible pairs of notes (a, b)
    if(note.every(a => note.every(b => {
      // compute the table index
      idx = Math.abs(H(a) - H(b));

      // and the expected result
      res = F(a, b);

      // if the slot is empty, store the correct value
      if(table[idx] === undefined) {
        table[idx] = res;
        return 1;
      }
      // else, make sure that the correct value is already there
      return table[idx] == res;
    }))) {
      // if all tests pass: translate the table into a binary mask
      for(n = 0, msk = 0; n < 31; n++) {
        msk |= (table[n] || 0) << n;
      }
      // and display the result
      console.log('mul ' + mul + ', mod ' + mod + ' --> ' + msk);
    }
  }
}

APL (Dyalog) , 62 39 byte

Công dụng ⎕IO←0; 0 là phụ âm, 1 là phụ âm. Đưa danh sách các ký tự ghi chú cơ sở làm đối số bên trái và danh sách các phần tử sắc nét làm đối số bên phải.

{⎕A[|-/('C D EF G A '⍳⍺)+⍵=⍕#]∊'BCGKL'}

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

{... } chức năng ẩn danh nơi ⍺là lập luận trái và ⍵là lập luận đúng

 ⎕A[Có phải ]∊'BCGKL' là một lph.us, được lập chỉ mục bởi những người sau đây, một thành viên của chuỗi?

  ⍕# định dạng không gian tên gốc (mang lại ký tự sắc nét)

  ⍵= các ký tự đối số đúng (các sắc nét) có bằng không?

  (... )+ thêm những điều sau đây:

   'C D EF G A '⍳⍺ các chỉ số của ký tự đối số bên trái trong chuỗi

  -/ sự khác biệt giữa những

  | giá trị tuyệt đối

MATL , 30 27 26 byte

,j'DJEFPGIALBC'&mQs]ZP7Mdm

Nhập hai ghi chú trong các dòng khác nhau. Đầu ra 0cho phụ âm, 1cho phụ âm .

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Chuỗi 11 ký tự

DJEFPGIALBC

mã hóa cả ghi chú và khoảng thời gian không đồng nhất, như sau.

Chương trình trước tiên tìm các chỉ số dựa trên 1 của các ký tự đầu vào trong chuỗi trên. Một đầu vào không sắc nét như Dsẽ cho 1, Esẽ cho 3, ..., Csẽ cho 11. Những số này cũng có thể được coi là mảng số 1 × 1. Một đầu vào sắc nét như C#sẽ cho mảng 1 × 2 [11 0], có nghĩa là Cđược tìm thấy tại vị trí 11và #không được tìm thấy.

Quan sát rằng các chữ cái JPILsẽ không bao giờ có mặt trong đầu vào. Cho đến nay, chúng chỉ được sử dụng làm trình giữ chỗ, do đó, ví dụ ghi chú Elà hai nửa cung ở trên D. Nhưng chúng cũng sẽ hữu ích để xác định khoảng thời gian không đồng nhất.

Các số trong mục nhập đầu tiên của mảng 1 × 1 hoặc 1 × 2 tương ứng với nốt ghi chú trong nửa cung, không tính các ký hiệu sắc nét (chưa). Quan sát rằng thang đo được xác định bởi những con số này không bắt đầu tại C; nhưng điều đó không quan trọng bởi vì chúng tôi chỉ muốn khoảng thời gian, đó là sự khác biệt giữa các ghi chú. Trừ các số có được sẽ cho khoảng hoặc 12 trừ đi khoảng. Nhưng trước tiên chúng ta cần xem xét biểu tượng sắc nét.

Để xem xét các ghi chú sắc nét, một cách chơi gôn (trong MATL) là thêm 1vào từng mục của mảng 1 × 1 hoặc 1 × 2 thu được trước đó và sau đó tính tổng mảng (2 byte). Do đó, ghi chú không sắc nét được tăng lên 1và ghi chú sắc nét bằng 2. Điều này làm cho ghi chú sắc nét 1 nửa cung cao hơn ghi chú không sắc nét, theo yêu cầu. Chúng tôi cũng đang thêm một nửa cung thêm cho tất cả các ghi chú, nhưng điều đó không thay đổi khoảng thời gian giữa chúng. Vì vậy, bây giờ lưu ý Dsẽ cho số sân 2, D#sẽ cho 3, ..., Csẽ cho 12, C#sẽ cho 13.

Khoảng mâu thuẫn là 1, 2, 6, 10, hoặc 11. Chúng có đối xứng modulo-12 : một khoảng giữa hai nốt là không đồng nhất khi và chỉ khi khoảng với các nốt theo thứ tự ngược lại, modulo 12, là không đồng nhất.

Nếu chúng ta tính toán sự khác biệt liên tiếp của chuỗi, 'DJEFPGIALBC'chúng ta sẽ có được vectơ số

6 -5 1 10 -9 2 -8 11 -10 1

trong đó có chứa chính xác các khoảng không đồng nhất, ngoài một số giá trị âm, sẽ không hữu ích cũng không có hại. Quan sát rằng đó là sự lựa chọn của các chữ cái bổ sung JPILtrong chuỗi 'DJEFPGIALBC'xác định (thông qua các khác biệt liên tiếp) các khoảng không đồng nhất.

Để xem hai ghi chú đầu vào có khác nhau hay không, chúng tôi lấy sự khác biệt tuyệt đối của số nốt của chúng. Ví dụ, Cvà D#sẽ đưa ra số 12và 3tương ứng, và sự khác biệt tuyệt đối là 9. Sự khác biệt thực tế sẽ là -9, và khoảng thời gian thực tế sẽ là 3(thu được dưới dạng -9modulo 12). Nhưng nhờ sự đối xứng được đề cập ở trên, chúng ta có thể xem xét 9thay vì 3. Vì 9không có trong vectơ của sự khác biệt liên tiếp, các nốt là phụ âm.

JavaScript (ES6), 68 64 byte

Lấy các ghi chú là hai chuỗi trong cú pháp currying (a)(b). Lợi nhuận 0cho mâu thuẫn hay 1cho phụ âm.

a=>b=>488055>>(g=s=>'C D EF G A'.search(s[0])-!s[1])(a)-g(b)+9&1

Các trường hợp thử nghiệm

let f =

a=>b=>488055>>(g=s=>'C D EF G A'.search(s[0])-!s[1])(a)-g(b)+9&1

console.log(f('C' )('D' )) // 0 (Dissonant)
console.log(f('A#')('A#')) // 1 (Consonant)
console.log(f('G' )('D' )) // 1 (Consonant)
console.log(f('D#')('A' )) // 0 (Dissonant)
console.log(f('F' )('E' )) // 0 (Dissonant)
console.log(f('A' )('C' )) // 1 (Consonant)

Định dạng và nhận xét

a => b =>                       // given the two notes 'a' and 'b'
  488055 >>                     // 19-bit lookup bitmask: 1110111001001110111
    (g = s =>                   // we use g() to convert a note 's' into a semitone index
      'C D EF G A'.search(s[0]) // position of the note: -1 for 'B' (not found) to 9 for 'A'
      - !s[1]                   // subtract 1 semitone if the '#' is not there
    )(a)                        // compute the result for 'a'  --> [ -2 ...  9]
    - g(b)                      // subtract the result for 'b' --> [-11 ... 11]
    + 9                         // add 9                       --> [ -2 ... 20]
  & 1                           // test the bitmask at this position (0 if negative or > 18)

Thạch , 26 byte

i@€ØAo.SḤ’d5ḅ4µ€ạ/“¢£©½¿‘ċ

Một liên kết đơn âm lấy một danh sách của hai ghi chú (dưới dạng danh sách các ký tự) và trả lại 0cho phụ âm và 1cho bất đồng.

Hãy thử trực tuyến! hoặc xem tất cả các đầu vào trong bộ thử nghiệm .

Làm sao?

i@€ØAo.SḤ’d5ḅ4µ€ạ/“¢£©½¿‘ċ - Link: list of lists of characters, notes
              µ€           - for €ach note in notes: (call the resulting list x)
   ØA                      -   yield the uppercase alphabet
i@€                        -   first index of c in ^ for €ach character, c
                           -     ...note '#' is not there so yields 0 (A->1, B->2,...)
      .                    -   literal one half
     o                     -   or (vectorised)  - e.g. "C#" -> [3, 0] -> [3, 0.5]
       S                   -   sum
        Ḥ                  -   double - that is ...  C C#  D D#  E  F F#  G G#  A A#  B
                                                 ->  6  7  8  9 10 12 13 14 15  2  3  4
         ’                 -   decrement         ->  5  6  7  8  9 11 12 13 14  1  2  3
           5               -   literal five
          d                -   divmod                (e.g. 9 -> [1,4] or 11 -> [2,1])
             4             -   literal four
            ḅ              -   convert from base     (e.g. [1,4] -> 8 or [2,1] -> 9)
                                                 ->  4  5  6  7  8  9 10 11 12  1  2  3
                 /         - reduce x with:
                ạ          -   absolute difference   (e.g. ["G#", "A"] -> [12, 1] -> 11)
                  “¢£©½¿‘  - code-page indices = [1, 2, 6, 10, 11]
                         ċ - count occurrences (1 if in the list, 0 if not)

Thạch , 31 byte

O_65ị“¢[ḋṃ’b⁴¤+L$€Ḣ€ạ/e“cṾ’b12¤

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

wheeeeee 32 byte quá dài

Giải trình

O_65ị“¢[ḋṃ’b⁴¤+L$€Ḣ€ạ/e“cṾ’b12¤  Main link
O                                Cast each character to an int using Python `ord`
 _65                             Subtract 65 (A is 0, G is 7)
     “¢[ḋṃ’b⁴¤                   [2, 3, 5, 7, 9, 10, 0]
     “¢[ḋṃ’                      37058720
           b                     Digits in base
            ⁴                    16
    ị                            Index into this list; this creates the gaps for sharps
                 €               For each sublist
              +L$                Add the length to each element (Sharpens sharp notes)
              +                  Add
               L                 Length
                   €             For each sublist
                  Ḣ              Take the first element
                    ạ/           Absolute difference between the two (unoctaved) pitches # It's convenient that every interval's inverse (?) has the same consonance/dissonance
                      e          Is the semitone difference in
                       “cṾ’b12¤  [1, 2, 6, 10, 11]?
                       “cṾ’      25178
                           b     base
                            12   12

Toán học, 55 byte

function                                                  arguments        bytes

FreeQ[1|2|6|10|11]@Abs[#-#2&@@Sound`PitchToNumber/@#]&    [{"C","F#"}]     55

Ánh xạ tích hợp bên trong Sound`PitchToNumbervào đầu vào (danh sách hai chuỗi), lấy sự khác biệt tuyệt đối, sau đó khớp mẫu cho các số khoảng cách không đồng nhất.

Chỉ để cho vui (không cạnh tranh)

Dưới đây là một số chức năng ngắn hơn vi phạm hạn chế, bạn không được gán bất kỳ tên nào khác cho ghi chú. Gói gói thô sơMusic` có các hằng số ghi chú được xác định trước (như A4 = 440.) và chức năng HertzToCents(có thể được đánh gôn). Thay vì các chuỗi, chúng ta sẽ sử dụng các hằng ghi chú làm đối số, nhưng được cung cấp ở một định dạng khác nhau cho mỗi hàm.

FreeQ[1|2|6|10|11]@Abs@@Round[.01HertzToCents@#]&         [{C3,Fsharp3}]   50+9=59
FreeQ[1|2|6|10|11]@Abs@Round[17Log[#2/#]]&                [C3,Fsharp3]     43+9=52
FreeQ[1|2|6|10|11]@Abs@Round[17Log@#]&                    [C3/Fsharp3]     39+9=48

Việc nhập gói <<Music`;mất 9 byte.

Hàm này chuyển đổi một chuỗi (như "F#") thành hằng số ghi chú (như Fsharp3):

Symbol[StringReplace[#,"#"->"sharp"]<>"3"]&                                44

Để chấp nhận các khoảng lớn hơn quãng tám, thay thế Abs[…]bằng Mod[…,12].

Tại sao một số khoảng thời gian được coi là bất hòa? Một khoảng là một tỷ lệ của hai tần số. Nếu tỷ lệ này có một tử số và mẫu số đơn giản, thì nó có xu hướng phụ âm nhiều hơn. Trong điều chỉnh 5 giới hạn , các tỷ số có thể được tính thành các số nguyên chỉ có các số nguyên tố nhỏ hơn hoặc bằng 5. Không có khoảng nào trong tính khí bằng nhau, ngoài quãng tám, chỉ là một khoảng ; chúng chỉ đơn thuần là các xấp xỉ gần đúng bằng cách sử dụng quyền hạn của gốc thứ 12 của 2.

Thay vì mã hóa cứng mà các số khoảng cách là không đồng nhất, chúng ta có thể tìm một xấp xỉ hợp lý của khoảng đó và sau đó xác định xem tử số và mẫu số của nó có đơn giản hay không (nghĩa là mẫu số nhỏ hơn 5 và tỷ lệ không chia 7).

Bảng này cho thấy từng bước trong quy trình đó.

Table[
  Module[{compoundInterval,simpleInterval,rationalApprox,denomLeq5,div7,consonant},
    compoundInterval = Power[2, i/12];
    simpleInterval   = 2^Mod[Log2[compoundInterval], 1];
    rationalApprox   = Rationalize[N@simpleInterval, 1/17];
    denomLeq5        = Denominator[rationalApprox]<=5;
    div7             = Denominator[rationalApprox]>1 && rationalApprox\[Divides]7;
    consonant        = FreeQ[1|2|6|10|11][Mod[i,12]];

    InputForm/@{
      i, simpleInterval, rationalApprox, 
      denomLeq5, div7, denomLeq5 && !div7,
      consonant
    }
  ], {i, 0, 12}
]

i   sInterval  ratio   denomLeq5  div7       den&&!div  | consonant?

0   1          1       True       False      True       | True
1   2^(1/12)   17/16   False      False      False      | False
2   2^(1/6)    9/8     False      False      False      | False
3   2^(1/4)    6/5     True       False      True       | True
4   2^(1/3)    5/4     True       False      True       | True
5   2^(5/12)   4/3     True       False      True       | True
6   Sqrt[2]    7/5     True       True       False      | False
7   2^(7/12)   3/2     True       False      True       | True
8   2^(2/3)    8/5     True       False      True       | True
9   2^(3/4)    5/3     True       False      True       | True
10  2^(5/6)    7/4     True       True       False      | False
11  2^(11/12)  11/6    False      False      False      | False
12  1          1       True       False      True       | True

Giá trị gần đúng hợp lý nằm trong 1/17khoảng bởi vì đó là ngưỡng lớn nhất phân biệt giữa tất cả 12 khoảng thời gian ủ bằng nhau. Chúng tôi khớp các số hữu tỷ với mẫu Rational[a_,b_](hoặc chỉ a_~_~b_) trước, sau đó khớp số nguyên với chỉ _.

Điều này đạt đến đỉnh điểm trong hàm khá ngắn sau đây xác định xem tỷ lệ tần số tùy ý (lớn hơn 1) là phụ âm hay phụ âm.

Rationalize[#,1/17]/.{a_~_~b_:>b<=5&&!a∣7,_->True}&       [Fsharp3/C3]     51+9=60

Toán học, 118 byte

FreeQ[{1,2,6,10,11},Min@Mod[Differences[Min@Position["C|C#|D|D#|E|F|F#|G|G#|A|A#|B"~StringSplit~"|",#]&/@{#,#2}],12]]&

Mẫu đầu vào

["A #", "D"]

Đầu ra

True->Consonant  
False->Dissonant   

cảm ơn @JonathanFrech -16 byte

Than , 30 byte

≔B#A#G#FE#D#C槔o∧⌈ς”⁻⌕ζ⮌θ⌕ζ⮌η

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đầu ra 1 cho phụ âm, 0 cho phụ âm. Giải trình:

≔B#A#G#FE#D#Cζ                  Store reversed note names in z
                        θ       First input
                       ⮌        Reversed
                     ⌕ζ         Find index in z
                            η   Second input
                           ⮌    Reversed
                         ⌕ζ     Find index in z
                     ⁻          Subtract
               ”o∧⌈ς”           Compressed string 100111011100
              §                 Circularly index
                                Implicitly print

J, 68 byte

[:e.&1 2 6 10 11[:(12| -~/)(<;._1',C,C#,D,D#,E,F,F#,G,G#,A,A#,B')i.]

giải trình

Một cách thực hiện đơn giản, không siêu golf trong J:

• Đầu vào được đưa ra dưới dạng ghi chú được ghi thành từng mục (được tạo ra bằng cách cắt), theo thứ tự.

• Tìm chỉ mục của họ trong phạm vi ghi chú: (<;._1',C,C#,D,D#,E,F,F#,G,G#,A,A#,B')i.]

• Trừ cái thứ nhất từ ​​cái thứ hai: -~/

• Lấy phần còn lại khi chia cho 12: 12|

• Kiểm tra xem đó có phải là một trong những ghi chú bất đồng không: e.&1 2 6 10 11

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

/// , 90 88 byte

/^/"\///^\/\///C^D/##"E/DD"F/E#"G/FD"A/GD"B/AD"#,#/,"B#^B/#"A#/#"A^G#^G^F#/#"F^E^D#^D/#/

Hãy thử trực tuyến!(tất cả các trường hợp thử nghiệm cùng một lúc)

• Đặt đầu vào sau mã.
• Phân tách tên ghi chú với ,B# trong mỗi trường hợp thử nghiệm.
• Đầu ra là ,cho phụ âm,,# cho .
• Hỗ trợ thay đổi kép ( ##) hoặc E#trong một số trường hợp cụ thể. Mặt khác, đầu ra là ,cho phụ âm, cho phụ âm #,(nhờ đối xứng modulo 12)
• Có thể xử lý nhiều trường hợp thử nghiệm cùng một lúc (nếu được phân tách hợp lý)
• Ký tự chữ thường được in chính xác.

C (gcc) , 91 byte

g(char*s){return (s[1]&1|2**s&15)*4/5;}f(char*x,char*y){return (1952220<<g(x)>>g(y))&2048;}

gọi điện: f("A#", "D")

Giá trị trả về:

• Phụ âm: 2048
• Mật độ: 0

Tiền thưởng: Chức năng không phân biệt chữ hoa chữ thường.

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

Python 2, 125 117 83 78 77 byte

a,b=map("C C#D D#E F F#G G#A A#B".index,input())
print chr(abs(a-b))in""

Trường hợp ""ở cuối thực sự chứa các ký tự"\x02\x04\x0c\x14\x16"

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

(+3 vì tôi đã quên 11 hoặc 22 trong danh sách để bắt đầu)

-8 byte từ Jonathan Frech và chuyển sang Python 2 .

-34 byte với các đề xuất từ ​​Jonathan Frech và sử dụng str chỉ mục của thay vìlist .

-4 byte từ nội tuyến i và Neil đảo ngược đề xuất chuỗi (chỉ -2 thực sự, như tôi đã quên() xung quanh một trình tạo)

-5 byte từ không nội tuyến i & thay đổi định dạng đầu vào

-1 byte từ Jonathan Frech với map() và không thể in được.

Đưa đầu vào vào một dòng stdin theo định dạng:

'C','C#'

True là bất hòa, False là phụ âm.

Giải thích cũ:

i='C C#D D#E F F#G G#A A#B'.index
a,b=input()
print abs(i(a)-i(b))in[2,4,12,20]

Python str.indextrả về chỉ số bắt đầu (dương) thấp nhất của một chuỗi con phù hợp, "ABACABA".index("A") == 0và "ABACABA".index("BA") == 1. Vì điều này, chúng ta có thể đặt các tên ghi chú cách đều nhau trong một chuỗi và miễn là (ví dụ) Axuất hiện trước đó A#, việc chia sẻ Asẽ không thành vấn đề.

i='C C#D D#E F F#G G#A A#B'.index

ibây giờ là một hàm trả về chỉ mục trong 'C C#D D#E F F#G G#A A#B'đối số của nó (tên ghi chú), là 2 * (số lượng nửa cung mà ghi chú được lấy từ C)

a,b=input()

Python 2 input()là (hầu hết) tương đương với eval(input())Python3, vì vậy với đầu vào hợp lệ của định dạng 'C#','F'(ví dụ) a='C#'vàb='F'

print abs(i(a)-i(b))in[2,4,12,20]

Nếu khoảng cách giữa nốt đầu tiên và nốt thứ hai trong chuỗi không phải là 2, 4, 12 hoặc 20 (vì tên ghi chú được biểu thị bằng 2 ký tự), thì khoảng đó là không đồng nhất, in True, nếu không thì đó là phụ âm, in sai.

C (gcc) , 115117 120 byte

g(char*a){a=*a-65+!!a[1]*(7-*a/70-*a/67);}f(x,y)char*x,*y;{x="(pP$HL<lt<X"[g(x)]*32+"=ZukW-^h1F6"[g(x)]>>g(y)&1;}

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

Trả về 1/0 cho consonat và dissonat. Thật thú vị khi thực hiện thao tác chuỗi với thuần C. Lấy đầu vào làf("A#", "C")

PowerShell , 107 byte

param($a,$b)[math]::abs(($x=-split'C C# D D# E F F# G G# A A# B').indexof($b)-$x.indexof($a))-in1,2,6,10,11

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

Đầu ra TrueFalse cho phụ âm và phụ âm.

Lấy đầu vào $avà $b, hai ghi chú, dưới dạng chuỗi. Thực hiện một -splitthao tác trên thang đo, phân tách trên khoảng trắng, để tạo ra một mảng các ghi chú, lưu trữ vào đó $x. Tìm .indexof $btrong mảng đó, trừ chỉ số của $a, và sau đó lấy absgiá trị olute của chúng. Kiểm tra xem số đó có phải là -inphạm vi không đồng nhất hay không.

Python 2 , 68 byte

lambda a,b,f='C C#D D#E F F#G G#A A#B'.find:3142>>(f(a)-f(b))/2%12&1

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

Đầu ra: 1là không đồng nhất, 0là phụ âm.

SQL, 582 byte

Câu đố SQL

Tôi vẫn còn một số môn đánh gôn để làm nó, nhưng tôi muốn đưa nó xuống đây trước khi tôi hoàn toàn phá vỡ nó.

Nếu đầu vào ở định dạng chữ cái, thì đặt các chữ cái đó vào một bảng có giá trị là được, phải không?

CREATE TABLE N(N char(2),v int)
Insert Into N values('A',1),('A#',2),('B',3),('C',4),('C#',5),('D',6),('D#',7),('E',8),('F',9),('F#',10),('G',11),('G#',12);
CREATE TABLE D(D char(9),v int) 
Insert Into D values('C',0),('D',1),('D',2),('C',3),('C',4),('C',5),('D',6);
CREATE FUNCTION I(@A char(2),@B char(2))
RETURNS char(9) as
BEGIN
DECLARE @E int=(SELECT v from N where n=@A),@F int=(SELECT v from N where n=@B)
DECLARE @C char(9) = (SELECT case D when 'D' then 'Dissonant' when 'C' then 'Consonant' END from D where v in(abs(@e-@f),12-abs(@e-@f)))
RETURN isnull(@C,'NotANote')
END

Perl 5 , 106 byte

("C,C#,D,D#,E,F,F#,G,G#,A,A#,B,"x2)=~/$F[0],(.*?)$F[1],/;$r=(1+($1=~y/,//))%12;say(grep/$r/,(0,3..5,7..9))

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

Trả về false cho phụ âm, đúng cho phụ âm.