두 개의 음표 이름이 주어지면,이 두 음표에 의해 형성된 간격이 자음인지 음소인지를 결정하는 프로그램을 작성해야합니다.

소개

서양 음악에는 12 가지 "다른"톤이 있습니다. 그들의 이름은 가장 낮은 것부터 가장 높은 것까지 다음과 같습니다 C, C#, D, D#, E, F, F#, G, G#, A, A#, B. 순서는 순환, 그것은 서로 계속 즉, C애프터 B무한.

두 톤 사이의 거리를 간격 이라고 합니다 . (예를 들어 위의 일련의 인접한 두 음의 간격 C — C#또는은 E — F)을 호출 반음 . 더 먼 음 사이의 간격은 첫 번째부터 두 번째까지 (시퀀스를 감싸는 동안) 필요한 반음 단계의 수로 정의됩니다. 몇 가지 예 : D to E= 2 개의 반음, C to G= 7 개의 반음, B to D#= 4 개의 반음 (이는 시퀀스를 둘러 쌉니다). ¹

자,이 간격은 자음 (한 번에 두 음을 연주하면 기분이 좋음)과 불협화음 (별로 많지 않음 )의 두 가지 범주로 구분됩니다 .

자음 간격을 0, 3, 4, 5, 7, 8 및 9 반음으로 정의합시다.

나머지는 불쾌합니다. 즉 1, 2, 6, 10 및 11 반음입니다.

도전

다음을 수행하기 위해 "프로그램"을 작성하십시오 (일반적으로 넓은 의미에서 기능 : 완벽하게 정상입니다).

• 입력으로 두 개의 메모 이름 (위의 순서에서 나온 문자열)을 사용하십시오. 원하는대로 원하는대로 사용할 수 있습니다 (stdin에서 인수로, 원하는대로 구분하여 문자 목록 (예 :)으로 자유롭게 ["C","#"]사용할 수도 있습니다). 0에서 11까지 번호를 매기 지 않고 숫자를 사용할 수 있습니다).

• 당신이 음악 괴짜를 위해, 음은 옥타브없이 지정됩니다. 이 경우, 음표의 순서와 순서는 중요하지 않습니다. 마지막으로 위 목록에없는 이름을 처리 할 필요가 없습니다. E#아파트, 아파트, 이중 개조 등의 다른 어모 니즘은 없습니다.

• 두 가지 다른 값을 선택하십시오. 입력의 두 음표에 의해 형성된 간격이 자음이고 그렇지 않은 경우 다른 하나가 출력되어야합니다. ( True및 가능 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

이것에 특히 위험한 사건이 없기 때문에 더 이상 추가하지 않습니다.

이것은 나의 첫번째 도전이므로, 어떤 건설적인 비판도 따뜻하게 환영합니다 :—). 이론 설명이 조잡하다고 생각되면 언제든지 질문하십시오. 마지막으로 이것이 이것 또는 이것 의 속임수라고 말하지 마십시오 . 나는 그렇지 않다는 것을 확인했다. (후자는 상당히 비슷하지만 더 복잡합니다. 조금 더 간단한 도전을하면 사람들이 더 쉽게 참여할 수 있다고 생각했습니다.)

젤리 , 21 바이트

두 문자열의 목록으로 입력을받습니다. 자음 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 ,되도록 | H (A) - H (B)를 | 제한된 범위의 값을 생성하며 예상되는 출력과 관련하여 가능한 모든 노트 쌍 (A, B) 에 대해 충돌이 없습니다 .

다음과 같이 정의 된 함수 H (mul, mod) 집합을 테스트합니다 .

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

어디 ORD(s[0])노트의 첫 번째 문자의 ASCII 코드와 LEN(s)(음표의 길이 2 거기를인지 '#'하고 일 하지 않은 경우).

다음은 유효한 쌍 (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' 는 IS 의 다음 문자열의 일원에 의해 색인 lphabet은?

  ⍕# 루트 네임 스페이스의 형식을 지정합니다 (예리한 문자가 나타남).

  ⍵= 올바른 논증 문자 (예리한 것)는 그것과 같습니까?

  (… )+ 다음을 추가하십시오.

   'C D EF G A '⍳⍺ 문자열에서 왼쪽 인수 문자의 인덱스

  -/ 그것들의 차이점

  | 절대 값

MATL , 30 27 26 바이트

,j'DJEFPGIALBC'&mQs]ZP7Mdm

두 줄을 다른 줄에 입력합니다. 0자음, 자음 출력 1.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

11 자 문자열

DJEFPGIALBC

다음과 같이 음표와 불협화음 간격을 모두 인코딩합니다.

프로그램은 먼저 위의 문자열에서 입력 문자의 1 기반 인덱스를 찾습니다. 예리하지 않은 입력 D은 줄 것이다 1, E줄 것이다 3, ..., C줄 것이다 11. 이 숫자는 1x1 숫자 형 배열로 간주 될 수도 있습니다. 같은 날카로운 입력이 C#1 × 2 배열을 줄 것이다 [11 0]의미 C위치에서 발견되었다 11그리고 #발견되지 하였다.

JPIL입력에 문자 가 절대로 표시되지 않는지 확인하십시오 . 현재는 자리 표시 자로 만 사용되므로 예를 들어 note E는 위의 두 반음입니다 D. 그러나 그것들은 또한 불협화음 간격을 정의하는데 유용 할 것입니다.

1x1 또는 1x2 배열의 첫 번째 항목의 숫자는 날카로운 기호 (아직)를 세지 않고 반음 단위의 음조 피치에 해당합니다. 이 숫자로 정의 된 스케일이 시작되지 않는지 확인하십시오 C. 그러나 간격, 즉 음표의 차이 만 원하기 때문에 중요하지 않습니다 . 획득 한 숫자를 빼면 구간 또는 12에서 구간을 뺀 값이됩니다. 그러나 먼저 날카로운 상징을 고려해야합니다.

예리한 음표를 고려하기 위해 MATL에서 골퍼 방식은 이전에 얻은 1x1 또는 1x2 1배열의 각 항목에 추가 한 다음 배열을 합 칩니다 (2 바이트). 따라서 선명하지 않은 음표는 증가하고 날카로운 음표는 증가 1합니다 2. 이렇게하면 필요에 따라 선명한 음표가 비 음표 음표보다 반음이 높아집니다. 또한 모든 음표에 반음을 추가하지만 음표의 간격은 바뀌지 않습니다. 그래서 지금주의 D피치 수를 줄 것이다 2, D#줄 것이다 3, ..., C줄 것이다 12, C#줄 것이다 13.

불협화의 간격은 1, 2, 6, 10, 또는 11. 이들은 모듈로 -12 대칭을 갖는다 : 역수로 노트와의 간격이 모듈로 12 인 경우에만 두 노트 사이의 간격은 불협화음이다.

문자열의 연속적인 차이를 계산 'DJEFPGIALBC'하면 숫자 벡터를 얻습니다.

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

여기에는 음수 값 외에 정밀하지 않은 간격이 포함되어있어 유용하지도 유해하지도 않습니다. 불연속 간격을 정의하는 (연속적인 차이를 통해) JPIL문자열에서 추가 문자 를 선택하는 것을 관찰하십시오 'DJEFPGIALBC'.

두 개의 입력 음이 불협화음을 확인하기 위해 피치 수 의 절대 차이 를 취합니다 . 예를 들어, C및 D#번호를 제공 12하고 3, 각각 절대 차이이다 9. 실제 차이는 -9이고 실제 간격은 3( -9모듈로 12로 획득 ) 것입니다. 그러나 위에서 언급 한 대칭 덕분에 9대신에 고려할 수 있습니다 3. 9연속적인 차이의 벡터 에는가 없기 때문에 음표는 자음입니다.

자바 스크립트 (ES6), 68 64 바이트

카레 구문에서 메모를 두 개의 문자열로 사용합니다 (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µ€ạ/“¢£©½¿‘ċ

두 음표 (문자 목록) 목록 을 가져와 0자음과 자음으로 돌아가는 모나드 링크 1.

온라인으로 사용해보십시오! 또는 테스트 스위트 의 모든 입력을 참조하십시오.

어떻게?

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

수학, 55 바이트

function                                                  arguments        bytes

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

Sound`PitchToNumber입력 (두 문자열의 목록)에 내장 된 내장 기능을 매핑하고 , 절대 차이를 취한 다음, 불연속 구간 수에 대한 패턴 일치를 지정하십시오.

재미를 위해 (경쟁이 아닌)

다음은 "노트에 다른 이름을 할당 할 수 없습니다"라는 제한을 위반하는 일부 짧은 기능입니다. 기본 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].

왜 일부 구간이 불협화음으로 간주됩니까? 간격은 두 주파수의 비율입니다. 비율에 "간단한"분자와 분모가 있으면 더 자음이되는 경향이 있습니다. 에서는 5 제한 튜닝 , 비는 이하 단지 소수의 정 전력에 반영 될 수 있거나 또는 옥타브 외에, A는, 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/1712 개의 모든 동일한 강화 간격을 구별하는 가장 큰 임계 값이므로 구간 내에 있습니다 . 우리는 유리수를 패턴 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.]

• 두 번째에서 첫 번째를 빼십시오. -~/

• 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

보너스 :이 기능은 대소 문자를 구분하지 않습니다.

온라인으로 사용해보십시오!

파이썬 2, 125117 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로 전환합니다 .

사용 조나단 FRECH과에서 제안 -34 바이트 str'대신의 인덱스를 listS'이 (가) 있습니다.

인라인에서 -4 바이트 i및 Neil의 문자열 제안 반전 ( ()제너레이터를 잊어 버렸을 때 실제로 -2 만 )

인라인 해제 i및 입력 형식 변경 에서 -5 바이트

Jonathan Frech와 -1 바이트는 map()인쇄 할 수 없습니다.

다음과 같은 형식으로 한 줄의 stdin을 입력합니다.

'C','C#'

TrueFalse자음 , 자음입니다.

이전 설명 :

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]

파이썬 str.index은 일치하는 부분 문자열의 가장 낮은 (긍정적 인) 시작 색인을 반환하므로 "ABACABA".index("A") == 0and "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()

파이썬 2의은 input()(주로)에 해당 eval(input())하므로 포맷의 유효한 입력으로 Python3에 'C#','F'(예), a='C#'및b='F'

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

문자열에서 첫 번째 음표와 두 번째 음표 사이의 거리가 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, 두 노트를 문자열로 사용합니다. -split공백으로 분할하여 음표 배열을 생성하고에 저장하는 스케일에서 작업을 수행합니다 $x. (가) 찾아 .indexof $b그 배열의 인덱스를 뺀 $a후 얻어 abs그 olute 값. 해당 숫자가 -in불협화음 범위 인지 확인합니다 .

파이썬 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

펄 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를 반환합니다.