2つの音名が与えられたら、これら2つの音によって形成される音程が子音か不協音かを決定するプログラムを作成します。

前書き

西洋音楽では、12の「異なる」音しかありません。それらの名前は、最低から最高の順に並べられていますC, C#, D, D#, E, F, F#, G, G#, A, A#, B。シーケンスは循環的です。つまり、のC後Bに無限に続きます。

2つのトーン間の距離は、インターバルと呼ばれます。上記のシリーズ（C — C#またはE — F）で隣接する2つの音の間隔は、半音と呼ばれます。より遠くの音符の間隔は、最初から2番目の音まで（シーケンスをラップしている間）取得するのに必要な半音ステップの数として定義されます。いくつかの例：D to E= 2半音、C to G= 7半音、B to D#= 4半音（これはシーケンスをラップします）。¹

現在、これらの間隔は2つのカテゴリに分けられます。子音（一度に2つの音を弾くと心地よく鳴ります）と不協和音（それほどではありません）です。

子音の間隔を0、3、4、5、7、8、9半音に定義します。

残りは不協和音です。つまり、1、2、6、10、11半音です。

チャレンジ

次のことを行うために、「プログラム」（通常の広義の意味：関数は完全にOK）を作成します。

• 入力として2つの音名（上記のシーケンスの文字列）を使用します。好きなようにそれらを使用することができます（引数として、必要なもので区切られた引数として、自由に文字のリスト（例["C","#"]）としてそれらを使用することもできます。ただし、ノートに他の名前を割り当てることはできません（特に0から11までの番号を付けたり、番号を使用したりすることはできません）。

• あなたの音楽オタクのために、音符はオクターブなしで指定されます。この場合、ノートがどの順序で来て、どれがより低く、どれがより高いかは重要ではありません。最後に、上記のリストにない名前を処理する必要はありません。のような他の高調波E#、フラット、二重変更などはありません。

• 2つの異なる値を選択します。プログラムは、入力内の2つの音符が形成する間隔が子音である場合は常に1つを出力し、そうでない場合はもう1つを出力する必要があります。（Trueand Falseになる可能性がありますが、必要に応じてπとeでも可能です:)）

• これはコードゴルフです。各言語のバイト単位の最短プログラムが優先されます。楽しむ！

例とテストケース

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

これには特に危険なケースがないため、これ以上追加しません。

これは私の最初の挑戦なので、建設的な批判は大歓迎です:—)。理論の説明がずさんな場合は、遠慮なく質問してください。最後に、これがthisまたはthisの duだとは言わないでください。そうでないことを確認しました。（後者は非常に似ていますが、より複雑です。少し簡単なチャレンジをすることで、人々が参加しやすくなると思いました。）

ゼリー、21バイト

入力を2つの文字列のリストとして受け取ります。0不協和音または1子音を返します。

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

オンラインでお試しください！

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

の制作

最初に、探している関数Fが可換であることに注意する必要があります。任意のペアのノート（A、B）に対して、F（A、B）= F（B、A）があります。

処理できる入力が多すぎず、出力が2つしかないため、| H（A）-H（B）|のようなかなり単純なハッシュ関数Hを見つけることができなければなりません。限られた範囲の値を生成し、予想される出力に関してすべての可能なノートのペア（A、B）に対して衝突が発生しません。

以下のように定義されている関数H（mul、mod）のセットをテストします。

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

どこORD(s[0])のノートの最初の文字のASCIIコードがあるとLEN(s)（音符の長さである2があるかどう'#'と1れていない場合）。

有効なペア（mul、mod）と結果のビットマスクを見つけるために使用されたJSコードのコメント付きバージョンを以下に示します。考えられる解決策は数​​多くありますが* 6 % 21、この方法では最も短い解決策です。

// 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バイト

使用⎕IO←0; 0は子音、1は子音です。左引数としてベースノート文字のリストを取り、右引数としてシャープのリストを取ります。

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

オンラインでお試しください！

{… 左辺引数が右辺引数} で⍺ある匿名関数⍵

 ⎕A[… 以下によってインデックスが付けられ]∊'BCGKL' たA lphabetは、文字列のメンバーですか？

  ⍕# ルート名前空間をフォーマットします（シャープな文字を生成します）

  ⍵= 正しい引数の文字（シャープ）はそれに等しいですか？

  (… )+ 次を追加します。

   'C D EF G A '⍳⍺ 文字列の左引数文字のインデックス

  -/ それらの違い

  | 絶対値

MATL、30 27 26バイト

,j'DJEFPGIALBC'&mQs]ZP7Mdm

2つのノートを異なる行に入力します。0子音、1不協和音の出力。

オンラインでお試しください！または、すべてのテストケースを確認します。

説明

11文字のストリング

DJEFPGIALBC

次のように、音符と不協和音の間隔の両方をエンコードします。

プログラムは最初に、上記の文字列で入力文字の1から始まるインデックスを見つけます。のような非シャープな入力は、Dを与え1、Eを与え3、... Cを与え11ます これらの数値は、1×1の数値配列と考えることもできます。のような鋭い入力C#は、1x2配列を与えます。これは、位置で見つかり、見つからなかったことを[11 0]意味します。C11#

JPIL入力に文字が存在しないことに注意してください。今の彼らは、たとえばノートがそうすることを、プレースホルダとして使用されてEいる2つの半音上D。しかし、不協和音の間隔を定義するのにも役立ちます。

1×1または1×2配列の最初のエントリの数字は、シャープ記号を（まだ）カウントせずに、半音の音高に対応しています。これらの数値で定義されるスケールがで始まらないことに注意してくださいC。間隔、つまり音符の違いだけが必要なので、それは問題ではありません。得られた数値を減算すると、間隔または12から間隔を引いた値が得られます。しかし、最初に鋭いシンボルを考慮する必要があります。

シャープな音を考慮するために、ゴルフ法（MATL）では、以前に取得した1x1または1x2配列の1各エントリに追加し、配列（2バイト）を合計します。したがって、シャープでないノートはによって増加し1、シャープなノートはによって増加し2ます。これにより、必要に応じて、シャープなノートがシャープでないノートよりも半音高くなります。また、すべての音符に半音を追加していますが、音符間の間隔は変わりません。だから今のノートはDピッチ数を与える2、D#与える3、...、C与える12、C#与えます13。

不協和音の間隔があり1、2、6、10、または11。これらはモジュロ12対称です。2つの音符の間隔は、逆順の音符の間隔12を法とする場合にのみ不協和音です。

文字列の連続的な差を計算すると'DJEFPGIALBC'、数値ベクトルが得られます

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

いくつかの負の値に加えて、不協和音の間隔が正確に含まれており、有用でも有害でもありません。不協和音の間隔を定義するのはJPIL、文字列内の追加の文字の選択であることに注意してください'DJEFPGIALBC'（連続した差異を介して）。

2つの入力ノートが不協和音であるかどうかを確認するために、ピッチ番号の絶対差を取ります。例えば、CとD#番号を与える12と3、それぞれ、絶対差です9。実際の差はで-9、実際の間隔は3（-9モジュロ12 として取得されます）です。しかし、上記の対称性のおかげで、の9代わりに考慮することができ3ます。9連続する差異のベクトルには存在しないため、音符は子音です。

JavaScript（ES6）、68 64バイト

カリー化構文の2つの文字列としてメモを取ります(a)(b)。0不協和音または1子音を返します。

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

テストケース

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)

書式設定およびコメント化

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)

ゼリー、26 バイト

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

2つの音符のリスト（文字のリストとして）を取得し、0子音と1不協和音のために返すモナドリンク。

オンラインでお試しください！または test-suiteのすべての入力を確認します。

どうやって？

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)

ゼリー、31バイト

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

オンラインでお試しください！

wheeeeee 32バイトが長すぎます

説明

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

Mathematica、55バイト

function                                                  arguments        bytes

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

内部ビルトインをSound`PitchToNumber入力（2つの文字列のリスト）にマッピングし、絶対差を取り、不協和音の間隔番号のパターンマッチを行います。

ただの楽しみのために（非競合）

「ノートに他の名前を割り当てることはできません。」という制限に違反する短い関数を次に示します。初歩的なMusic`パッケージには、定義済みのノート定数（などA4 = 440.）と関数HertzToCents（ゴルフが可能）があります。文字列の代わりに、ノート定数を引数として使用しますが、関数ごとに異なる形式で指定します。

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

パッケージのインポートに<<Music`;は9バイトかかります。

この関数は、文字列（など"F#"）を音符定数（などFsharp3）に変換します。

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

オクターブよりも大きな間隔を受け入れるには、交換してくださいAbs[…]とMod[…,12]。

一部の間隔が不協和音と見なされるのはなぜですか？間隔は、2つの周波数の比率です。比率に「単純な」分子と分母がある場合、より子音になる傾向があります。で5制限チューニング、割合未満だけ素数の整数べき乗に因数分解することができ、又は平均律における前記無間隔に等しく、オクターブの他に、あるだけ間隔。これらは、2の12乗根のべき乗を使用した近似にすぎません。

区間番号が不協和であるハードコーディングの代わりに、区間の有理近似を見つけて、その分子と分母が「単純」であるかどうかを判断できます（分母が5未満で、比率が7を除算しないことを意味します）。

この表は、そのプロセスの各ステップを示しています。

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

合理的な近似は1/17間隔の範囲内にあります。これは、12の等しい調律間隔すべてを区別する最大のしきい値であるためです。有理数とパターンRational[a_,b_]（または単にa_~_~b_）を最初に照合し、次に整数のみとを照合します_。

これは、任意の周波数比（1より大きい）が子音であるか不協音であるかを決定する次のかなり短い関数で終わります。

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

Mathematica、118バイト

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

入力フォーム

["広告"]

出力

True->Consonant  
False->Dissonant   

ありがとう@JonathanFrech -16バイト

炭、30バイト

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

オンラインでお試しください！リンクは、コードの詳細バージョンです。子音の場合は1、不協和音の場合は0を出力します。説明：

≔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バイト

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

説明

Jでの簡単な、スーパーゴルフではない実装：

• 入力は、ボックス化された箇条書き（カットを使用して作成）として順番に与えられます。

• メモの範囲でインデックスを検索します。 (<;._1',C,C#,D,D#,E,F,F#,G,G#,A,A#,B')i.]

• 2番目から1番目を引きます： -~/

• 12で割ったときに残りを取ります。 12|

• 不協和音の一つであるかどうかを確認してください： e.&1 2 6 10 11

オンラインでお試しください！

///、90 88バイト

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

オンラインでお試しください！（すべてのテストケースを一度に）

• コードの後に​​入力します。
• ,B#各テストケースでノート名を区切ります。
• 出力は,、子音,#用、不協和音用です。
• 二重変更のサポート（##）またはE#特定の場合。それ以外の場合、出力は,子音#,用、不協和音用です（モジュロ12対称性のおかげ）
• 一度に複数のテストケースを処理できる（合理的に分離されている場合）
• 小文字は正確に印刷されます。

C（gcc）、91バイト

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

コール： f("A#", "D")

戻り値：

• 子音：2048
• 不協和音：0

ボーナス：関数は大文字と小文字を区別しません。

オンラインでお試しください！

Python 2、 2、125 117 83 78 77バイト

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

どこで""終わり、実際に文字が含まれています"\x02\x04\x0c\x14\x16"

オンラインでお試しください！

（最初にリストの11または22を忘れていたため+3）

Jonathan Frechから-8バイト、Pythonへの切り替え 2。

-34バイト、Jonathan Frechからの提案と使用 str代わりにのインデックスlist。

インライン化から-4バイトi、ニールが文字列の提案を反転（実際には-2だけ、忘れてしまったので()、ジェネレーターをていたため）

インライン展開から-5バイト iと入力形式の変更

Jonathan Frechから-1バイト map()と印刷不可。

次の形式で標準入力の1行で入力を取得します。

'C','C#'

True 不協和音です False子音です。

古い説明：

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.index最も低い（正）に一致したサブストリングのインデックスを開始を返し、そう "ABACABA".index("A") == 0と"ABACABA".index("BA") == 1。このため、ノート名を文字列内に等間隔で配置でき、（たとえば）A前A#に来る限り、共有Aは問題になりません。

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

iは'C C#D D#E F F#G G#A A#B'、引数（音名）にインデックスを返す関数になりました。これは2 *（音が発する半音の数C）です

a,b=input()

Pythonの2者はinput()（ほとんど）に相当するeval(input())ので、フォーマットの有効な入力でのpython3で'C#','F'（例えば）、a='C#'およびb='F'

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

文字列の最初の音と2番目の音の間の距離が2、4、12、または20でない場合（音名は2​​文字で表されるため）、間隔は不協和であり、Trueを出力します。それ以外の場合は子音です。 Falseを印刷します。

C（gcc）、115117 120 バイト

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

オンラインでお試しください！

consonatとdissonatに対して1/0を返します。純粋なCで文字列操作を行うことは常に興味深いです。入力をf("A#", "C")

PowerShell、107バイト

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

オンラインでお試しください！

True不協和音とFalse子音の出力。

入力$aと$b、2つのメモを文字列として受け取ります。-split音階で操作を実行し、空白で分割して音符の配列を作成し、それをに保存し$xます。.indexof $bその配列内でを検索し、のインデックスを減算してから$a、absその値を取得します。その数値が-in不協和音の範囲かどうかを確認します。

Python 2、68バイト

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

オンラインでお試しください！

出力：1不協和音、0子音です。

SQL、582バイト

SQLフィドル

私はまだゴルフをすることがありますが、それを完全に壊してしまう前にここで降ろしたかったのです。

入力が文字形式である場合、それらの文字を値付きのテーブルに入れることは大丈夫ですよね？

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バイト

("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))

オンラインでお試しください！

不協和音の場合はfalse、子音の場合はtrueを返します。