दिशा-निर्देश

कार्य

दो नोटों को देखते हुए, स्ट्रिंग्स या सूचियों / सरणियों के रूप में इनपुट किया गया, गणना करें कि वे कितने सेमिटोन हैं, जो एक संख्या के रूप में आउटपुट होते हैं (स्वयं नोटों के समावेशी)।

एक अर्धविराम की व्याख्या:

कीबोर्ड के ऊपर या नीचे एक सेमीटोन होता है। एक उदाहरण C से C # है। जैसा कि आप नोट के नीचे देख सकते हैं कि C एक सफेद नोट पर है और C # काला नोट उसके ठीक ऊपर है। सिमिटोन एक काले नोट से अगले सफेद नोट तक, ऊपर या नीचे हैं, इसके अलावा:

B से C
C से B
ई से एफ
एफ से ई

उदाहरण

'A, C' -> 4

'G, G#' -> 2

'F#, B' -> 6

'Bb, Bb' -> 13

नियम

दो नोटों के बीच सबसे बड़ी दूरी 13 सेमीटोन है।
दूसरा इनपुट वाला नोट हमेशा पहले इनपुट वाले नोट के ऊपर होगा।
आप इनपुट को एक स्ट्रिंग, या एक सरणी / सूची के रूप में ले सकते हैं। यदि आप इसे एक स्ट्रिंग के रूप में लेते हैं, तो नोट अल्पविराम से अलग हो जाएंगे (जैसे String -> 'A, F', Array -> ['A', 'F'])।
आप मान सकते हैं कि आपको हमेशा दो वैध नोट दिए जाएंगे।
शार्प के रूप में चिह्नित किए जाएंगे #और फ्लैट्स के रूप में चिह्नित किए जाएंगेb
आपके कोड को एन्होमोनिक समकक्षों का समर्थन करना चाहिए (जैसे कि इसे F # और Gb दोनों का समर्थन करना चाहिए)
आपके कोड को उन नोटों का समर्थन करने की आवश्यकता नहीं है, जिनके साथ नाम हैं, लेकिन एक तेज या फ्लैट के बिना नाम दिया जा सकता है (यानी आपको E #, या Cb का समर्थन करने की आवश्यकता नहीं है)। बोनस अंक यदि आपका कोड हालांकि इसका समर्थन करता है।
आपके कोड को डबल शार्प या डबल फ़्लैट का समर्थन करने की आवश्यकता नहीं है।
आप मान सकते हैं कि यदि आपको एक ही नोट, या समान पिच (जैसे 'Gb, Gb' या 'A #, Bb') दोनों मिलते हैं, तो दूसरा पहले के मुकाबले बिल्कुल एक सप्तक नहीं होगा।
यह कोड गोल्फ है इसलिए कम से कम बाइट्स जीत के साथ जवाब।

code-golf music

— Amorris
स्रोत

मुझे 2 मिलते हैं G -> G#क्योंकि वे दोनों शामिल हैं।

— हाइपरएनुट्रिनो

@ हिपरनेत्रो यपे क्षमा। मेरी तरफ से गलती।

— अमोरिस

1

क्या हमें ऐसे नोटों के लिए पूरा करना होगा Cbया E#? डबल शार्प / फ्लैट्स के बारे में क्या?

— सोक

1

@Sok नहीं, आपके कोड को E # या Cb जैसे नोटों का समर्थन करने की आवश्यकता नहीं है, और इसे डबल शार्प या फ्लैट का समर्थन करने की आवश्यकता नहीं है। मैंने इसे स्पष्ट करने के लिए प्रश्न अपडेट किया है। किसी भी भ्रम के बारे में क्षमा करें।

— अमोरिस

2

बस स्पष्ट होने के लिए, जब एक संगीत सिद्धांत से बात करते हुए सूटिंग में दूरी आपके द्वारा शुरू किए गए नोट को शामिल नहीं करती है । गणित में इसे wold के रूप में दर्शाया जाता है, (X, Y]इसलिए C को C # 1 सेमीटोन और C को C को 12 सेमीिटोन कहा जाता है।

— डोम

7

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

r=1
for s in input():r=cmp(s[1:]+s,s)-ord(s[0])*5/3-r
print-r%12+2

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

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

lambda s,t:13-(q(s)-q(t))%12
q=lambda s:ord(s[0])*5/3+cmp(s,s[1:]+s)

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

— XNOR
स्रोत

B # और Fb जैसे नोटों को संभालने में सक्षम होने के लिए अतिरिक्त अंक, जबकि अभी तक सबसे छोटा शेष है।

— एमोरिस

7

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

@Neil को 1 बाइट धन्यवाद दिया

सिंटेक्स में करीने से नोट्स लेता है (a)(b)।

a=>b=>((g=n=>'0x'+'_46280ab_91735'[parseInt(n+3,36)*2%37%14])(b)-g(a)+23)%12+2

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

a=>b=>((g=n=>'0x'+'_46280ab_91735'[parseInt(n+3,36)*2%37%14])(b)-g(a)+23)%12+2

console.log(f('A')('C'))   // 4
console.log(f('G')('G#'))  // 2
console.log(f('F#')('B'))  // 6
console.log(f('Bb')('Bb')) // 13

स्निपेट का विस्तार करें

हैश फंकशन

हैश फ़ंक्शन का उद्देश्य हेक्साडेसिमल में संग्रहित एक लुकअप तालिका में एक नोट को पॉजिटिव टेबल में बदलने के लिए होता है, जिसमें सेमीऑनसेट ऑफ़सेट (C = 0, C # = 1, ..., B = 11) होता है।

हम पहले नोट में '3' जोड़ते हैं और आधार -36 में परिणामी स्ट्रिंग को पार्स करते हैं, जिससे पूर्णांक N बनता है । क्योंकि '#' एक अमान्य चरित्र है, इसलिए इसे अनदेखा कर दिया जाता है, इसके साथ ही किसी भी वर्ण का अनुसरण किया जाता है।

फिर हम गणना करते हैं:

H(N) = ((N * 2) MOD 37) MOD 14

नीचे परिणामों का सारांश दिया गया है।

 note | +'3' | parsed as | base 36->10 |   *2  | %37 | %14 | offset
------+------+-----------+-------------+-------+-----+-----+--------
  C   |  C3  |    c3     |         435 |   870 |  19 |   5 |  0x0
  C#  |  C#3 |    c      |          12 |    24 |  24 |  10 |  0x1
  Db  |  Db3 |    db3    |       17247 | 34494 |  10 |  10 |  0x1
  D   |  D3  |    d3     |         471 |   942 |  17 |   3 |  0x2
  D#  |  D#3 |    d      |          13 |    26 |  26 |  12 |  0x3
  Eb  |  Eb3 |    eb3    |       18543 | 37086 |  12 |  12 |  0x3
  E   |  E3  |    e3     |         507 |  1014 |  15 |   1 |  0x4
  F   |  F3  |    f3     |         543 |  1086 |  13 |  13 |  0x5
  F#  |  F#3 |    f      |          15 |    30 |  30 |   2 |  0x6
  Gb  |  Gb3 |    gb3    |       21135 | 42270 |  16 |   2 |  0x6
  G   |  G3  |    g3     |         579 |  1158 |  11 |  11 |  0x7
  G#  |  G#3 |    g      |          16 |    32 |  32 |   4 |  0x8
  Ab  |  Ab3 |    ab3    |       13359 | 26718 |   4 |   4 |  0x8
  A   |  A3  |    a3     |         363 |   726 |  23 |   9 |  0x9
  A#  |  A#3 |    a      |          10 |    20 |  20 |   6 |  0xa
  Bb  |  Bb3 |    bb3    |       14655 | 29310 |   6 |   6 |  0xa
  B   |  B3  |    b3     |         399 |   798 |  21 |   7 |  0xb

फ्लैट और शार्प के बारे में

नीचे प्रमाण है कि यह हैश फ़ंक्शन सुनिश्चित करता है कि '#' के बाद वाला नोट अगले नोट की तुलना में 'बी' के समान परिणाम देता है । इस अनुच्छेद में, हम बेस -36 मात्राओं के लिए उपसर्ग @ का उपयोग करते हैं ।

उदाहरण के लिए, Db को @ db3 में परिवर्तित किया जाएगा और C # को @c (पिछले पैरा देखें) में परिवर्तित किया जाएगा । हम यह साबित करना चाहते हैं:

H(@db3) = H(@c)

या सामान्य मामले में, वाई = एक्स + 1 के साथ :

H(@Yb3) = H(@X)

@ बी 3 है 399 दशमलव में। इसलिए:

H(@Yb3) =
@Yb3 * 2 % 37 % 14 =
(@Y * 36 * 36 + 399) * 2 % 37 % 14 =
((@X + 1) * 36 * 36 + 399) * 2 % 37 % 14 =
(@X * 1296 + 1695) * 2 % 37 % 14

1296 1 मोडुलो 37 के अनुरूप है , इसलिए इसे इस प्रकार सरल बनाया जा सकता है:

(@X + 1695) * 2 % 37 % 14 =
((@X * 2 % 37 % 14) + (1695 * 2 % 37 % 14)) % 37 % 14 =
((@X * 2 % 37) + 23) % 37 % 14 =
((@X * 2 % 37) + 37 - 14) % 37 % 14 =
@X * 2 % 37 % 14 =
H(@X)

एक विशेष मामला जी # से अब तक का संक्रमण है , क्योंकि हम उपरोक्त सूत्रों का पालन करने के लिए एचबी की अपेक्षा करेंगे । हालाँकि, यह भी काम करता है क्योंकि:

@ab3 * 2 % 37 % 14 = @hb3 * 2 % 37 % 14 = 4

— Arnauld
स्रोत

@ नील धन्यवाद! आपका अनुकूलन खदान से अधिक बाइट बचाता है।

— अरनौलड

हुह, मुझे वास्तव में मेरे बैच समाधान के साथ उल्टा मिला ...

— नील

@ नील क्योंकि बैच में मोदुलो का चिन्ह भाजक का चिन्ह है, मुझे लगता है?

— अरनौलद

नहीं, यह जेएस के रूप में लाभांश का संकेत है, लेकिन यह परिणाम के संकेत के लिए सही करने के लिए थोड़ा गोल्फ खिलाड़ी निकला, जो पहले वाले गोल्फ के कारण उलटा था।

— नील

4

पर्ल, 39 32 बाइट्स

के लिए शामिल +1हैp

STDIN पर दो लाइनों के रूप में आरंभ और समाप्ति नोट दें

(echo "A"; echo "C") | perl -pe '$\=(/#/-/b/-$\+5/3*ord)%12+$.}{'; echo

बस कोड:

$\=(/#/-/b/-$\+5/3*ord)%12+$.}{

— टन हास्पेल
स्रोत

कमांड लाइन के झंडे अब स्वतंत्र हैं

— wastl

@wastl तो मुझे बताया गया है। मैं जानना चाहता हूं कि कौन सी मेटा पोस्ट है, इसलिए मैं वहां जा सकता हूं और असहमत हूं :-)

— टन हास्पेल

मेरी टिप्पणी एक कड़ी है। बेझिझक इसे क्लिक करें।

— बंजर भूमि

ऐसा लगता है कि यह मेरे समान ही काम करता है - लेकिन पर्ल के लिए बहुत ही कम, +1

— लेवल रिवर सेंट

@LevelRiverSt अच्छी तरह से, यह है टन Hospel।

— msh210

4

जाप , 27 बाइट्स

®¬x!b"C#D EF G A"ÃrnJ uC +2

इसे ऑनलाइन टेस्ट करें! दो तारों के एक सरणी के रूप में इनपुट लेता है।

किसी भी आधार नोट पर शार्प या फ्लैट्स की किसी भी राशि के लिए काम करता है!

व्याख्या

®¬x!b"C#D EF G A"ÃrnJ uC +2   Let's call the two semitones X and Y.
®                Ã            Map X and Y by
 ¬                              splitting each into characters,
  x                             then taking the sum of
   !b"C#D EF G A"               the 0-based index in this string of each char.
                                C -> 0, D -> 2, E -> 4, F -> 5, G -> 7, A -> 9.
                                # -> 1, adding 1 for each sharp in the note.
                                b -> -1, subtracting 1 for each flat in the note.
                                B also -> -1, which happens to be equivalent to 11 mod 12.
                                The sum will be -2 for Bb, 2 for D, 6 for F#, etc.
                              Now we have a list of the positions of the X and Y.
                  rnJ         Reduce this list with reversed subtraction, starting at -1.
                              This gets the difference Y - (X - (-1)), or (Y - X) - 1.
                      uC      Find the result modulo 12. This is 0 if the notes are 1
                              semitone apart, 11 if they're a full octave apart.
                         +2   Add 2 to the result.

— ETHproductions
स्रोत

2

पर्ल 5 + `-p`, 66 बाइट्स

s/,/)+0x/;y/B-G/013568/;s/#/+1/g;s/b/-1/g;$_=eval"(-(0x$_-1)%12+2"

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

अल्पविराम से अलग किए गए मान लेता है। Cb, B #, E #, Fb और कई # / b के लिए भी काम करता है।

स्पष्टीकरण:

# input example: 'G,G#'
s/,/)+0x/; # replace separator with )+0x (0x for hex) => 'G)+0xG#'
y/B-G/013568/; # replace keys with numbers (A stays hex 10) => '8)+0x8#'
s/#/+1/g; s/b/-1/g; # replace accidentals with +1/-1 => '8)+0x8+1'
$_ = eval # evaluate => 2
    "(-(0x$_-1)%12+2" # add some math => '(-(0x8)+0x8+1-1)%12+2'

निष्कासन के लिए स्पष्टीकरण:

(
    - (0x8) # subtract the first key => -8
    + 0x8 + 1 # add the second key => 1
    - 1 # subtract 1 => 0
) % 12 # mod 12 => 0
+ 2 # add 2 => 2
# I can't use % 12 + 1 because 12 (octave) % 12 + 1 = 1, which is not allowed

— wastl
स्रोत

2

रूबी , 56 बाइट्स

->a{a.map!{|s|s.ord*5/3-s[-1].ord/32}
13-(a[0]-a[1])%12}

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

अक्षरों को उनके ASCII कोड समय के अनुसार पार्स किया 5/3जाता है (यह आवश्यक संख्याओं को सेमीटोन और प्लस ऑफ़ ऑफ़ 108)

A    B    C    D    E    F    G
108  110  111  113  115  116  118

अंतिम वर्ण ( या #, bया फिर पत्र) को इसके ASCII कोड के रूप में 32 से विभाजित किया गया है

# letter (natural) b 
1  { --- 2 --- }   3

यह अक्षर कोड से घटाया जाता है।

फिर अंतिम परिणाम के रूप में वापस किया जाता है 13-(difference in semitones)%12

— स्तर नदी सेंट
स्रोत

2

स्टैक्स , 25 24 बाइट्स

╝─°U┤ƒXz☺=≡eA╕δ┴╬\¿☺zt┼§

इसे ऑनलाइन चलाएं और डीबग करें

इसी कार्यक्रम के संबंधित एएससीआई प्रतिनिधित्व यह है।

{h9%H_H32/-c4>-c9>-mrE-v12%^^

प्रभावी रूप से, यह एक सूत्र का उपयोग करके प्रत्येक नोट के कीबोर्ड इंडेक्स की गणना करता है, फिर परिणामी अंतराल की गणना करता है।

आधार नोट से शुरू करें, ए = 2, बी = 4, ... जी = 14
आकस्मिक ऑफसेट की गणना करें 2 - code / 32जहां codeअंतिम चरित्र का एससी कोड है।
उन्हें एक साथ जोड़ें।
यदि परिणाम> 4 है, तो B # निकालने के लिए 1 घटाएं।
यदि परिणाम> 7 है, तो E # निकालने के लिए 1 घटाएँ।
मॉड्यूलर दो परिणामी नोट इंडेक्स को घटाएं, और 1 जोड़ें।

— पुनरावर्ती
स्रोत

1

["F#","B"]होना चाहिए 6.

— वीजुन झोउ

1

धन्यवाद। मैंने गणना का एक हिस्सा दूसरे को समायोजित किए बिना बदल दिया। यह तय हो चुका है।

— पुनरावर्ती

1

बैच, 136 135 बाइट्स

@set/ac=0,d=2,e=4,f=5,g=7,a=9,r=24
@call:c %2
:c
@set s=%1
@set s=%s:b=-1%
@set/ar=%s:#=+1%-r
@if not "%2"=="" cmd/cset/a13-r%%12

स्पष्टीकरण: cसबरूटीन में प्रतिस्थापन #नोट के नाम के साथ +1और उसके bसाथ प्रतिस्थापित होते हैं-1 । जैसा कि यह असंवेदनशील है, Bbबन जाता है -1-1। के लिए चर C... A(यह भी असंवेदनशील मामला) इसलिए से दूर उचित संख्या में अर्धविराम चुने जाते हैं B=-1। परिणामी स्ट्रिंग का मूल्यांकन किया जाता है, और @ xnor के मूल्य से परिणाम को घटाने की चाल एक दूसरे से नोट मान को घटाने का वांछित प्रभाव देती है। संपादित करें: अंत में मैं 13 से modulo घटाना करने के लिए @ Arnauld की चाल का उपयोग वांछित उत्तर प्राप्त करने के लिए, 1 बाइट की बचत।

— नील
स्रोत

1

अजगर ३ , 95 बाइट्स

lambda a,b:(g(b)+~g(a))%12+2
g=lambda q:[0,2,3,5,7,8,10][ord(q[0])-65]+" #".find(q.ljust(2)[1])

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

-14 बाइट उपयोगकर्ता 71546 के लिए धन्यवाद

— HyperNeutrino
स्रोत

-8 के साथ बाइट्स ord(q[0])-65की जगह "ABCDEFG".find(q[0]));

— Shieru Asakoto

ओह, -6 और बाइट्स की (g(b)+~g(a))%12+2जगह1+((g(b)-g(a))%12or 12)

— Shieru Asakoto

@ user71546 ओह कूल, धन्यवाद!

— हाइपरएनुट्रीनो

1

जेली , 28 बाइट्स

O64_ṠH$2¦ḅ-AḤ’d5ḅ4µ€IḞṃ12FṪ‘

वर्णों की दो सूचियों की एक सूची को स्वीकार करने और पूर्णांक वापस करने वाला एक अद्वैतिक लिंक।

इसे ऑनलाइन आज़माएं! या सभी संभावित मामलों को देखें।

कैसे?

शून्य से बारह तक के पूर्णांक पर नोटों को मैप करने के लिए इनपुट वर्णों के अध्यादेशों पर कुछ विचित्र अंकगणित करता है और फिर एक आधार-अपघटन को बारह से मॉडुलो के लिए एक छद्म के रूप में निष्पादित करता है जहां शून्य को 12 से बदल दिया जाता है।

O64_ṠH$2¦ḅ-AḤ’d5ḅ4µ€IḞṃ12FṪ‘ - Main link, list of lists    e.g. [['F','#'],['B']]  ...or [['A','b'],['G','#']]
                  µ€         - for €ach note list          e.g.  ['F','#'] ['B']          ['A','b'] ['G','#']
O                            - { cast to ordinal (vectorises)    [70,35]   [66]           [65,98]   [71,35]
 64                          -   literal 64
   _                         -   subtract (vectorises)           [-6,29]   [-2]           [-1,-34]  [-7,29]
        ¦                    -   sparse application...
       2                     -   ...to indices: [2] (just index 2)
      $                      -   ...do: last two links as a monad:
    Ṡ                        -          sign                     [-6,1]    [-2]           [-1,-1]   [-7,1]
     H                       -          halve                    [-6,-0.5] [-2]           [-1,-0.5] [-7,0.5]
         ḅ-                  -   convert from base -1            5.5       -2             0.5       7.5
           A                 -   absolute value                  5.5       2              0.5       7.5
            Ḥ                -   double                          11.0      4              1.0       15.0
             ’               -   decrement                       10.0      3              0.0       14.0
              d5             -   divmod by 5                     [2.0,2.0] [0,3]          [0.0,0.0] [2.0,4.0]
                ḅ4           -   convert from base 4             10.0      3              0.0       12.0
                             - } -->                             [10.0,3]                 [0.0,12.0]
                    I        - incremental differences           [-7.0]                   [12.0]
                     Ḟ       - floor (vectorises)                [-7]                     [12]
                      ṃ12    - base decompress using [1-12]      [[5]]                    [[1,12]]
                         F   - flatten                           [5]                      [1,12]
                          Ṫ  - tail                              5                        12
                           ‘ - increment                         6                        13

28 बाइट्स में भी ...

Xnor के पायथन 2 उत्तर का ए (इतना सीधा नहीं) पोर्ट ...

O×5:3z60_Ṡ¥2¦60U1¦Fḅ-‘N%12+2

सभी संभव मामलों की कोशिश करो

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

0

सीजेएम , 67 बाइट्स

l',/~)@)@{ciW*50+_z/}_@\~@@~-@@{ci65- 2*_9>-_3>-}_@\~@@~12+\- 12%+)

ऑनलाइन दुभाषिया: http://cjam.aditsu.net/

— चायल दस ब्रिंक
स्रोत

कितने अर्धविराम

दिशा-निर्देश

कार्य

उदाहरण

नियम

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

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

परीक्षण के मामलों

हैश फंकशन

फ्लैट और शार्प के बारे में

पर्ल, 39 32 बाइट्स

जाप , 27 बाइट्स

व्याख्या

पर्ल 5 + -p, 66 बाइट्स

रूबी , 56 बाइट्स

स्टैक्स , 25 24 बाइट्स

बैच, 136 135 बाइट्स

अजगर ३ , 95 बाइट्स

जेली , 28 बाइट्स

कैसे?

28 बाइट्स में भी ...

सीजेएम , 67 बाइट्स

पर्ल 5 + `-p`, 66 बाइट्स