떠나기 전에이 도전을하기 위해 많은 음악 표기법을 이해할 필요는 없습니다.

설명

표준 악보에서 이중 음자리표는 페이지를 가로 질러 음표의 기준점으로 사용되어 어떤 음표를 연주해야하는지 알려줍니다. 고음 및 저음 음자리표에 익숙하지 않은 경우 Wikipedia 의 설명입니다 .

음자리표는 필기 음의 피치를 나타내는 데 사용되는 음악 기호입니다. 스 태브 시작 부분의 라인 중 하나에 배치되면 해당 라인에있는 음의 이름과 피치를 나타냅니다. 이 선은 스 태브의 다른 선 또는 공간에있는 음표의 이름을 결정할 수있는 기준점으로 사용됩니다.

위의 이미지에서 선의 상단 절반은 고음 음자리표이며

하단 절반은베이스 음자리표이며

고음 음자리표에서 볼 수 있듯이 맨 아래 줄의 메모는 E 입니다. (이 도전에 대한 음자리표 외부의 음표는 세지 않습니다)베이스 음자리표에서 가장 낮은 선은 G 입니다. 이 과제를 완료하려면 다음을 수행해야합니다.

도전

다음 형식 중 하나를 입력하면 (선택) 반대 음자리표로 변환하십시오. 고음 또는 저음 음자리표 여부는 귀하의 언어로 된 Truthey / Falsey 값일 수 있습니다 (예 : 두 값만이 아님).

F # T 또는 F # True 또는 F # 고음

하지만

F # -1 또는 F # 4

공백과 대문자는 선택 사항이며, 아파트는 나타나지 않으며 후행 공백은 허용되지 않습니다.

Input          Expected Output
E   Treble     G
F   Treble     A
F#  Treble     A#
G   Treble     B
G#  Treble     C
A   Treble     C
A#  Treble     C#
B   Treble     D
C   Treble     E
C#  Treble     F
D   Treble     F
D#  Treble     F#
E   Treble     G
F   Treble     A
F#  Treble     A#
G   Bass       E
G#  Bass       F
A   Bass       F
A#  Bass       F#
B   Bass       G
C   Bass       A
C#  Bass       A#
D   Bass       B
D#  Bass       C
E   Bass       C
F   Bass       D
F#  Bass       D#
G   Bass       E
G#  Bass       F
A   Bass       F
A#  Bass       F#

이것은 사소한 일정한 차이의 도전이 아닙니다. 입력과 출력을 자세히 살펴보십시오. 피아노를 보면

검은 색 키는 #로 표시되어 선명합니다. E # 또는 B #이 없습니다. 이것은 E # 을 반환하는 대신베이스 음자리표에 G # 이 주어지면 F 를 반환해야 함을 의미합니다.

이것은 code-golf 이므로 가장 작은 바이트 수가 이깁니다.

젤리 ,  35  34 바이트

^{이 방법으로 일부 산술이 이길 수 있다고 생각합니다.}

ØAḣ7µW€ż;€”#$Ẏ
Ç”C4¦”F⁵¦
Ñi+_⁸?4ị¢

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

1) 음자리표 0또는 1저음 또는 고음과 각각 2) 음표를 취하는 전체 프로그램 ; 및 생성 된 노트를 인쇄하는 단계.

^{31 바이트가 될 것인지 -4및 4음자리표 표시 입력 값 (다음로 인정 하였다 Ñi+_⁸?4ị¢될 수있다 Ñi+⁸ị¢) 그러나 falsey이며, 4의 경우 젤리하지 않다 truthy 아니라면 -4 허용하지이 밝혀져있다.}

어떻게?

팬텀 B#과 E#키가 있는 키보드를 만들고 , 입력 인덱스를 찾은 다음 4, 필요한 방향으로 그 팬텀 키를 필요한 결과 (위의 키)로 교체하여 키보드로 다시 인덱싱하는 오프셋을 찾습니다 .

ØAḣ7µW€ż;€”#$Ẏ - Link 1, keyboard with phantoms: no inputs
ØA             - alphabet yield        -> ['A', 'B', ..., 'Z']
   7           - literal seven
  ḣ            - head                  -> ['A','B','C','D','E','F','G']
    µ          - new monadic chain, call that K
     W€        - wrap €ach             -> ["A","B","C","D","E","F","G"] ("" being lists of characters)
            $  - last two links as a monad:
          ”#   -   character '#'
        ;€     -   concatenate to €ach -> ["A#","B#","C#","D#","E#","F#","G#"]
       ż       - zip together          -> [["A","A#"],["B","B#"],["C","C#"],["D","D#"],["E","E#"],["F","F#"],["G","G#"]]
             Ẏ - tighten               -> ["A","A#","B","B#","C","C#","D","D#","E","E#","F","F#","G","G#"]

Ç”C4¦”F⁵¦ - Link 2, keyboard with phantoms replaced: no inputs
Ç         - call the last link (1) as a monad  ["A","A#","B","B#","C","C#","D","D#","E","E#","F","F#","G","G#"]
    ¦     - sparse application:
   4      - ...to index: literal four
 ”C       - ...action: character 'C'    -> ["A","A#","B","C","C","C#","D","D#","E","E#","F","F#","G","G#"]
        ¦ - sparse application:
       ⁵  - ...to index: literal ten
     ”F   - ...action: character 'F'    -> ["A","A#","B","C","C","C#","D","D#","E","F","F","F#","G","G#"]

Ñi+_⁸?4ị¢ - Main link: integer, clef (1 Treble / 0 Bass); list of characters, key
                                      e.g. 0; "D#"
Ñ         - next link (1) as a monad (no atom for next link as a nilad, but this works here anyway)
          -                               ["A","A#","B","B#","C","C#","D","D#","E","E#","F","F#","G","G#"]
 i        - first index of key in that    8
      4   - literal four
     ?    - if:
    ⁸     - ...condition: chain's left argument, clef
  +       - ...then: addition
   _      - ...else: subtraction          4
        ¢ - next link as a nilad          ["A","A#","B","C","C","C#","D","D#","E","F","F","F#","G","G#"]
       ị  - index into                    "C"

Befunge, 70 64 바이트

~0~:70p##~+2%00p+"A"-~7%2++7%:3%2%00g*:10p+"A"+,00g!10g+#@_"#",@

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

입력은 나머지 형식이 어쨌든 무시 되므로 음자리표는 단순히 첫 글자 (예 : 또는 ) 일 수 있지만 C# Treble또는 형식이어야 합니다.F BassTB

설명

~0        Read the note and push a zero (the purpose of this will become apparent later).
~:70p     Read the following sharp or space and write that out as the next instruction.

이 코드 수정의 결과로 다음 명령어 시퀀스는 두 가지 형식 중 하나를 따릅니다.

##~       The first # jumps over the second, and thus we perform the read instruction.
 #~       But if there's only one #, we'll ending up skipping the read instruction.

이 시점에서 스택은 note,0,sharp,space또는을 포함 note,0,space합니다.

+2%       Add the top two stack items mod 2, returning 1 if we read a sharp, else 0 if not.
00p       Save this 'sharp' boolean for later use.

이 시점에서 스택은 포함 note,0하거나 단지 note(아래에 내재 된 0으로) 있습니다.

+         By adding the top two items, we combine the 0 (if present) onto the note below.
"A"-      We can then subtract 'A' to convert the note into a number in the range 0 to 6.
~7%2+     Read the T/B clef, then mod 7 and add 2, returning 2 or 5 (the conversion offset).
+7%       Add that offset to our note number, then mod 7, to get the converted note number.
:3%2%     Make a dup, and calculate mod 3 mod 2 to determine the special cases (B# or E#).
00g*      Multiply that by the 'sharp' boolean, since we only care if the input was sharp.
:10p      Duplicate and save this special case boolean for later.
+         Now add it to the note number, since the special cases need to be offset by 1.
"A"+,     Then we can finally convert the number back into a character and output it.
00g!10g+  Now we check if the original note was not sharp, or if this was a special case.
#@_       If so, we exit immediately.
"#",@     Otherwise, we output a '#'.

펄 5, 56 바이트

$_=<>;s/./chr 65+(-4*<>+ord$&)%7/e;s/B#/C/;s/E#/F/;print

STDIN에서 음표와 ​​음자리표를 두 줄로 읽고 새 음표를 STDOUT에 인쇄합니다. 음자리표는 0고음과 1저음을위한 것입니다.

자바 스크립트 (ES6) 74 바이트

태닝 구문 입력을 받고 있다 위한 베이스 및 위해 고음 .(note)(clef)clef01

n=>c=>'FC.DAFCGDAEBF'[k=(parseInt(n,36)*15+!n[1]*90+c)%98%13]+(k<5?'#':'')

데모

let f =

n=>c=>'FC.DAFCGDAEBF'[k=(parseInt(n,36)*15+!n[1]*90+c)%98%13]+(k<5?'#':'')

;[1, 0].forEach(c => {
  [ 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B', 'C', 'C#', 'D', 'D#' ].forEach(n => {
    console.log(
      (n + '  ').slice(0, 3) +
      ['Bass  ', 'Treble'][c] +
      ' --> ' +
      f(n)(c)
    )
  })
})

어떻게?

이것은 실제로 이전 버전보다 약간 덜 재미 있지만 기본 조회 테이블은 이제 # 조건 F#,C#,(unused),D#,A#,F,C,G,D,A,E,B,F을 단축 하면서 NUL 문자 트릭 을 피할 수있게 해줍니다 .

이전 버전 76 75 바이트

n=>c=>'ACCDFF.CDEFGABCDE'[k=parseInt(4*!!n[1]+c+n,21)%24%17]+'\0#'[45>>k&1]

데모

let f =

n=>c=>'ACCDFF.CDEFGABCDE'[k=parseInt(4*!!n[1]+c+n,21)%24%17]+'\0#'[45>>k&1]

;[1, 0].forEach(c => {
  [ 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B', 'C', 'C#', 'D', 'D#' ].forEach(n => {
    console.log(
      (n + '  ').slice(0, 3) +
      ['Bass  ', 'Treble'][c] +
      ' --> ' +
      f(n)(c)
    )
  })
})

어떻게?

입력 (n, c) 은 다음 단계를 통해 처리됩니다.

1. 우리는 먼저 평가 4 * !!n[1] + c + n곳 !!n[1]입니다 진정한 (강제 변환 한 메모가 포함 된 경우) # 하고, 거짓 (강제 변환 0 , 그렇지 않으면). 표현식 4 * !!n[1] + c은 문자열 n 앞에 추가 된 숫자 값을 생성합니다 .

2. 암시 적 단계 : 선행 0과 후행 # 은 무시됩니다 parseInt(). 예를 들어 "5G#"실제로는로 구문 분석됩니다 "5G".

3. 새 문자열을 기본 21 수량으로 구문 분석하여 10 진수 값으로 변환합니다.

4. 우리는 모듈로 24를 적용합니다.

5. 우리는 모듈로 17을 적용합니다.

다음은 가능한 모든 입력 쌍에 대한 요약 테이블과 예상 출력입니다. 유의 #는 최종 결과 인 경우 출력에 추가되어야 0 , 2 , 3 또는 5 . 따라서 이진 마스크 101101 ( 10 진수 45 )의 사용.

 n   | c | (1)   | (2)   | (3) | (4) | (5) | Output
-----+---+-------+-------+-----+-----+-----+-------
"E"  | 1 | "1E"  | "1E"  |  35 |  11 |  11 | "G"
"F"  | 1 | "1F"  | "1F"  |  36 |  12 |  12 | "A"
"F#" | 1 | "5F#" | "5F"  | 120 |   0 |   0 | "A#"
"G"  | 1 | "1G"  | "1G"  |  37 |  13 |  13 | "B"
"G#" | 1 | "5G#" | "5G"  | 121 |   1 |   1 | "C"
"A"  | 1 | "1A"  | "1A"  |  31 |   7 |   7 | "C"
"A#" | 1 | "5A#" | "5A"  | 115 |  19 |   2 | "C#"
"B"  | 1 | "1B"  | "1B"  |  32 |   8 |   8 | "D"
"C"  | 1 | "1C"  | "1C"  |  33 |   9 |   9 | "E"
"C#" | 1 | "5C#" | "5C"  | 117 |  21 |   4 | "F"
"D"  | 1 | "1D"  | "1D"  |  34 |  10 |  10 | "F"
"D#" | 1 | "5D#" | "5D"  | 118 |  22 |   5 | "F#"
-----+---+-------+-------+-----+-----+-----+-------
"E"  | 0 | "0E"  | "E"   |  14 |  14 |  14 | "C"
"F"  | 0 | "0F"  | "F"   |  15 |  15 |  15 | "D"
"F#" | 0 | "4F#" | "4F"  |  99 |   3 |   3 | "D#"
"G"  | 0 | "0G"  | "G"   |  16 |  16 |  16 | "E"
"G#" | 0 | "4G#" | "4G"  | 100 |   4 |   4 | "F"
"A"  | 0 | "0A"  | "A"   |  10 |  10 |  10 | "F"
"A#" | 0 | "4A#" | "4A"  |  94 |  22 |   5 | "F#"
"B"  | 0 | "0B"  | "B"   |  11 |  11 |  11 | "G"
"C"  | 0 | "0C"  | "C"   |  12 |  12 |  12 | "A"
"C#" | 0 | "4C#" | "4C"  |  96 |   0 |   0 | "A#"
"D"  | 0 | "0D"  | "D"   |  13 |  13 |  13 | "B"
"D#" | 0 | "4D#" | "4D"  |  97 |   1 |   1 | "C"

파이썬 2 , 77 바이트

로 인쇄하는 기능 STDOUT. True저음을 고음으로 False변환하고 고음을 저음으로 변환합니다.

def f(n,c):N=ord(n[0])-63-4*c;M=-~N%3<1<len(n);print chr((N+M)%7+65)+n[1:2-M]

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

설명:

• 첫 번째 문 N=ord(n[0])-63-4*c;은 샤프를 무시하고 새 음표의 색인 (0 ~ 7)을 계산합니다.
  • ord(N[0])-63-4*c현재 문자의 색인을 가져오고 값에 따라 2를 더하거나 뺍니다 c(변환 방향을 전환 할 수있는 변수).
• 다음 문장 M=-~N%3<1<len(n);은이 변수를 조정해야하는지 여부를 계산합니다. 예를 들어, 새 메모가 E이고 원본 메모가 날카 로웠다면으로 조정해야합니다 F. 연쇄 불평등은 다음과 같이 작동합니다.
  • -~N%3<1새 메모의 색인이 순서에 있는지 확인합니다 3n-1. 이것은 단지 true를 얻을 것 E와 B날카로운가없는 두 음을.
  • 1<len(n)원본 음표가 날카 로웠는지 확인합니다 (문자열 길이가 1보다 큼). 예리하지 않은 경우 새 메모를 조정할 필요가 없으므로이 작업이 필요합니다.
  • 이 세트의 값 M에 대한 하나 True또는 False로서 계산에 이용 될 수 있고, 1그리고 0우리는 단지 M N에 추가하고 (7)에 의해 필요 모듈로 상기 조정을 수행하기 위해, 각각.
• 최종 문장은 최종 결과를 생성하고 출력합니다.
  • chr((N+M)%7+65) 필요한 경우 조정을 추가 한 다음 값을 색인에서 문자로 다시 변환합니다.
  • +n[1:2-M]M=0(조정이 이루어지지 않은) 두 개의 원래 값이 모두 날카로운 경우 날카로운 기호를 추가합니다 .

자바 8, 119 바이트

n->b->(b?"C D E F G A B C# F F# A# C":"F G A B C D E F# A# C D# F").split(" ")["A B C D E F G A#C#D#F#G#".indexOf(n)/2]

설명:

여기에서 시도하십시오.

n->b->         // Method with String and boolean parameters and String return-type
  (b?          //  If it's Treble:
    "C D E F G A B C# F F# A# C"
               //   Use this String
   :           //  Else (it's Bass):
    "F G A B C D E F# A# C D# F")
               //   Use this String
  .split(" ")  //  Split this String by spaces,
   [           //  and then get the item at index:
    "A B C D E F G A#C#D#F#G#".indexOf(n)
               //   Get the index of the String on the left,
    /2]        //   and divide this by 2
               // End of method (implicit / single-line return-statement)

R , 111 바이트

function(k,C,N=paste0(LETTERS[2:15%/%2],c("","#")))sub("E#","F",sub("B#","C",N[which(k==N[(4:17+6*C)%%14+1])]))

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

언 골프 드 :

function(k,C){
  N=paste0(LETTERS[2:15%/%2],c("","#")) # Generate a vector of the notes, including E# and B#
  M=N[(4:17+6*C)%%14+1])                # Create a copy that's cycled either up 4 or down 4
  P=N[which(k==M)]                      # Look up the input note in the complementary vector
  P=sub("B#","C",P)                     # Replace B# with C
  P=sub("E#","F",P)                     # Replace E# with F
}