ट्रम्पेट खेलने में मेरी मदद करें

14

तुरही एक valved आवाज़ का विपुलक साधन है, आमतौर पर में खड़ा किया है B♭। ध्वनि तब की जाती है जब खिलाड़ी अपने होंठों को यंत्र के अंदर हवा में विस्थापित करने के लिए कंपन करता है। उस कंपन को एक विशिष्ट तरीके से किसी के मुंह को स्थापित करके अधिग्रहित किया जाता है, जिसे एम्बॉचर कहा जाता है। तंग या ढीले होठों के साथ अलग-अलग आलिंगन, विभिन्न पिचों का उत्पादन करते हैं।

इसके अलावा, तुरही में प्रत्येक वाल्व भी साधन की पिच को बदलता है। जब उदास होता है, तो एक वाल्व उपकरण के टयूबिंग के अंदर एक मार्ग को बंद कर देता है, जिससे हवा लंबे मार्ग से प्रवाहित होती है, जिससे मूल ध्वनि की पिच कम हो जाती है। इस चुनौती के प्रयोजनों के लिए, हम मानक, B♭तुरही पर विचार करेंगे , जिसमें पहला वाल्व पिच को एक पूर्ण चरण से कम करता है, दूसरा पिच को एक आधे-चरण से कम करता है, और तीसरा एक और एक करके पिच को कम करता है आधा कदम।

चुनौती

आपकी चुनौती एक प्रोग्राम या फ़ंक्शन बनाने की है, जो दो इनपुट दिए गए हों embouchureऔर valves, नोट की पिच का निर्धारण किया जाता है।

इस चुनौती के प्रयोजनों के लिए, नोट्स अनुक्रम का पालन करेंगे:

B♭, B, C, C♯, D, E♭, E, F, F♯, G, G♯, A.

नियम

  • I / O को किसी भी उचित विधि में लिया / दिया जा सकता है ।
  • मानक खामियां लागू होती हैं।
  • आप उपयोग करने की अनुमति bऔर #के बजाय ♭और ♯आप चाहते हैं।
  • के लिए इनपुट valvesको उदास वाल्व ( 1, 3) या बूलियन सूची ( 1, 0, 1) की सूची के रूप में लिया जा सकता है ।
  • यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम कोड जीतता है।

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

Valves इन परीक्षण मामलों में एक बूलियन सूची के रूप में दिया गया है, जहां 0 का अर्थ है उदास और 1 का अर्थ दबाया गया है।

Embouchure:    Valves:   Output:
B♭             0 0 0     B♭
B♭             0 1 0     A
B♭             1 0 1     F
C♯             0 0 1     B♭
C♯             1 1 1     G
E♭             1 0 0     C♯
G              0 1 1     E♭
G♯             1 0 0     F♯
G♯             0 0 1     F
G              1 0 0     F
F♯             1 0 0     E
D              1 0 1     A
A              1 1 1     E♭
E              1 1 0     C♯
E              0 0 1     C♯

डिस्क्लेमर: मैं अभी तक एक संगीतकार के रूप में ज्यादा नहीं हूं, इसलिए मैं किसी भी कसौटी के लिए माफी मांगता हूं जो मैंने परीक्षण के मामलों में बनाया है। सुधार की सराहना की जाती है।

code-golf  music 
— जे। सल्ल
स्रोत
2
यहाँ पर पर्क्युसिनिस्ट। रुको रुको, यह है कि आप कैसे वशीकरण मंत्र। हमेशा यह एक
— ;;
1
@vasilescur आप सही कह रहे हैं। मैं उन्हें ठीक करूंगा और किसी अन्य संभावित गलतियों की समीक्षा करूंगा। सर उठाने के लिए धन्यवाद।
— जे। सेले
1
जैसा कि कोई है जो एक लंबे समय से तुरही बजाता है, मैं वास्तव में उलझन माप से भ्रमित हूं ... उदाहरण के लिए C # Embouchure क्या है?
— बेंडल
1
F# 100ई नहीं होना चाहिए एफ?
— लेवल रिवर सेंट
2
@bendl ऐसी कोई बात नहीं है। आप C#किसी भी वाल्व को दबाए बिना एक तुरही पर नहीं खेल सकते । बस विशिष्ट नोट्स ( B♭-F-B♭-D-F-A♭-B♭...), की ओवरटोन श्रृंखला B♭। फिर भी, भले ही यह एक वास्तविक उपकरण को प्रतिबिंबित न करे लेकिन चुनौती पूरी तरह से परिभाषित है।
— क्रिस

जवाबों:

4

अजगर 3 2, 125 119 81 बाइट्स

lambda e,f,s,t,n=2*'A G# G F# F E Eb D C# C B Bb'.split():n[n.index(e)+2*f+s+3*t]

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

जोनाथन एलन के लिए बहुत सारे बाइट्स का धन्यवाद।

मेरा मूल समाधान ( पायथन 3 में ):

n=2*'Bb B C C# D Eb E F F# G G# A'.split()
e,f,s,t=str(input()).split()
print(n[n.index(e,9)-2*int(f)-int(s)-3*int(t)])

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

6 बाइट्स @HyperNeutrino की बदौलत सहेजे गए।

व्याख्या

सबसे पहले, मैं नोटों की एक सरणी है, लेकिन लंबाई में दोगुनी हो तो मैं से वापस जाएं के बारे में चिंता करने की जरूरत नहीं Bbकरने के लिए A।

फिर, मैं निम्नलिखित प्रारूप में इनपुट लेता हूं (उदाहरण के लिए):

Bb 1 0 1

मैं तब शुरू करने वाले नोट के सूचकांक का उपयोग करता हूं n.index(e,9)( 9क्या यह सुनिश्चित करने के लिए है कि मैं अच्छी तरह से सूची के बीच में शुरू कर दूं)। मैं अभिव्यक्ति के साथ वांछित ऑफसेट की गणना करता हूं:

2*int(f) - int(s) - 3*int(t)

fपहला वाल्व कहाँ है, sदूसरा वाल्व है, और tतीसरा है।

अंत में, यह सूची में पाए गए नोट को शुरुआती सूचकांक से ऑफसेट घटाकर प्रिंट करता है।

— vasilescur
स्रोत
3
रिक्त स्थान से अलग करके कुछ बाइट्स बचाएं। "<some string>".split()डिफ़ॉल्ट रूप से
— व्हाट्सएप
अजगर 2 में जाने (परहेज द्वारा 30 बाइट्स सहेजें strऔर intकलाकारों के साथ और का मूल्यांकन इनपुट की अनुमति देता है) और नोट्स पीछे और आगे समायोजन (परहेज ,9में index। कॉल ऑनलाइन यह कोशिश करो!
— जोनाथन एलन
... और एक और 8 फ़ंक्शन के लिए आगे बढ़ रहा है (जो पायथन 2 या 3 में काम करता है) इसे ऑनलाइन आज़माएं!
— जोनाथन एलन
@JonathanAllan मैंने आपके सुधारों से कई पायथन गोल्फिंग गुर सीखे। आपको बहुत - बहुत धन्यवाद!
— वसीलसर्कुर
... वास्तव में आप पुनरावृत्ति के बिना अपने मूल क्रम में सूची का उपयोग कर सकते हैं और मूल्यों को घटा सकते हैं क्योंकि नकारात्मक सूचकांक कभी भी सीमा से बाहर नहीं जाता है (सबसे नकारात्मक 'Bb', 1, 1, 1आपको सूचकांक में ले -6जाएगा जो Eआवश्यकतानुसार होगा) - यह वही है जो TFeld है जब से किया है ।
— जोनाथन एलन
3

वोल्फ्राम भाषा (गणितज्ञ) , 100 बाइट्स (और एक कामकाजी तुरही के लिए 134)

l="Bb,B,C,C#,D,Eb,E,F,F#,G,G#,A"~StringSplit~",";f=l[[Mod[#&@@#&@@l~Position~#-2#2-#3-3#4-1,12]+1]]&

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

काफी निष्कपट।

l="Bb,B,C,C#,D,Eb,E,F,F#,G,G#,A"~StringSplit~",";f=EmitSound@SoundNote[l[[Mod[#&@@#&@@l~Position~#-2#2-#3-3#4-1,12]+1]],1,"Trumpet"]&

34 बाइट की लागत के लिए एक बेहतर आउटपुट।

— कीउ गण
स्रोत
रुको ... गणितज्ञ के पास ऑडियो आउटपुट है ??? दुष्ट!
— टाइटस
बेशक मैथेमेटिका में ऑडियो आउटपुट के लिए बिल्ट-इन है। यह सोना है।
— जे। साले
2

जेली ,  37  36 बाइट्स

ØAḣ7;⁾#b“®JXrẊỤȥ’ṃnŒl$œṗ$Ḋ©i_⁸æ.J¤ị®

एक डायैडिक लिंक जो वाल्वों को 1एस या 0एस की एक सूची के रूप में स्वीकार करता [second, first, third]है जो बाईं ओर का प्रतिनिधित्व करता है और दाईं ओर वर्णों की सूची के रूप में एम्बुचर होता है जो पात्रों की सूची देता है।

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

कैसे?

ØAḣ7;⁾#b“®JXrẊỤȥ’ṃnŒl$œṗ$Ḋ©i_⁸æ.J¤ị® - Link: list of integers, V; list of characters, E
ØA                                   - yield uppercase alphabet
  ḣ7                                 - head to index 7 = "ABCDEFG"
     ⁾#b                             - literal list of characters = "#b"
    ;                                - concatenate = "ABCDEFG#b"
        “®JXrẊỤȥ’                    - literal integer = 2270857278734171
                 ṃ                   - base decompress (i.e. convert to base 9 using the 'digits' "bABCDEFG#")
                                     -                 = "ABbBCC#DEbEFF#GG#"
                        $            - last two links as a monad:
                     $               -   last two links as a monad:
                   Œl                -     to lower case = "abbbcc#debeff#gg#"
                  n                  -     not equal? (vectorises) = [1,1,0,1,1,1,0,1,1,0,1,1,1,0,1,1,0]
                      œṗ             -   partition at truthy indices = [[],"A","Bb","B","C","C#","D","Eb","E","F","F#","G","G#"]
                         Ḋ           - dequeue = ["A","Bb","B","C","C#","D","Eb","E","F","F#","G","G#"]
                          ©          - copy to register and yield
                           i         - first index of E in there
                                 ¤   - nilad followed by links as a nilad:
                             ⁸       -   chain's left argument, V
                                J    -   range of length [1,2,3]
                              æ.     -   dot product (i.e. 1*second + 2*first + 3*third)
                            _        - subtract
                                   ® - recall from register
                                  ị  - index into (1-based and modular)
— जोनाथन एलन
स्रोत
1

जावास्क्रिप्ट 96 बाइट्स

@Vasilescur विचार के बाद, यह js में कार्यान्वयन है

(a,b,c,d,_="B♭,B,C,C♯,D,E♭,E,F,F♯,G,G♯,A".split`,`)=>(l=_.concat(_))[l.indexOf(a,9)-(2*b+c+3*d)]


a=(a,b,c,d,_="B♭,B,C,C♯,D,E♭,E,F,F♯,G,G♯,A".split`,`)=>(l=_.concat(_))[l.indexOf(a,9)-(2*b+c+3*d)]
console.log(a('B♭',0,0,0))
console.log(a('B♭',0,1,0))
console.log(a('B♭',1,0,1))
console.log(a('C♯',0,0,1))
console.log(a('C♯',1,1,1))
console.log(a('E♭',1,0,0))
console.log(a('G',0,1,1))
console.log(a('G♯',1,0,0))
console.log(a('G♯',0,0,1))
console.log(a('G',1,0,0))
console.log(a('F♯',1,0,0))
console.log(a('D',1,0,1))
console.log(a('A',1,1,1))
console.log(a('E',1,1,0))
console.log(a('E',0,0,1))
स्निपेट का विस्तार करें

— लुइस फेलिप डी जीसस मुनोज
स्रोत
3 बाइट्स कम;) BTW फ्लैट्स और शार्प्स को गिना जाना चाहिए क्योंकि 3 बाइट्स वे नहीं हैं?
— शायरु असकोतो
ओह nvm (मुझे लगता है कि देखा था नहीं bऔर #अनुमति दी जाती है), लेकिन आप का उपयोग करने की आवश्यकता है bऔर #बजाय फ्लैट और तेजधार की।
— शायरु असकोतो
1

बैच, 188 बाइट्स

@set n=%1
@set/aC=0,D=2,Eb=3,E=4,F=5,G=7,A=9,Bb=10,B=11,n=(%n:#=+1%+12-%2*2-%3-%4*3)%%12
@for %%n in (C.0 C#.1 D.2 Eb.3 E.4 F.5 F#.6 G.7 G#.8 A.9 Bb.10 B.11)do @if %%~xn==.%n% echo %%~nn

उपयोग #और b: इसका मतलब यह है कि Ebऔर Bbकानूनी चर नाम हैं; #एक स्ट्रिंग प्रतिस्थापन करने के द्वारा नियंत्रित किया जाता है +1। स्ट्रिंग प्रतिस्थापन के परिणाम का मूल्यांकन स्वचालित रूप से किया जाता है और फिर वाल्व को सूची में देखने से पहले वाल्व को ध्यान में रखा जाता है।

— नील
स्रोत
1

स्टैक्स , 32 बाइट्स

τ┤=Yº○!AÄΔâß₧←╥╟ö'ÄD├æñßf╧å▬tó÷╖

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

यह एक नोट का नाम और उदास वाल्वों की एक सूची लेता है। यह नोट नामों की एक सरणी बनाता है, फिर कुल वाल्व अंतराल की गणना करता है, और सरणी में उस ऑफसेट पर नोट प्राप्त करता है।

"AbABbBCC#DEbEFF#G" just a literal
{VA#}(Y             partition at capital letters and store in y
,]I                 get the index of the input note
,2R:t               swap 1s and 2s in valve list
{-F                 subtract valve list from note index
y@                  look up result from note array

इसको चलाओ

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

Perl6 / Rakudo 73 वर्ण

तकनीकी तौर पर यह 83 बाइट्स है क्योंकि मैंने यूनिकोड के पात्रों को रखा है, लेकिन ASCII समकक्षों के लिए उन्हें स्वैप करने से 73 बाइट्स मिलेंगे।

के रूप में एक {code block}तरह के मानकों के साथ $^aयह एक लैम्ब्डा, एक हस्ताक्षर के साथ है ($a, $b, $c, $d)।

{$_=2*$^b+$^c+3*$^d;'AG♯GF♯FEE♭DC♯CBB♭'x 2~~/$^a(\w\W?)**{$_}/~~/\w\W?$/}

इसे कहते हैं:

say { ... }("D", 1, 0, 1)
>> A

कम-golfed:

sub f($a, $b, $c, $d) {
   my $totalShift = 2*$b + $c + 3*$d;
   my $doubledScale = 'AG♯GF♯FEE♭DC♯CBB♭' x 2;
   my $matchEmbOnward = $doubledScale ~~ / $^a (\w\W?)**{$totalShift} /;
   my $matchFinalNote = $marchEmbOnward ~~ / \w \W? $ /;
   return $matchFinalNote;
}

यहाँ हम infix ऑपरेटर '...' x 2का उपयोग करते हुए एक स्ट्रिंग को दोगुना करते हैं x, फिर स्मार्टचैच ऑपरेटर का उपयोग करते हुए n नोट्स द्वारा खोजे जाने वाले एम्ब्रेचर की खोज करते हैं '...' ~~ /.../- रेगेक्स टिका है \w\W?जिस पर एक शब्द चार है तो शायद एक गैर-शब्द चार।

हम इसके माध्यम से n उदाहरणों की तलाश करते हैं (\w\W?)**{$_}, जहां हमने पहले से ही n = $_params से n की गणना की $bहै $d। यह परिणाम के नोट के लिए अछूता नोट से एक मैच प्राप्त करता है, जिनमें से हम बस आखिरी चाहते हैं ताकि हम दूसरे के साथ मेल खाते हों ~~ /\w\W?$/।

ब्लॉक पर अंतर्निहित परम निर्माण की $_अनुमति देने के लिए पहले की गणना आवश्यक है $^b।

76 वर्ण

स्ट्रिंग मैचों के बजाय एक सरणी का उपयोग करने वाला एक विकल्प 3 अधिक वर्ण है:

{$_=<B♭ B C C♯ D E♭ E F F♯ G G♯ A>;.[((.first: $^a,:k)-2*$^b-$^c-3*$^d)%12]}

सूची में शामिल होने का पता लगाने के साथ प्राप्त किया जाता है @arr.first: $^a, :k, जो पाया गया तत्व के सूचकांक (कुंजी) को वापस करता है :k।

करने के लिए सरणी की स्थापना $_(एक वस्तु के रूप में) हमें उपयोग करने देता है .firstऔर .[ ]बहुत अधिक वर्ण खर्च किए बिना उस पर।

— फिल एच
स्रोत
0

सी (जीसीसी) , 155 बाइट्स

char r[][12]={"bb","b","c","c#","d","eb","e","f","f#","g","g#","a"};u;v(z,y,x,w)char*z;{for(;u<12;u++)if(!strcmp(z,r[u]))break;u=u-2*y-x-3*w;u=u<0?12+u:u;}

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

सरल दृष्टिकोण।

वाल्व इनपुट 0,1 है।

एंबोचर इनपुट लोअरकेस होना चाहिए। दिलचस्प रूप से, TiO को strcmpi()शामिल किए बिना नहीं मिल रहा है string.h, जबकि mingw-gcc इसे मानक -Wimplicit-function-declarationचेतावनी के साथ अनुमति देता है ।

— vazt
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.