あなたが去る前に、あなたはこの挑戦をするために多くの楽譜を理解する必要はありません。

説明

標準的な楽譜では、音部記号はページを横切って音符への参照ポイントとして機能し、どの音符を演奏するべきかを知らせます。高音部記号と低音部記号にまだ慣れていない場合は、ここから説明します Wikipediaのください。

音部記号は、音符のピッチを示すために使用される音楽記号です。ステーブの先頭にある行の1つに配置され、その行のノートの名前とピッチを示します。この行は、ステーブの他の行またはスペース上のノートの名前を決定する基準点として機能します。

上の画像では、線の上半分がト音記号であり、

下半分は低音部記号で、

高音部記号を見るとわかるように、一番下の行のノートはEです。（このチャレンジでは、音部記号の外側の音符は数えません）低音部記号の一番下の線は Gです。この課題を完了するには、次のことを行う必要があります。

チャレンジ

次のいずれかの形式の入力（任意）を指定して、反対の音部記号に変換します。高音部記号と低音部記号のどちらであるかは、言語のTruthey / Falsey値（2つの値だけでなく）になります。

F＃T または F＃True または F＃Treble

だがしかし

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＃がないことに注意してください。これは、ベース音部記号にG＃が指定されている場合、E＃を返す代わりに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 Bassがありますが、音部記号は単に最初の文字（TまたはB）である場合があります。残りの入力は無視されるためです。

説明

~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.

このコード変更の結果、命令の次のシーケンスは次の2つの形式のいずれかを取ります。

##~       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。

+         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 '#'.

Perl 5、56バイト

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

音符と音部記号をSTDINから2行として読み取り、新しい音符をSTDOUTに出力します。音部記号は0高音1用と低音用です。

JavaScript（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]である真（に強制1ノートが含まれている場合）＃を、そして偽（に強制変換0それ以外）。この式の4 * !!n[1] + c結果、文字列nの前に数値が追加されます。

2. 暗黙のステップ：先行ゼロと後続＃は無視され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"

Python 2 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現在の文字のインデックスを取得し、c（変換方向を切り替える変数）の値に応じて2を加算または減算します
• 次のステートメントは、M=-~N%3<1<len(n);この変数を調整する必要があるかどうかを計算します。たとえば、新しいノートがEで、元のノートがシャープだった場合、これをに調整する必要がありFます。連鎖不等式は次のように機能します。
  • -~N%3<1新しいノートのインデックスがシーケンス内にあるかどうかを確認します3n-1。これはEおよびB、シャープを持っていない2冊のノート。
  • 1<len(n)元のノートにシャープがあるかどうかを確認します（これにより、文字列の長さが1より大きくなります）。これは、シャープがなかった場合、新しいノート文字を調整する必要がないため必要です。
  • これにより、の値がまたMはのいずれかに設定されます。TrueこれらFalseはそれぞれ1およびとして計算に使用できる0ため、調整を実行するには、MをNに加算し、7を法として必要です。
• 最終ステートメントは、最終結果を作成して出力します。
  • chr((N+M)%7+65) 必要に応じて調整を追加し、値をインデックスから文字に変換します。
  • +n[1:2-M]両方M=0（調整が行われなかった）と元の値にもシャープがある場合、シャープ記号が追加されます。

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