18

एक गिटार fretboard आरेख इस तरह दिखता है:

  0  1  2  3  4  5  6  7  8  9 10 11 12   <- Fret number (0 means it's open)
|-E--F--F#-G--G#-A--A#-B--C--C#-D--D#-E
|-B--C--C#-D--D#-E--F--F#-G--G#-A--A#-B 
|-G--G#-A--A#-B--C--C#-D--D#-E--F--F#-G
|-D--D#-E--F--F#-G--G#-A--A#-B--C--C#-D
|-A--A#-B--C--C#-D--D#-E--F--F#-G--G#-A
|-E--F--F#-G--G#-A--A#-B--C--C#-D--D#-E

जैसा कि आप देख सकते हैं, पहला तार (ऊपर से) खुला एक है E। पहली स्ट्रिंग पर पहला झल्लाहट ए है F। तीसरी स्ट्रिंग पर चौथा झल्लाहट है B। ध्यान दें कि पहला नोट ज़ेरोथ झल्लाहट है, पहला नहीं।

यह प्रारूप पर संख्याओं के साथ लिखा जा सकता है string, fret। तार 1 से 6 तक ऊपर से नीचे तक गिने जाते हैं। मालियों को 0 से 12 तक बाएं से दाएं तक गिना जाता है। पहला Eइसलिए है 1, 0। कुछ अन्य उदाहरण:

1, 0 --> E
1, 1 --> F
3, 5 --> C
5, 1 --> A# 
6, 6 --> A#

चुनौती:

Nसंख्याओं ( sऔर f) के जोड़े लें , और एक सीमांकित नोट उत्तराधिकार का उत्पादन करें।

इनपुट किसी भी उपयुक्त प्रारूप पर हो सकता है। ट्यूपल्स, 2 डी-मैट्रिक्स, दो अलग-अलग सूचियां, एक इंटरव्यू की गई सूची (स्ट्रिंग, झल्लाहट, स्ट्रिंग, झल्लाहट ...) आदि।
आउटपुट टोन को अलग किया जाना चाहिए, लेकिन सीमांकक वैकल्पिक है (अल्पविराम, अंतरिक्ष, डैश ...)। आउटपुट ऊपरी या निचले मामले में हो सकता है।
s(स्ट्रिंग के लिए) सीमा में होगा [1, 6](आप मुझे 0-अनुक्रमित करने के लिए चुन सकते हैं)
f (झल्लाहट के लिए) रेंज में होगा [0, 12]

परीक्षण के मामले और उदाहरण:

1 4 5 2 1 3   <- String
4 2 6 3 5 1   <- Fret
G# E D# D A G#

6 2 3 1 4 2 3 2 2 2 6 5 2
0 1 2 3 4 5 6 7 8 9 10 11 12
E C A G F# E C# F# G G# D G# B  

3 3 3 3 3 3 3 3 3 3 3 3 3   <- String
0 3 5 0 3 6 5 0 3 5 3 0 0   <- Fret
G A# C G A# C# C G A# C A# G G     

// The same test case, but different input and output format:
(3,0)(3,3)(3,5)(3,3)(3,6)(3,5)(3,0)(3,3)(3,5)(3,3)(3,0)(3,0)    
G,A#,C,G,A#,C#,C,G,A#,C,A#,G,G

गुड लक, और खुश गोल्फ!

code-golf parsing music

— स्टीवी ग्रिफिन
स्रोत

गिटारवादक नहीं (और न ही एक सभ्य संगीतकार, वास्तव में), लेकिन यहाँ एक महत्वपूर्ण चूक नहीं है, यदि आप आउटपुट को पहचानने योग्य धुन के रूप में उम्मीद कर रहे हैं? वह है, नोट की अवधि - पूरे, आधे, चौथाई नोट, और सी।

— jamesqf

1

@jamesqf नहीं, जब तक आप गीत जानते हैं यह पूरी तरह से ठीक है। यह वर्तमान में अल्टीमेट- guitar.com पर सबसे लोकप्रिय गीत है । इंट्रो पर एक नजर।

— स्टीवी ग्रिफिन

4

05AB1E , 48 47 43 40 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

स्ट्रिंग्स और फ़्रीट्स दोनों 0-आधारित हैं।

v7YT5¾7)y`Šè+•™ÎÚ,Ülu•žh'#A«‡•7V3•3BS£è,

व्याख्या

v                                # for each pair in input
 7YT5¾7)                         # the list [7,2,10,5,0,7]
 y`                              # flatten the pair [string, fret] and places on stack
 Šè                              # index into the list above using the string
 +                               # add the fret
 •™ÎÚ,Ülu•žh'#A«‡•7V3•3BS£       # list of accords
 è                               # index into the string using the number calculated above
 ,                               # print

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

अदनान की बदौलत 7 बाइट्स बचीं

— Emigna
स्रोत

1

बग का शोषण करना बहुत अधिक गोल्फ है! .-)

— लुइस मेन्डो

"AA#BCC#DD#EFF#GG#"•7V3•3BS£इसके बजाय "A A# B C C# D D# E F F# G G#"#कुछ बाइट्स कम हैं :)।

— अदनान

@ अदनान: ऊह, अच्छा आधार-परिवर्तन :)

— एमिग्ना

"AA#BCC#DD#EFF#GG#"स्ट्रिंग का एक संपीड़ित संस्करण भी : •™ÎÚ,Ülu•žh'#A«‡(चूंकि लोअरकेस की अनुमति है: p)।

— अदनान

9

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

a=>a.map(([s,f])=>"AA#BCC#DD#EFF#GG#".match(/.#?/g)[(s*7+(s>2)+f)%12])

1-आधारित स्ट्रिंग्स की आवश्यकता है। संपादित करें: @ nimi के पुराने उत्तर के आधार पर सीधे रूपांतरण के लिए स्ट्रिंग की गणना करके 9 बाइट्स सहेजे गए।

— नील
स्रोत

@Arnauld धन्यवाद, लेकिन मैंने इसके स्थान पर @ नीमी के उत्तर को विनियोजित किया।

— नील

वास्तव में बहुत अधिक कुशल;)

— अर्नुलड

चतुर। बहुत ही डरपोक जवाब

— रोहन झुनझुनवाला

7

गणितज्ञ, 62 बाइट्स (गैर-प्रतिस्पर्धात्मक)

<<Music`;MusicScale[100(#2+{24,19,15,10,5,0}[[#]])&@@@#,E2,9]&

{24,19,15,10,5,0}और E2छह गिटार तार के खुले स्ट्रिंग टन प्रतिनिधित्व करते हैं (उदाहरण के लिए, शीर्ष स्ट्रिंग टिप्पणी E2 ऊपर 24 semitones है)। गैर-प्रतिस्पर्धा क्योंकि यह नोटों के नाम नहीं छापता है - यह नोट्स के अनुक्रम को निभाता है! (केवल अगर आपके पास गणितज्ञ है, दुर्भाग्य से) उदाहरण के लिए,

<<Music`;MusicScale[100(#2+{24,19,15,10,5,0}[[#]])&@@@#,E2,9]&@
 {{4,0},{3,2},{2,3},{1,2},{5,0},{4,2},{3,2},{2,2},
  {5,2},{4,4},{2,0},{2,3},{6,2},{4,4},{3,2},{2,2},
  {6,3},{4,0},{3,0},{2,0},{4,0},{4,4},{3,2},{2,3},
  {6,3},{3,0},{2,0},{2,3},{5,0},{4,2},{3,2},{2,2},{4,0}}

पचेलबेल के कैनन से खुलने वाले 4 बार या इतने पर। (जो पचेलबेल के कैनन के बारे में है जितना मैं खड़ा हो सकता हूं)

— ग्रेग मार्टिन
स्रोत

7

MATL , 48 47 45 बाइट्स

इनपुट प्रारूप के संबंध में सुधार के लिए @Emigna का धन्यवाद।

गिटार और कोड गोल्फ ... मुझे इसका उत्तर देना था!

'$)-27<'i)-'F F# G G# A A# B C C# D D#

इनपुट प्रारूप है: (1-आधारित) स्ट्रिंग की एक सरणी, फिर (0-आधारित) की एक सरणी फ़्रीट्स।

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

व्याख्या

इस उत्तर में प्रयुक्त कुछ भाषा सुविधाएँ:

जब कुछ अंकगणितीय ऑपरेशन उस पर लागू होते हैं तो एक स्ट्रिंग स्वचालित रूप से ASCII कोड बिंदुओं के एक संख्यात्मक सरणी में बदल जाती है।
अंकगणितीय ऑपरेशन तत्व-वार अर्थात वेक्टरकृत होते हैं। तो एक स्ट्रिंग का घटाव और उसी आकार का एक संख्यात्मक सरणी संबंधित प्रविष्टियों के घटाव के साथ एक सरणी देता है।
इंडेक्सिंग 1-आधारित और मॉड्यूलर है ।
एक सेल ऐरे अन्य भाषाओं की सूची की तरह है। इसमें मनमाने तत्व हो सकते हैं, संभवतः विभिन्न प्रकार या आकारों के सरणियाँ। यहां एक सेल ऐरे का उपयोग विभिन्न लंबाई (नोटों के नाम) के तार को स्टोर करने के लिए किया जाएगा।

टिप्पणी कोड:

'$)-27<'                       % Push this string
i                              % Take first input (array of guitar strings)
)                              % Index into the string. For example, input [1 3] gives
                               % the string '$-' (indexing is 1-based)
-                              % Implicitly take second input (array of guitar frets).
                               % Subtract element-wise. This automatically converts the
                               % previous string into an array of ASCII codes. For
                               % example, second input [1 5] gives a result [-35 -40],
                               % which is [1 5] minus [36 45], where 36 and 45 are the
                               % ASCII codes of '$-' 
'F F# G G# A A# B C C# D D# E' % Push this string
Yb                             % Split at spaces. Gives a cell array of 12 (sub)strings:
                               % {'F', 'F#', 'G', ..., 'E'}
w)                             % Swap and index into the cell array of strings.
                               % Indexing is 1-based and modular. In the example, since
                               % the cell array has 12 elements, the indexing array
                               % [-35 -40] is the same [1 8], and thus it gives a 
                               % (sub-)array formed by the first and eighth cells: 
                               % {'F', 'C'}. This is displayed as the cells' contents,
                               % one per line

— लुइस मेंडो
स्रोत

1

मुझे पता था कि जैसे ही मैंने "गिटार" शब्द देखा, मैं आपसे एक जवाब खोजने जा रहा था

— स्वेकर

1

@LuisMendo बहुत अच्छा! मुझे

— एसिसी

4

जावा, 174

String f(int[]s,int[]f){String o="";for(int i=0;i<s.length;++i){int n =(7*s[i]-7+f[i]+(s[i]>2?1:0))%12*2;o+="E F F#G G#A A#B C C#D D#".substring(n,n+2).trim()+" ";}return o;}

Ungolfed:

  String f(int[] s, int[] f) {
    String o = "";
    for (int i = 0; i < s.length; ++i) {
      int n = (7 * s[i] - 7 + f[i] + (s[i] > 2 ? 1 : 0)) % 12 * 2;
      o += "E F F#G G#A A#B C C#D D#".substring(n, n + 2).trim() + " ";
    }
    return o;
  }

3

सी, 104 103 बाइट्स

main(s,f){for(;~scanf("%d%d",&s,&f);printf("%.2s\n",
"E F F#G G#A A#B C C#D D#"+(f+7*~-s+(s>2))%12*2));}

string fretस्टड पर जोड़े के रूप में संख्या लेता है , और हर जोड़ी के बाद नोट आउटपुट करता है। उदाहरण के लिए:

1 4
G#
4 2
E 
5 6
D#
2 3
D

— orlp
स्रोत

3

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

क्रम में 2-तत्व सरणियों की एक सरणी लेता है [string,fret]।

->x{x.map{|i|"BEADGCF"[6-n=((i[0]-3)%5+2+i[1]*7)%12]+?#*(n/7)}}

व्याख्या

मानक ट्यूनिंग में गिटार कुछ कड़े उपकरणों (झुके या झुके हुए) में से एक होता है जिसमें कई तार के बीच असंगत अंतराल होता है। अधिकांश या तो आसन्न स्ट्रिंग्स ("चौथे") के सभी जोड़े के बीच एक सुसंगत 5-सेमिटोन अंतराल है या समीपवर्ती स्ट्रिंग्स के सभी जोड़े (एक "पांचवें") के बीच एक सुसंगत 7-सेमीटोन अंतराल है: ये 3 के आवृत्ति अनुपात के अनुरूप हैं: 4। और क्रमशः 2: 3, और आवृत्ति अनुपात 1: 2 के साथ "ऑक्टेव" के लिए महत्वपूर्ण दूसरे स्थान पर हैं।

गिटार में ज्यादातर 5-सेमिटोन अंतराल हैं। यदि इनमें से 5 में यह 1 और 6 वें स्ट्रिंग के बीच 25 सेमीटोन का अंतर होता। इसके बजाय, 2 और 3 वें स्ट्रिंग के बीच का अंतराल 4 सेमीटोन तक कम हो जाता है, जिससे 24 सेमीटाइन्स (2 ऑक्टेव्स) का अंतर होता है जो कि कॉर्ड्स खेलने के लिए बेहतर है।

यह कार्यक्रम के लिए असुविधाजनक है, इसलिए हम 1-अनुक्रमित गिटार इंटोनेशन को 0 अनुक्रमित 5-स्ट्रिंग-बास इंटोनेशन में बदलकर शुरू करते हैं, जिसमें 5 सेमीटाउन के सभी अंतराल हैं:

formula (i[0]-3)%5
Before                            After
String      6 5 4 3 2 1           String 4 3 2 1 0
Note        E A D G B E           Note   B E A D G

अगला हम 2 जोड़ते हैं, और एक काल्पनिक 12 स्ट्रिंग बास की ट्यूनिंग देते हैं, इस प्रकार के खुले स्ट्रिंग्स के एकीकरण के साथ, और सभी अंतराल 5 सेमीिटोन्स (12 स्ट्रिंग "बेस") मौजूद हैं, लेकिन मुझे यकीन नहीं है कि ठीक इसके साथ कई हैं ट्यूनिंग।)

String       11 10 9  8  7  6  5  4  3  2  1  0 
Note         A# D# G# C# F# B  E  A  D  G  C  F

जैसा कि देखा जा सकता है, सभी शार्प एक साथ समूहीकृत हैं। इस पैटर्न को दोहराया जा सकता है। इसे "पंद्रहवें चक्र" के रूप में जाना जाता है और यह पश्चिमी संगीत के पैमाने के लिए मौलिक है (थोड़ी ट्यूनिंग समायोजन के साथ सर्कल को इस तथ्य के कारण बंद किया जा सकता है (3/2)**12और 2**7बहुत समान संख्या में हैं।

अब हम झल्लाहट पैरामीटर से निपटते हैं। यहां कई अन्य उत्तरों के विपरीत, जो स्ट्रिंग पैरामीटर को कई फ्रीट्स में अनुवाद करते हैं, मैं एफआरटी पैरामीटर को कई स्ट्रिंग्स में अनुवाद करता हूं। ऊपर दी गई तालिका में यह देखा जा सकता है कि स्ट्रिंग संख्या में 7 जोड़ने से हमें एक स्ट्रिंग पर रखा जाता है जिसका नोट नाम एक सेमीटोन अधिक है। (यह पूरी तरह से अलग सप्तक में है, लेकिन इससे कोई फर्क नहीं पड़ता।) इसलिए हम i[1]*7स्ट्रिंग संख्या में जोड़ते हैं , और इसे 12 ले लेते हैं:

n=(i[0]-3)%5+2+i[1]*7)%12

हम इसे 6 से घटाकर 6 से -5 की सीमा में संख्या प्राप्त करते हैं और अक्षर को देखते हैं BEADGCF(रूबी नकारात्मक सूचक को सरणी के अंत में चारों ओर लपेटने की अनुमति देता है।) यदि n>=7हमें एक जोड़ने की आवश्यकता है।# आउटपुट पूरा प्रतीक ।

परीक्षण कार्यक्रम

f=->x{x.map{|i|"BEADGCF"[6-n=((i[0]-3)%5+2+i[1]*7)%12]+?#*(n/7)}}

z=[[6, 2, 3, 1, 4, 2, 3, 2, 2, 2, 6,5,2],[0, 1, 2, 3, 4 ,5 ,6 ,7, 8, 9, 10, 11, 12]].transpose

puts f[z]

उत्पादन

E
C
A
G
F#
E
C#
F#
G
G#
D
G#
B

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

3

सी #, 131 बाइट्स

string n(int[]s,int[]f){return string.Join(" ",s.Zip(f,(x,y)=>"E,F,F#,G,G#,A,A#,B,C,C#,D,D#".Split(',')[(7*x-7+y+(x<3?0:1))%12]));}

इनपुट दो अलग-अलग सूची, तार 1 आधारित हैं।

— टैको
स्रोत

1

साइट पर आपका स्वागत है! अच्छा पहला जवाब।

— DJMcMayhem

@DJMcMayhem: धन्यवाद :-)

— ताको

1

क्लोरा , 55 बाइट्स

@T[0,7,2,10,5,0,7]+N%12@T[,A,A#,B,C#,D,D#,E,F,F#,G,G#]!

व्याख्या

@ संख्यात्मक मोड (संख्या के रूप में इनपुट पढ़ें)

T[0,7,2,10,5,0,7] सरणी, पूर्व सरणी [इनपुट] का उपयोग करके ट्रांसफ़ॉर्म इनपुट

+N वर्तमान इनपुट में N (अगला इनपुट मान) जोड़ें

%12 मोडुलो 12 वर्तमान इनपुट मूल्य

@ सांख्यिक मोड बंद करें

T[,A,A#,B,C#,D,D#,E,F,F#,G,G#] इनपुट को ऐरे में अनुवाद करें

! आउटपुट मान के रूप में इनपुट का उपयोग करें

— OPSXCQ
स्रोत

1

जावा 7 197, 163 बाइट्स

void f(int[]s,int[]f){String[]l={"A","A#","B","C","C#","D","D#","E","F","F#","G","G#"};int[]d={0,7,2,10,5,0,7};int j=0;for(int i:s)out.print(l[(d[i]+f[j++])%12]);}

Ungolfed

  void f(int[]s,int[]f){
 String[]l={"A","A#","B","C","C#","D","D#","E","F","F#","G","G#"};
int[]d={0,7,2,10,5,0,7};
    int j=0;
    for(int i:s)
        out.print(l[(d[i]+f[j++])%12]);



}

— Numberknot
स्रोत

0

पायथन 2, 94, 91 , 88 बाइट्स

for s,f in input():print"A A# B C C# D D# E F F# G G#".split()[([7,2,10,5,0,7][s]+f)%12]

संभवत: कुछ स्पष्ट सुधार किए जाने हैं। इनपुट जोड़े की एक सूची है, और तार 0-अनुक्रमित हैं, जैसे:

[0, 4], [3, 2], [4, 6]...

— DJMcMayhem
स्रोत

0

हास्केल, 83 82 बाइट्स

zipWith$(!!).(`drop`cycle(words"A# B C C# D D# E F F# G G# A")).([6,1,9,4,11,6]!!)

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

Prelude >  ( zipWith$(!!).(`drop`cycle$words"A# B C C# D D# E F F# G G# A").([6,1,9,4,11,6]!!) ) [0,1,2,3,4,5] [0,0,0,0,0,0]
["E","B","G","D","A","E"]

से शुरू होने वाले नोटों की अनंत सूची से A#, सूची द्वारा दिए गए नोटों की संख्या [6,1,9,4,11,6]को स्ट्रिंग के सूचकांक में छोड़ दें और शेष सूची से नोटों को अनुक्रमणिका पर ले जाएं।

— nimi
स्रोत

दुर्भाग्य से तार के बीच के अंतराल सभी समान नहीं हैं।

— नील

@ नील: ... तय किया।

— nimi

यह जावास्क्रिप्ट में एक साधारण तय निकला - (s*7)+(s>2)- तो मैं अब अपने उत्तर में इसका उपयोग कर रहा हूं।

— नील

@ नील: ... उस पर भी काम कर रहे हैं।

— नौ

0

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

a=>a.map(b=>(q=(b[0]+.3+b[1]*7.3|0)%12/1.7+10.3).toString(17)[0]+(q%1>.5?"#":""))

मैं एक ऑल-मैथ उत्तर का प्रयास करना चाहता था, लेकिन यह थोड़ा लंबा हो गया। शायद यह गोल्फ के लिए एक रास्ता है ...

टेस्ट स्निपेट

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

f=a=>a.map(b=>(q=(b[0]+.3+b[1]*7.3|0)%12/1.7+10.3).toString(17)[0]+(q%1>.5?"#":""))
console.log(f([[4,1],[2,4],[6,5],[3,2],[5,1],[1,3]]))

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

— ETHproductions
स्रोत

मैं उपयोग करना चाहता था toString(17)लेकिन एक उचित बाइट की गिनती में इसे पाने के लिए संघर्ष किया।

— नील

0

PHP, 102 बाइट्स

<?foreach($_GET[i]as$t)echo[E,F,"F#",G,"G#",A,"A#",B,C,"C#",D,"D#"][[0,7,3,10,5][$t[0]%5]+$t[1]%12]._;

उदाहरण के तौर पर दोनों 0 के आधार पर कई सरणी के रूप में '[[2,0], [5,3], [2,12], [3,8], [0,3]]'

अच्छा विकल्प 106 बाइट्स सेट करने के लिए # 7 मॉड अनुरूप पर आधारित है

<?foreach($_GET[i]as$t)echo EFFGGAABCCDD[$d=[0,7,3,10,5][$t[0]%5]+$t[1]%12].["","#"][$d%7?$d%7%2?0:1:0]._;

— जार्ग हुल्सरमन
स्रोत

गिटार नोटों में नंबर जोड़े का अनुवाद करें

05AB1E , 48 47 43 40 बाइट्स

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

गणितज्ञ, 62 बाइट्स (गैर-प्रतिस्पर्धात्मक)

MATL , 48 47 45 बाइट्स

व्याख्या

जावा, 174

सी, 104 103 बाइट्स

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

सी #, 131 बाइट्स

क्लोरा , 55 बाइट्स

जावा 7 197, 163 बाइट्स

Ungolfed

पायथन 2, 94, 91 , 88 बाइट्स

हास्केल, 83 82 बाइट्स

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

टेस्ट स्निपेट

PHP, 102 बाइट्स