20

अरे नहीं! मेरा जल्द ही एक सिद्धांत परीक्षण है और मुझे अभी तक तराजू याद नहीं है! निम्नलिखित प्रिंट करके मुझे अपने प्रमुख पैमानों को याद रखने में मदद करें:

7♯ - C♯ D♯ E♯ F♯ G♯ A♯ B♯ C♯
6♯ - F♯ G♯ A♯ B  C♯ D♯ E♯ F♯
5♯ - B  C♯ D♯ E  F♯ G♯ A♯ B
4♯ - E  F♯ G♯ A  B  C♯ D♯ E
3♯ - A  B  C♯ D  E  F♯ G♯ A
2♯ - D  E  F♯ G  A  B  C♯ D
1♯ - G  A  B  C  D  E  F♯ G
0  - C  D  E  F  G  A  B  C
1♭ - F  G  A  B♭ C  D  E  F
2♭ - B♭ C  D  E♭ F  G  A  B♭
3♭ - E♭ F  G  A♭ B♭ C  D  E♭
4♭ - A♭ B♭ C  D♭ E♭ F  G  A♭
5♭ - D♭ E♭ F  G♭ A♭ B♭ C  D♭
6♭ - G♭ A♭ B♭ C♭ D♭ E♭ F  G♭
7♭ - C♭ D♭ E♭ F♭ G♭ A♭ B♭ C♭

यह कोड-गोल्फ है, इसलिए सबसे छोटा कोड जीतता है। आप उपयोग कर सकते हैं #और bके बजाय प्रतीकों ♯और ♭क्रमशः।

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

code-golf kolmogorov-complexity music

— ericw31415
स्रोत

1

क्या आउटपुट में एक अग्रणी न्यूलाइन स्वीकार्य है?

— 20

4

मैं विश्वास नहीं कर सकता कि अभी तक कोई Fugue जवाब नहीं है!

— leo

आउटपुट स्वरूप कितना सख्त है? हम लाइनों की एक सरणी ouput कर सकते हैं? कैसे एक तत्व या एक ही चरित्र के साथ एक 2 डी सरणी के बारे में?

— झबरा

@ शैगी मुझे नहीं पता कि कोलमोगोरोव जटिलता के सवालों के लिए क्या मानक है, इसलिए मैं कहूंगा कि नहीं।

— ericw31415

3

♭: कोड तत्वों में मोनोस्पेस फॉन्ट के लिए बहुत कुछ

— चिले दस ब्रिंक

8

चारकोल , 66 65 बाइट्स (यदि # और b का उपयोग कर रहे हैं)

↑⮌…0¦8‖Ｏ⸿×⁷♭Ｍ→×⁷♯→⸿⸿¹⁵ＦＥ⁸﹪⊕⊗ι⁷«⸿⸿✂×³FCGDAEBι⁺¹⁵ι→⸿✂⭆♭ ♯×⁷κι⁺¹⁵ι»⟲

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

↑⮌…0¦8‖Ｏ

वर्णों 0को 7उल्टा प्रिंट करें , फिर ओवरलैप के साथ प्रतिबिंबित करें। आम तौर पर सूची नीचे की ओर प्रिंट होती है, इसलिए ऊपर की ओर छपाई वास्तव में दाईं ओर प्रिंट होती है; हम अंत में सब कुछ घुमाएँगे।

⸿×⁷♭Ｍ→×⁷♯

एक नई लाइन शुरू करें और बीच में एक अंतराल के साथ 7 फ्लैट और 7 शार्प प्रिंट करें।

→⸿⸿¹⁵

एक रिक्त रेखा छोड़ें और 15 -एस प्रिंट करें ।

ＦＥ⁸﹪⊕⊗ι⁷«

संख्या 0 से 7 तक ले जाएं, उन्हें दोगुना करें, 1 जोड़ें, फिर परिणाम को कम करें 7. परिणाम पर लूप करें।

⸿⸿✂×³FCGDAEBι⁺¹⁵ι

एक रिक्त रेखा छोड़ें और फिर मौजूदा मूल्य पर शुरू होने वाले नोटों के त्रिपृष्ठी स्ट्रिंग के 15-वर्ण का टुकड़ा लें।

→⸿✂⭆♭ ♯×⁷κι⁺¹⁵ι

अगली पंक्ति में फ्लैट्स, स्पेस और शार्प्स का 15-कैरेक्टर स्लाइस लें, प्रत्येक को 7 बार दोहराया जाए।

»⟲

सभी नोटों को प्रिंट करने के बाद, सब कुछ जगह में घुमाएं।

— नील
स्रोत

आप प्रत्येक के बजाए 3. ♯और ♭1 बाइट को गिन सकते हैं

— ericw31415

यह प्रतिभा है, मैं इस समाधान के साथ प्रतिस्पर्धा नहीं कर सकता।

— चार्ली

6

रूबी , 113 बाइट्स ( # और b के साथ 131 126 108 105)

-7.upto(7){|i|print i.abs," ♭♯"[i<=>0]," - ",(4..11).map{|j|("FCGDAEB"*3)[k=j*2%7-i]+"♭♯ "[~k/7]}*" ",$/}

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

रूबी , 116 बाइट्स (# और बी के साथ 108)

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

रूबी , 126 बाइट्स (118 # और बी के साथ)

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

रूबी , # और बी के साथ 131 बाइट्स

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

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

आपको यूनिकोड तेज और सपाट पात्रों को प्रिंट करने की आवश्यकता है क्योंकि रूबी उनका समर्थन करती है।

— जेकब

मुझे लगता है कि आपको 124-बाइट समाधान पर स्विच करना चाहिए। यहाँ मीट्रिक बाइट्स है, वर्ण नहीं!

— जेकब

आप प्रत्येक के बजाए 3. ♯और ♭1 बाइट को गिन सकते हैं

— ericw31415

6

पायथन 3 , 135 बाइट्स

प्रत्येक बाइट के रूप में counting और ♭ की गिनती

Zacharý के लिए धन्यवाद -6 बाइट्स।

for i in range(15):k=' ♯♭'[(i<7)-(i>7)]+' -';print(str(i-7)[-1]+k,*[v+k[a+8>i>a]for a,v in zip([1,3,5,0,2,4,6,1],('CDEFGAB'*8)[i*3:])])

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

— OVS
स्रोत

5

GNU sed , 148 144 + 1 = 145 बाइट्स

-rझंडे के लिए +1 बाइट ।

s/^/ 7# - C# D# E# F# G# A# B# \n65432101234567/
:
s/((.).(. - )((\S..){3})([^-]+)..\n)([0-7])/\1\2\7\3\6\2 \4\n/
s/ 0#/b0b/
t
s/^.//gm
s/0b/0 /

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

व्याख्या

सबसे पहले, एक प्रकार का टेम्पलेट डालें:

 7# - C# D# E# F# G# A# B# 
65432101234567

पहली पंक्ति पर अग्रणी और अनुगामी स्थान पर ध्यान दें।

एक लूप में, पहले नंबर को अंतिम पंक्ति से लें और इसे दूसरी से-अंतिम पंक्ति के हिस्सों से बदलें जैसे:

 7# - C# D# E# F# G# A# B# 
│ └┬─┘└───┬───┘└───┬────┘
2  3      4        6
│  │      └────────│──┐
├──│────────────┐  │  │
│  │      ┌─────│──┘  │
│ ┌┴─┐┌───┴────┐│ ┌───┴───┐
 6# - F# G# A# B  C# D# E#

जैसा कि आप देख सकते हैं, चरित्र को बदलने के लिए प्रारंभिक स्थान (कैप्चर 2) का उपयोग किया जाता है B।

जब 0पहुँच जाता है, तो प्रारंभिक स्थान को साथ बदलें b। लूप जारी रहता है, लेकिन #रिक्त स्थान के साथ एस को बदलने के बजाय , प्रत्येक बाद की पंक्ति में एक स्थान को एक के साथ बदल दिया जाता है b।

अंत में, थोड़ा सफाई करें: प्रत्येक पंक्ति से अग्रणी वर्ण निकालें और उसके 0bसाथ बदलें 0।

— जॉर्डन
स्रोत

4

Befunge, 134 132 130 बाइट्स

<v:,,," - ",g2+!!\`0::,+*86*-1*2`0::p00:<75
@>4*65*+81v>55+,$$\:00g0`!\9p3+7%\1-:8+#^_
 b#"A"%7:\_^#:-1,*84,g2*+1`0g00!!g9%7:\+1,+

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

व्याख्या

हम एक बाहरी लूप की शुरुआत 7 से -7 तक की गिनती के साथ करते हैं। हम इसे पंक्ति संख्या कहेंगे ।
प्रत्येक पंक्ति के लिए, हम बाहर '0'+abs(row)(स्केल संख्या) लिखकर शुरू करते हैं , और फिर (row>0)+(row!=0)यह देखने के लिए गणना करते हैं कि क्या यह तालिका में प्राकृतिक, तेज या सपाट है #b(आप इसे कोड की तीसरी पंक्ति की शुरुआत में देखेंगे)।
फिर हम स्केल के स्टार्ट नोट, n , as की गणना करते हैं 30 + row*4। यह अंततः मॉड 7 होगा, इसलिए इसे दोहराए जाने वाले अनुक्रम 2,5,1,4,0,3,6,6 (यानी CFBEADG) के रूप में सोचें।
हमारे आंतरिक लूप, मैं , फिर 8 से 1 तक गिना जाता है, पैमाने में आठ नोटों के लिए, प्रत्येक पुनरावृत्ति पर एन बढ़ाना ।
नोट का पत्र बस है 'A' + n%7। चाहे वह तेज हो या सपाट i%7, एक तालिका में देखकर निर्धारित किया जाता है । तालिका प्रारंभ में सभी सत्य है, क्योंकि पहला पैमाना सभी शार्प है।
प्रत्येक पंक्ति के आउटपुट के बाद, हालांकि, हम एक मान को टॉगल करके तालिका को अपडेट करते हैं। पहले पुनरावृत्ति पर हम ऑफसेट 5 पर मान टॉगल करेंगे, लेकिन प्रत्येक लूप ऑफसेट द्वारा समायोजित किया जाता है (offset+3)%7।
आउटपुट के पहले भाग पर, जब पंक्ति शून्य से अधिक होती है, हम इन तालिका मानों को असत्य मान रहे हैं। आउटपुट के दूसरे भाग पर, जब पंक्ति शून्य से कम या बराबर होती है, तो हम उन्हें सही पर सेट कर रहे हैं।

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

1

केवल आप वास्तव में Befunge में गोल्फ कर सकते हैं।

— 21

3

बबलगम , 107 बाइट्स

बबलगम दहलीज

00000000: 4dca a90d 0301 1443 41ee 2a9e f4b1 a5ec  M......CA.*.....
00000010: 8d73 f7e1 fe8b 48a0 e968 aec1 3c87 d7f0  .s....H..h..<...
00000020: 1e3e c377 b80f 8ff9 a3ce c165 74d4 31b8  .>.w.......et.1.
00000030: 8c8a da07 1751 4fdb e022 ea69 1d5c 443d  .....QO..".i.\D=
00000040: 2d83 8ba8 a71b b888 7a5a 828b 524f 6b70  -.......zZ..ROkp
00000050: 51fa 690b 2e4b 47ed c165 e9a8 23b8 2c1d  Q.i..KG..e..#.,.
00000060: 7506 97a5 a3ae e0b2 74d4 0f              u.......t..

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

— OVS
स्रोत

3

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

या एक अग्रणी न्यूलाइन के साथ ~~128~~ 121 बाइट्स ।

f=(y=14,x=8)=>x?f(y,x-1)+' '+'BCDEFGA'[(y*3+x)%7]+'# b'[(x*5%7+y)/7|0]:(y?f(y-1)+`
`:'')+`${y<7?7-y+'#':y>7?y-7+'b':'0 '} -`

O.innerText = f()

<pre id=O style="font-size:11px"></pre>

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

— Arnauld
स्रोत

3

सी, 212 189 186 185 बाइट्स

एक बाइट को बचाने के लिए @ जोनाथन फ्रेच को धन्यवाद!

#define N n>0?35:98:32);
f(i,n){for(n=8;--n+8;puts(""))for(i=-1,printf("%d%c -",abs(n),n?N++i<8;)printf(" %c%c",(n*4+65+i)%7+65,"\377\277\273\233\231\211\10\0@Ddfv\367\377"[n+7]&1<<i?N}

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

unrolled:

#define N n>0 ? 35 : 98 : 32);
f(i, n)
{
    for (n=8; --n+8; puts(""))
        for (i=-1, printf("%d%c -", abs(n), n?N ++i<8;)
            printf(" %c%c",
                (n*4+65+i)%7 + 65,
                "\377\277\273\233\231\211\10\0@Ddfv\367\377"[n+7] & 1<<i ? N
}

— Steadybox
स्रोत

>-हो सकता है +।

— जोनाथन फ्रीच

@JonathanFrech धन्यवाद!

— 21

के i=~!printfबजाय i=-1,printfऔर के \bबजाय \10

— सुझाव

2

जेली , 57 56 55 54 बाइट्स

-1 बाइट के लिए धन्यवाद EriktheOutgolfer ( 7ŒRप्रतिस्थापित करने के लिए उपयोग -7r7)

_Ṃị“ b#”
=”B+\Çż
×3⁵+€ịØAḣ7¤ḊḊÇ€Z
7ŒRµṠÑżAW€żÇj€”-UK€Y

एक पूर्ण कार्यक्रम मुद्रण वांछित निर्गम (का उपयोग करते हुए #, b)।

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

कैसे?

_Ṃị“ b#” - Link 1, getSharpsFlatsOrSpaces: list of integers
 Ṃ       - minimum (of the input list)
_        - subtract (from the input list) -- for our purposes this resets whatever our
         -       1st value is to 0, since our inputs are always monotonically increasing
   “ b#” - literal list of characters = [' ', 'b', '#']
  ị      - index into (1-based and modular)

=”B+\Çż - Link 2, addSharpsFlatsOrSpaces: list of characters  e.g."CFBEADGCFBEADGC"
 ”B     - literal character 'B'
=       - equals? (vectorises)                      [0,0,1,0,0,0,0,0,0,1,0,0,0,0,0]
    \   - cumulative reduce with:
   +    -   addition                                [0,0,1,1,1,1,1,1,1,2,2,2,2,2,2]
     Ç  - call the last link (1) as a monad                       "##       bbbbbb"
      ż - zip (with input) ["#C","#F"," B"," E",...," F","bB","bE","bA","bD","bG","bC"]

×3⁵+€ịØAḣ7¤ḊḊÇ€Z - link 3, getNoteLetters: list of integers          e.g. [-7,-6,...,6,7]
×3               - multiply by three       [-21,-18,-15,-12,-9,-6,-3,0,3,6,9,12,15,18,21]
  ⁵              - literal ten                                                         10
   +€            - add for €ach (in [1,10])   [[-20,...,22],[-19,...,23],...,[-11,...31]]
          ¤      - nilad followed by link(s) as a nilad:
      ØA         -   yield uppercase alphabet                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        ḣ7       -   head to index seven                                        "ABCDEFG"
     ị           - index into ["ADGCFBEADGCFBEA","BEADGCFBEADGCFB","CFBEADGCFBEADGC",...]
           Ḋ     - dequeue    ["BEADGCFBEADGCFB","CFBEADGCFBEADGC","DGCFBEADGCFBEAD",...]
            Ḋ    - dequeue    ["CFBEADGCFBEADGC","DGCFBEADGCFBEAD","EADGCFBEADGCFBE",...]
             Ç€  - call the last link(2) as a monad for €ach
                 -    [[["#C","#F"," B"," E",...," F","bB","bE","bA","bD","bG","bC"],...]
               Z - transpose           [["#C","#D",...,"#C"],["#F",..." B",...,"#F"],...]

7ŒRµṠÑżAW€żÇj€”-UK€Y - Main link: no arguments
7ŒR                  - absolute range of seven     [-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7]
   µ                 - start a new monadic chain (call that r)
    Ṡ                - sign (of r)                 [-1,-1,-1,-1,-1,-1,-1,0,1,1,1,1,1,1,1]
     Ñ               - call the next link (1) as a monad                "####### bbbbbbb"
       A             - absolute value (of r)              [7,6,5,4,3,2,1,0,1,2,3,4,5,6,7]
      ż              - zip                      [[7,'#'],[6,'#'],...,[0,' '],...,[7,'b']]
        W€           - wrap €ach        [[[7,'#']],[[6,'#']],...,[[0,' ']],...,[[7,'b']]]
           Ç         - call the last link (3) as a monad (with r)      see link 3 example
          ż          - zip                     [[[['#',7]],["#C","#D",...,"#C"]],
                                                [[['#',6]],["#F",...," B",..."#F"]], ...]
              ”-     - literal character '-'
            j€       - join for €ach            [[['#',7],'-',"#C","#D",..."#C"],
                                                 [['#',6],'-',"#F",...," B",..."#F"],...]
                U    - upend (reverse each)     [[[7,'#'],'-',"C#","D#",..."C#"],
                                                 [[6,'#'],'-',"F#",...,"B ",..."F#"],...]
                 K€  - join €ach with spaces            [[7+"# - C# D# ... C#"],
                                                         [6+"# - F# ... B  ... F#"], ...]
                   Y - join with newlines
                     - implicit print to STDOUT

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

1

मुझे इस पर जेली पर भरोसा था।

— एर्गेल आउटफर

0

CJam , 109 106 94 बाइट्स

{_0={_z/}|" b#"=a}:A;15,{X7-_zs\A+" - "+o7,0+{YX+7%65+c"2461357"Y=aiX\-_7,#){;0}&AS++o}fYNo}fX

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

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

0

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

प्रत्येक बाइट के रूप में। और ♭ की गिनती।

v->{String r="",t="GABCDEF";for(int i=-8;++i<8;r+="\n"){r+=(i<0?-i+"♯":i>0?i+"♭":"0 ")+" - ";for(String c:((t=t.substring(3)+t.substring(0,3))+t.charAt(0)).split(""))r+=c+("BEADGCF".substring(i<0?7+i:i).contains(c)?i<0?"♯":" ":i>0?"♭":" ")+" ";}return r;}

स्पष्टीकरण:

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

v->{                   // Method with empty unused parameter and String return-type
  String r="",         //  Result-String, starting empty
         t="GABCDEF";  //  Temp-String `t`, starting at "GABCDEF"
  for(int i=-8;++i<8;  //  Loop from -7 to 7 (inclusive); range (-8;8) == [-7;7]
      r+="\n"){        //    After every iteration: append the result with a new-line
    r+=                //   Append the result-String with:
       (i<0?           //    If `i` is negative:
         -i+"♯"        //     Append the absolute value of `i` + a literal "♯"
        :i>0?          //    Else-if `i` is positive:
         i+"♭"         //     Append `i` + a literal "♭"
        :              //    Else (`i` is 0):
         "0 ")         //     Append a literal "0" + space
     +" - ";           //   And then append a literal " - "
  for(String c:((t=t.substring(3)+t.substring(0,3))
                       //  Split String `t` in the middle,
                       //  and swap the two parts (i.e. "GABCDEF" becomes "CDEFGAB")
                +t.charAt(0))
                       //  Then append the first character
                .split(""))
                       //  And loop over each character:
     r+=c+             //   Append the result-String with this character, plus:
          ("BEADGCF".substring(i<0?
                       //    If `i` is negative
            7+i        //     Take the last `-i` characters of "BEAFGCF"
           :           //    Else (`i` is 0 or positive)
            i)         //     Take the last `7-i` characters of "BEAFGCF"
          .contains(c)?//    And if these last characters contain the current character:
            i<0?       //     And `i` is negative:
             "♯"       //      Append a literal "♯"
            :          //     Else (`i` is 0 or positive)
             " "       //      Append a space
          :i>0?        //    Else-if `i` is positive
            "♭"        //     Append a literal "♭"
          :            //    Else:
           " ")        //     Append a space
      +" ";}           //   And then append a space
  return r;}           //  Return the result-String

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

मुझे एक पैमाना छापें

चारकोल , 66 65 बाइट्स (यदि # और b का उपयोग कर रहे हैं)

रूबी , 113 बाइट्स ( # और b के साथ 131 126 108 105)

रूबी , 116 बाइट्स (# और बी के साथ 108)

रूबी , 126 बाइट्स (118 # और बी के साथ)

रूबी , # और बी के साथ 131 बाइट्स

पायथन 3 , 135 बाइट्स

GNU sed , 148 144 + 1 = 145 बाइट्स

व्याख्या

Befunge, 134 132 130 बाइट्स

बबलगम , 107 बाइट्स

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

सी, 212 189 186 185 बाइट्स

जेली , 57 56 55 54 बाइट्स

कैसे?

CJam , 109 106 94 बाइट्स

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