12

इससे पहले कि आप छोड़ दें, आपको इस चुनौती को करने के लिए अधिक संगीत संकेतन को समझने की आवश्यकता नहीं है।

व्याख्या

मानक शीट संगीत में, डबल क्लीफ़्स पूरे पृष्ठ पर जाते हैं जो नोटों के संदर्भ बिंदुओं के रूप में काम करते हैं, जिससे आपको पता चल जाता है कि क्या नोट चलाया जाना चाहिए। यदि आप पहले से ही ट्रेबल और बास फांक से परिचित नहीं हैं, तो यहां विकिपीडिया से एक विवरण दिया गया है:

एक फांक एक संगीत प्रतीक है जिसका उपयोग लिखित नोट्स की पिच को इंगित करने के लिए किया जाता है। सीढ़ी की शुरुआत में एक पंक्ति पर रखा गया, यह उस रेखा पर नोटों के नाम और पिच को इंगित करता है। यह रेखा एक संदर्भ बिंदु के रूप में कार्य करती है जिसके द्वारा किसी भी अन्य पंक्ति या सीढ़ी के स्थान पर नोटों के नाम निर्धारित किए जा सकते हैं।

ऊपर की छवि में, लाइनों के शीर्ष आधा ट्रेबल फांक है, एक के साथ चिह्नित

नीचे आधा बास फांक है, एक के साथ चिह्नित

जैसा कि आप देख सकते हैं कि ट्रेबल क्लीफ पर सबसे नीचे की तरफ एक नोट एक E है । (मैं इस चुनौती के लिए फांक लाइनों के बाहर नोटों की गिनती नहीं कर रहा हूं) बास फांक पर, सबसे कम रेखा एक जी है । इस चुनौती को पूरा करने के लिए, आपको निम्नलिखित कार्य करने होंगे:

चुनौती

निम्नलिखित में से किसी एक रूप (आपकी पसंद) में एक इनपुट को देखते हुए, इसे विपरीत फांक में बदल दें। चाहे वह ट्रेबल हो या बास क्लेफ़ आपकी भाषा में ट्रूथी / फाल्सी मूल्य हो सकता है (न कि केवल दो दो), उदाहरण के लिए।

एफ # टी या एफ # ट्रू या एफ # ट्रेबल

लेकिन नहीं

एफ # -1 या एफ # 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 music conversion

— FantaC
स्रोत

1

क्या हमें फ्लैटों के बारे में चिंता करना है? डबल फ्लैट / शार्प के बारे में कैसे?

— मैपेटेलियन

1

कृपया उन विषयों के लिए टैग न बनाएं जो उन्हें वारंट नहीं करते हैं।

— जोनाथन एलन

3

क्या व्हॉट्सएप का पता लगाना ( C बदले की वापसी C) ठीक है?

— लिन

2

उपयोग कर रहा है 1और -1(या यहां तक कहते हैं, 4और -4) कुंजी सूचक इनपुट की अनुमति के लिए या यह केवल स्वीकार्य होगा अगर वे हमारी भाषा में truthy / falsey मान रहे हैं?

— जोनाथन एलन

1

यह एक अच्छी और अच्छी तरह से प्रस्तुत चुनौती है, लेकिन यह थोड़ा आराम से इनपुट / आउटपुट प्रारूपों के साथ बेहतर आईएमओ भी होता।

— Arnauld

5

जेली , 35 34 बाइट्स

^{मुझे लग रहा है कि इस पद्धति पर कुछ अंकगणित जीत सकते हैं।}

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

इसे ऑनलाइन आज़माएं!

एक पूर्ण कार्यक्रम ले रहा है 1) फांक संकेतक 0या 1क्रमशः बास या ट्रेबल के लिए और 2) नोट; और परिणामस्वरूप नोट की छपाई।

^{यदि क्लीफ़ इंडिकेटर इनपुट वैल्यूज़ (तब बन सकती हैं ) के रूप में 31 बाइट्स -4और 4स्वीकार्य थे, लेकिन यह स्पष्ट नहीं किया गया है जब तक कि अनुमति नहीं दी जाती है जब तक कि -4 फ़ॉसी नहीं है और 4 सत्य है, जो कि जेली के लिए मामला नहीं है।Ñi+_⁸?4ị¢Ñi+⁸ị¢}

कैसे?

फ़ैंटम 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"

— जोनाथन एलन
स्रोत

ग्रीन चेक: हम्म, इसलिए किसी ने अभी तक इस स्कोर को नहीं हराया है - मैं काफी हैरान हूं।

— जोनाथन एलन

9

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.

इस कोड संशोधन के परिणामस्वरूप, निर्देशों का अगला क्रम दो रूपों में से एक ले जाएगा:

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

— जेम्स होल्डरनेस
स्रोत

3

पर्ल 5, 56 बाइट्स

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

नोट पढ़ता है और STDIN से दो पंक्तियों के रूप में साफ होता है और नए नोट को STDOUT में प्रिंट करता है। फांक 0तिहरा और 1बास के लिए है।

— faubi
स्रोत

1

-pफ्लैग tio.run/##K0gtyjH9/79YX08/OaNIwcxUW0PXRMvGTju/KEVFTVPVXD-…

— Nahuel Fouilleul

3

जावास्क्रिप्ट (ईएस 6) 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लिए # स्थिति को छोटा करने की अनुमति देता है - जो कि थोड़ी सी सीमा-रेखा थी, मुझे लगता है।

पिछला संस्करण 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) को निम्न चरणों के माध्यम से संसाधित किया जाता है:

हम पहले का मूल्यांकन 4 * !!n[1] + c + nजहां !!n[1]है सच (करने के लिए मजबूर 1 ) अगर टिप्पणी एक होता है # , और झूठी (करने के लिए मजबूर 0 ) अन्यथा। अभिव्यक्ति का 4 * !!n[1] + cपरिणाम एक संख्यात्मक मान होता है जो स्ट्रिंग n के सामने जोड़ा जाता है ।
निहित कदम: अग्रणी शून्य और अनुगामी # द्वारा अनदेखा किया जाता है parseInt()। उदाहरण के लिए, "5G#"वास्तव में के रूप में पार्स किया गया है "5G"।
हम आधार -21 मात्रा के रूप में पार्स करके नए स्ट्रिंग को दशमलव मान में परिवर्तित करते हैं।
हम मोडुलो 24 लागू करते हैं।
हम मोडुलो 17 लागू करते हैं।

नीचे अपेक्षित आउटपुट के साथ सभी संभावित इनपुट जोड़े के लिए सारांश तालिका है। ध्यान दें कि यदि अंतिम परिणाम 0 , 2 , 3 या 5 है तो एक # आउटपुट में जोड़ा जाना चाहिए । इसलिए बाइनरी मास्क 101101 ( दशमलव में 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"

— Arnauld
स्रोत

3

पायथन 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। यह केवल Eऔर उसके लिए सही होगा B, जिन दो नोटों में पैनापन नहीं है।
- 1<len(n)जाँच करें कि क्या मूल नोट में तेज था (यह स्ट्रिंग की लंबाई 1 से बड़ा करेगा)। यह आवश्यक है, जैसे कि अगर कोई तेज नहीं था, तो नए नोट पत्रों को समायोजित करने की कोई आवश्यकता नहीं है।
- यह या Mतो और के मूल्य को निर्धारित करता है , जिसका उपयोग गणना के रूप में और क्रमशः किया जा सकता है, इसलिए समायोजन करने के लिए हमें केवल M को N और modulo को 7 से जोड़ना होगा।TrueFalse10
अंतिम विवरण अंतिम परिणाम बनाता है और आउटपुट करता है।
- chr((N+M)%7+65) यदि आवश्यक हो तो समायोजन जोड़ता है, फिर मूल्य को एक सूचकांक से वापस चरित्र में परिवर्तित करता है।
- +n[1:2-M]यदि दोनों M=0(कोई समायोजन नहीं किया गया था) एक तेज प्रतीक को जोड़ देगा और मूल मूल्य भी एक तेज था।

— FlipTack
स्रोत

1

क्षमा करें, केवल 0 & 1, Truthey & Falsey, या T & B

— FantaC

@tfbninja स्पष्टीकरण के लिए धन्यवाद

— FlipTack

2

जावा 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)

— केविन क्रूज़सेन
स्रोत

1

99 बाइट्स के साथ एक और समाधान:n->b->((char)((n.charAt(0)-(b?0:4))%7+65)+n.substring(1)).replaceAll("B#","C").replaceAll("E#","F")

— नहुएल फौलीउल

@NahuelFouilleul आह अच्छा! मैं वास्तव में चार-कास्ट के साथ कुछ सोच रहा था और कुछ मोडुलो कम हो सकता है। लेकिन चूंकि यह मेरे वर्तमान उत्तर से थोड़ा अलग है, इसलिए इसे एक अलग उत्तर के रूप में पोस्ट करने के लिए स्वतंत्र महसूस करें। तुम मेरे upvote हो अगर तुम करते हो :)

— केविन क्रूज़सेन 16

0

आर , 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])]))

इसे ऑनलाइन आज़माएं!

Ungolfed:

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
}

— user2390246
स्रोत

संगीत के बीच में परिवर्तित करें

जेली , 35 34 बाइट्स

कैसे?

Befunge, 70 64 बाइट्स

पर्ल 5, 56 बाइट्स

जावास्क्रिप्ट (ईएस 6) 74 बाइट्स

डेमो

कैसे?

पिछला संस्करण 76 75 बाइट्स

डेमो

कैसे?

पायथन 2 , 77 बाइट्स

जावा 8, 119 बाइट्स

आर , 111 बाइट्स