नियति का नोट - एक स्टाफ पर एक नोट रखें

19

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

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

-----

-----
   |
---|-
   |
--O--

-----

विशिष्टता:

  • आपको -----(5 डैश) और एक खाली लाइन की वैकल्पिक लाइनों के कर्मचारियों को आउटपुट करना होगा । -----कुल 5 s होंगे । इस स्टाफ़ के शीर्ष पर नोट को लगाया जाना चाहिए।
  • इनपुट निर्दिष्ट करेगा कि नोट कहाँ स्थित है। इनपुट होगा:
    • एक वैकल्पिक Hया L, "उच्च" या "कम" निर्दिष्ट करना
    • पिच को निर्दिष्ट करने के Aलिए एक पत्रG
    • एक वैकल्पिक #या b, तेज या सपाट निर्दिष्ट।
  • "नोट" को इस रूप में परिभाषित किया गया है:
    • वन O(कैपिटल ओ) स्टाफ के मध्य में संरेखित किया गया है, जो नोट के स्थान पर है। (शीर्ष पंक्ति है HF(उच्च एफ), और निचला रेखा E(एक सामान्य ई) है।)
    • तीन |एस (ऊर्ध्वाधर बार), स्टेम, जो होगा:
      • नोट के बाईं ओर एक स्थान और नीचे की ओर जाना (नोट के नीचे एक स्थान शुरू करना) यदि नोट मध्य रेखा ( B) या ऊपर या, पर है
      • नोट के दाईं ओर एक स्थान और ऊपर की ओर (नोट के ऊपर एक स्थान शुरू) यदि नोट मध्य रेखा के नीचे है।
    • यदि इनपुट में निर्दिष्ट है तो नोट के बाईं ओर एक #या bएक स्थान।
  • यदि नोट बहुत अधिक या कम है, तो लेजर लाइनें जोड़ी जानी चाहिए। ये रेखाएँ ---(5 की तुलना में चौड़ाई में केवल 3 डैश) होंगी, और केवल तभी दिखाई देंगी जब नोट नीचे या ऊपर / नीचे (क्रमशः शीर्ष / नीचे की ओर लेज़र लाइनों के लिए) होता है।
  • बाहरी स्थान आप चाहते हैं कहीं भी रखा जा सकता है; उदाहरण के लिए, आप रिक्त लाइनों को रिक्त स्थान बना सकते हैं या लेज़र लाइनों के बाद एक स्थान रख सकते हैं यदि यह आपको किसी भी वर्ण को बचाने में मदद करता है।

यहाँ एक विज़ुअलाइज़ेशन है, विनिर्देश को अधिक आसानी से समझने के लिए, लाइनों के आगे सभी नोट नामों के साथ:

      HB
 ---  HA
      HG
----- HF
      HE
----- HD
      HC
----- B
      A
----- G
      F
----- E
      D
 ---  C
      LB
 ---  LA
      LG
 ---  LF
... (bottom cut off for brevity, you get the idea anyway)

यहां कुछ और उदाहरण दिए गए हैं जिनका उपयोग करके आप अपने कार्यक्रम का परीक्षण कर सकते हैं:

इनपुट: HG#

 #O
-|---
 |
-|---

-----

-----

-----

इनपुट: LAb

-----

-----

-----

-----

-----
   |
 --|
   |
 bO-

इनपुट: HB

  O
 |--
 |
-|---

-----

-----

-----

-----

इनपुट: C

-----

-----

-----

-----
   |
---|-
   |
 -O-

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाएगा!

1: सबसे यथार्थवादी प्रदर्शनी evar! :-P

code-golf  ascii-art  music 
— Doorknob
स्रोत
2
नोट के दाईं ओर #या bबाईं ओर के बजाय यह बहुत अजीब लगता है ; क्या यह वास्तव में आवश्यक है?
— थॉमस बरूचेल
2
बी # और पसंद के बारे में क्या? 1. कथानक जैसा है; 2. अस्वीकार; 3. चुपचाप सी में परिवर्तित?
— डिजिटल ट्रामा
2
यह स्पष्ट रूप से बताने के लिए बेहतर हो सकता है कि यह तिगुनी दरार में होना चाहिए।
— user12205
3
Fugue में यह प्रयास करने के लिए किसी को भी ?
— AJMansfield
3
@AJM हाँ, यह ASCII कला होना चाहिए।
— दरवाज़े

जवाबों:

1

गोल्फस्क्रिप्ट, 211 210 209 197 195 192 वर्ण

(इस पद के अनुसार) जीत के लिए, मेरे नवीनतम पायथन संस्करण का एक गोल्फस्क्रिप्ट संस्करण आ रहा है :

"J"\+[0]+.1=71>>3<{}/@7*2/246-@3+7%-:z;:c;21,{..3z<3z
if<\11z>11z
if>|{;}{...2>\12<&\2%.{'-'' 'if}:Q~:9;&Q\.z={c!9{[c]''+}if}{..z>\4z+<&8z>&'|'9if}if\.z='o'9if\..z
4-\<\z<&7z<&'|'9if\;3$n}if}/

यहां इसका परीक्षण करें (पहली 2 लाइनें उपयोगकर्ता-इनपुट हैं, आम तौर पर यह स्टडिन से आती है)।

'पठनीय' संस्करण:

;"HCb"

"J"\+[0]+       #process input
.1=71>>3<       #first char is HJL, second is letter, third is #b or space
{}/             #spill chars onto stack, now we working with ints
@7*2/246-@3+7%- #convert HC/JD/LE etc to a number from 0 to 20
:z;:c;
21,{            #for r in range(21):
  ..3z<3z if<           #either out-of-bounds or process the line
  \11z>11z if>|
  {;}{
    ...2>\12<&\2%.{'-'' 'if}:Q~:9;&Q\        #1st char
    .z={c!9{[c]''+}if}                       #2nd char accidental
       {..z>\4z+<&8z>&'|'9if}if\            #2nd char stem or row
    .z='o'9if\                              #3rd char
    ..z 4-\<\z<&7z<&'|'9if\                 #4th char stem or row
    ;3$                                      #5th char=1st char
    n
  }if
}/
— Claudiu
स्रोत
Aaaaaaand फिर से GolfScript द्वारा पीटा गया। :) ...
— मार्टिन एंडर
@ m.buettner: हाहा, यह कभी खत्म नहीं होता .. आश्चर्यजनक रूप से हालांकि करीब!
— Claudiu
1
बेहतर! अब मुझे केवल 6/9 बाइट खोजने की आवश्यकता है: D (हालाँकि मैं नहीं देखता कि मैं ऐसा कैसे करूँगा)
— मार्टिन एंडर
@ m.buettner: नीचे 2 और बाइट्स मिल गए! हालांकि हर एक इतना क्रूर है ... मुझे अब इसके लिए रुकना पड़ सकता है। सौभाग्य!
— क्लाउडीयू
2
हे खूनी नरक ... जब मैंने सोचा कि मैंने तुम्हारा 209 पीटा है। मुझे लगता है कि मैं हार मान रहा हूं। GolfScript प्रबल है। ;)
— मार्टिन एंडर
6

रूबी - 271 267 252 249 234 229 220 214 वर्ण

मैंने सचमुच रूबी को इसके लिए सीखा। तो निश्चित रूप से इसे नीचे गोल्फ में सुधार के लिए जगह है। या वास्तव में कुछ भी कर रहा है। लेकिन मुझे एक भाषा की जरूरत थी जिसमें परस्पर सामंजस्य हो। :)

def f(n)s=[0]*20
s.fill{|i|i%2>0?i<3||i>11?" ---":?-*5:" "*5}
s[l=(3-n[(p="H_L".index n[0])?1:0].ord)%7+7*(p||1)][1,2]=("#b"[n[-1]]||s[l][1])+?O
s[l+3-2*o=l>7?3:1,3].map{|t|t[o]=?|}
puts s[[3,l].min..[11,l].max]end

कुछ हद तक असंयमी:

def f(note)
  staff=[]
  0.step(20) {|i| staff[i] = " "*5}
  1.step(19,2) {|i| staff[i] = " ---"}
  3.step(11,2) {|i| staff[i] = "-"*5}
  level = 7
  if !(pos="HL".index note[i=0]).nil?
    level = 14*pos
    i += 1
  end
  level += (73-note[i].ord)%7
  staff[level][2] = "O"
  mark = note[-1]
  if !"#b".index(mark).nil?
    staff[level][1] = mark
  end
  offset = (level > 7) ? 3 : 1
  staff[level-2*offset+3,3].map {|line| line[offset] = "|"}
  first = [3,level].min
  last = [11,level].max
  puts s[first..last]
end

अगर इसे खाली लाइनों की अनुमति दी जाती है तो मैं इसे 2 और पात्रों को 212 वर्णों तक काट सकता हूं । यह समाधान उन लाइनों को नहीं भरता है जो वैसे भी मुद्रित नहीं हैं:

def f(n)s=[]
[3,l=(3-n[(p="H_L".index n[0])?1:0].ord)%7+7*(p||1)].min.step(l>11?l:11){|i|s[i]=i%2>0?i<3||i>11?" ---":?-*5:" "*5}
s[l][1,2]=("#b"[n[-1]]||s[l][1])+?O
s[l+3-2*o=l>7?3:1,3].map{|t|t[o]=?|}
puts s
end

लाम्बा के निष्पक्ष खेल हैं? तब मुझे पहले दृष्टिकोण के साथ 210 अक्षर मिल सकते हैं

f=->n{s=[0]*20
s.fill{|i|i%2>0?i<3||i>11?" ---":?-*5:" "*5}
s[l=(3-n[(p="H_L".index n[0])?1:0].ord)%7+7*(p||1)][1,2]=("#b"[n[-1]]||s[l][1])+?O
s[l+3-2*o=l>7?3:1,3].map{|t|t[o]=?|}
puts s[[3,l].min..[11,l].max]}

या अतिरिक्त रिक्त लाइनों के साथ 207 वर्ण :

f=->n{s=[]
[3,l=(3-n[(p="H_L".index n[0])?1:0].ord)%7+7*(p||1)].min.step(l>11?l:11){|i|s[i]=i%2>0?i<3||i>11?" ---":?-*5:" "*5}
s[l][1,2]=("#b"[n[-1]]||s[l][1])+?O
s[l+3-2*o=l>7?3:1,3].map{|t|t[o]=?|}
puts s}

बेशक, अब आपको करने की आवश्यकता होगी f.call("HGb")।

— मार्टिन एंडर
स्रोत
हा, एक पूरी तरह से नई भाषा सीखने के लिए +1! ;-) यहाँ एक टिप है: !x.nil?के बराबर है !x। और एक पंक्ति के लिए अगर, if x;y;end;के बराबर है y if x। इसके अलावा, आप उस स्ट्रिंग में शाब्दिक न्यूलाइन का उपयोग कर सकते हैं।
— दरवाज़े
@Doorknob धन्यवाद, मैं उन में काम करने की कोशिश करूँगा!
— मार्टिन एंडर
@ डॉर्कनोब एचएम, मुझे केवल ifकाम करने का मौका मिला । अगर मैं उपयोग करता हूं ?\n(यदि आपका मतलब है तो) मुझे एक स्थान जोड़ने की आवश्यकता है, इसलिए मुझे कुछ भी नहीं मिला। और एस को हटाने से .nil?(हमेशा मूल्यांकन किया गया true) बिल्कुल भी काम नहीं किया ।
— मार्टिन एंडर
मेरा मतलब था कि दो कोट्स के बीच एक नई पंक्ति जोड़ना। और मुझे लगता है कि हटाते समय आपको अतिरिक्त परिंदों की आवश्यकता होती है .nil?, लेकिन यह पात्रों में इसके लायक है।
— दरवाज़े
@ डॉर्कनोब आह, नहीं !x.nil?है !!x। :)
— मार्टिन एंडर
2

पायथन, 329 309 295 286 280 277 वर्ण

अब थोड़ा और गोल्फ। फिर भी सुधार किया जा सकता है, लेकिन निश्चित नहीं कि अगर मैं इस दृष्टिकोण के साथ रूबी या गोल्फस्क्रिप्ट समाधान को हरा सकता हूं।

R=range
N='J'+raw_input()+' '
X=N[1]>'G'
a,b,c=N[X:3+X]
z=266-ord(a)/2*7+(ord(b)-4)%7
Z=[list((' '*5,(' ---','-'*5)[8<r<18])[r%2])for r in R(21)]
Z[z][2]='o'
if' '<c:Z[z][1]=c
Q=(z<13)*2
for i in(1,2,3):Z[z+i*Q-i][Q+1]='|'
for r in R(max(17,z),min(z-1,8),-1):print''.join(Z[r])

प्रारंभ में मैं लाइन-बाय-लाइन प्रिंट कर रहा था, लेकिन यह बहुत अधिक लेने के लिए निकला, इसलिए मैंने एक स्ट्रिंग ग्रिड तैयार किया और फिर उसमें क्या भरा जाना चाहिए, इनपुट कमांड लाइन से है, जैसे।

>echo HG# | python note2_golf.py
 #o
-|---
 |
-|---

-----

-----

-----
— Claudiu
स्रोत
पंक्ति 5 में आप दूसरे अल्पविराम से पहले स्थान को हटा सकते हैं
— user12205
@ace: धन्यवाद, याद है कि एक
— Claudiu
2

गोल्फस्क्रिप्ट - 243 232 228 227 वर्ण

मैंने अपने कॉफीस्क्रिप्ट उत्तर को गोल्फस्क्रिप्ट में अनुवादित किया, जो स्ट्रिंग जोड़तोड़ के लिए अधिक अनुकूल है।

संपादित करें: वेतन वृद्धि ऑपरेटर का उपयोग करके छह वर्णों को ठीक से सहेजा, तीन का उपयोग स्टैक का अच्छा उपयोग करके, गैरकानूनी रूप से पुनर्परिभाषित ऑपरेटरों द्वारा छह अधिक का उपयोग करके, और एक और अनुग्रह लाइनों के बाद अनुगामी स्थान को नहीं प्रिंट करके।

पूरी तरह से गोल्फ:

..0="HL"?2+3%:o)2%.@="CDEFGAB"?7o*+:`2%45 32if:r;
).2$,<{=}{;;r}if:&;
[" "5*:|" ---":g]4*[|"-"5*]5*+[|g|]+.
[`<~]\[`>([0=:^&79r^]''+\~]
+17`<`)18if<9`>`9if:j>:t 13`>.2*):x;
4,1>{`j-\2${+}{-}if}%\;
{.@<\t>(:v[x<'|'+x)v>+]\++:t}
/-1%n*

टिप्पणियों के साथ:

# extract octave
..0="HL"?2+3%:o

# extract note
2%1\-.@="CDEFGAB"?7o*+:k

# line spacer
2%45 32if:r;

# extract accidental
1+.2$,<{=}{;;r}if:a;

# staff
[" "5*:|" --- ":g]4*[|"-"5*]5*+[|g|]+.

# lines below
[k<~]\

# note line and above
[k>([0=:w a 79r w]''+\~]+

# cut off just what we need
17k<1k+18if<
9k>k 9if:j>:t;

# and the note stem
13k>.2*1+:x;4,1>{k j-\2${+}{-}if}%\;

{
  .t<\
  t>(:v[x<'|'+1x+v>+]\++:t;
}/

# now output the note
t-1%n*
— couchand
स्रोत
मैं चकित रह जाता अगर मैं एक गोल्फस्क्रिप्ट समाधान को उस भाषा में हरा सकता हूं जिसका मुझे कोई अनुभव नहीं है;)
— मार्टिन एंडर
1
मैं कोई गोल्फस्क्रिप्ट विशेषज्ञ नहीं हूं, लेकिन मुझे लगता है कि मैंने उन सभी पात्रों के बारे में सोचा है, जिनसे मैं बाहर निकलने वाला हूं, इसलिए यदि आप एक और दो पा सकते हैं, तो आप सुनहरे हैं!
— कौचंद
Goइसमें टाइप करने की कोशिश करें । यह उत्पादन करेगा oo|||:)
— जेमी
1

पायथन, 250 245 242 235 वर्ण

एक बहुत अलग दृष्टिकोण जो मेरे दूसरे को पीटता हुआ समाप्त हो गया! इनपुट प्रोसेसिंग कोड समान है लेकिन इसके बारे में है।

M=' -'
N=raw_input()+M
a,b,c=('J'+N)[N>'G':][:3]
z=ord(a)*7/2-246-(ord(b)+3)%7
for r in range(21):
 L=M[r%2];F=M[2<r<12and r%2]
 if min(3,z)<=r<=max(11,z):print F+((L,'|')[8>z<r<z+4],(L,c)[M<c])[r==z]+(L,'o')[r==z]+(L,'|')[z-4<r<z>7]+F

मैंने पंक्ति और स्तंभ के आधार पर प्रत्येक वर्ण के मान को मैप किया और फिर छपाई को नियंत्रित किया:

#given row r, with note on row n, how to print each char?
#rows are:
#       HB : 0
#  ---  HA : 1
#       HG : 2
# ----- HF : 3
#       HE : 4
# ----- HD : 5
#       HC : 6
# ----- B  : 7
#       A  : 8
# ----- G  : 9
#       F  : 10
# ----- E  : 11
#       D  : 12
#  ---  C  : 13
#       LB : 14
#  ---  LA : 15
#       LG : 16
#  ---  LF : 17
#       LE : 18
#  ---  LD : 19
#       LC : 20
#chars are:
# 0 | 1 | 2 | 3 | 4
#
# 0,4:
#    if r%2:
#      if 2<r<12: '-'
#      else ' '
#    else: ' '
# 1: ' -b#|'
#    if r==n:
#      if A: c
#      else: ' -'[r%2]
#    elif n<8 and n<r<n+4: '|'
#    else: ' -'[r%2]
# 2: ' -o'
#    if r==n: 'o'
#    else: ' -'[r%2]
# 3: ' -|'
#    if n>7 and n-4<r<n: '|'
#    else: ' -'[r%2]
— Claudiu
स्रोत
+1, अंतिम पंक्ति पाइथोनिक सामान की तुलना में अधिक पर्ल का काला जादू लगती है
— एंटोनियो रागैगिन
1

जावा - 921 907 863 अक्षर

मैं प्रत्येक स्ट्रिंग को अलग-अलग बनाता हूं, प्रत्येक स्ट्रिंग को एक सरणी में संग्रहीत करता हूं। फिर सरणी के माध्यम से लूप करें और प्रत्येक पंक्ति का प्रिंट आउट लें।

public class D{public static void main(String[]a){char[]z=a[0].toCharArray();char[]y=new char[3];y[0]=('H'==z[0]||'L'==z[0])?z[0]:'N';int o=(y[0]=='N')?0:1;y[1]=z[o++];y[2]=z.length>o?z[o]:'!';int n=y[1]<'C'?((int)(y[1]-'A'))+6:((int)(y[1]-'C'))+1;n=(y[0]=='N')?n+7:(y[0]=='H'?n+14:n);String s="     ";String b=" --- ";String[]u=new String[22];for(int i=1;i<=21;i+=2){u[i]=s;}for(int i=10;i<=18;i+=2){u[i]="-----";}u[20]=n>19?b:s;u[2]=n<3?b:s;u[4]=n<5?b:s;u[6]=n<7?b:s;u[8]=n<9?b:s;char c=u[n].charAt(0);char e=u[n].charAt(1);char[]h=new char[]{c,y[2]=='!'?e:y[2],'O',e,c};u[n]=new String(h);for(int i=0;i<22;i++){if(n<14&&i-n<4&&i>n)u[i]=u[i]!=null?u[i].substring(0,3)+"|"+u[i].charAt(4):s;else if(n>13&&n-i<4&&n>i)u[i]=u[i]!=null?u[i].substring(0,3)+"|"+u[i].charAt(4):s;}for(int i=21;i>=0;i--)if(!(i>n&&i>18||i<n&&i<10))System.u.println((u[i]==null)?s:u[i]);}}

ओह, कृपया मुझसे नफरत मत करो, यह मेरी पहली बार है। मुझे कोई faq / परिचय नहीं मिला, इसलिए मुझे उम्मीद है कि मेरा पोस्टिंग प्रारूप ठीक है। यह निश्चित नहीं है कि चरित्र की गिनती के बारे में लोगों को कितना गंभीर मिला .... कोड का सामान्य संस्करण - अतिरिक्त लाइनब्रेक / स्थान (1313 वर्ण) है:

public class DisplayNote
{
  public static void main(String[] args)
  {
    char[] z=args[0].toCharArray();
    char[] y=new char[3];
    y[0]=('H'==z[0]||'L'==z[0])?z[0]:'N';
    int o=(y[0]=='N')?0:1;
    y[1]=z[o++];
    y[2]=z.length>o?z[o]:'!';

    int noteValue=y[1]<'C'?((int) (y[1] - 'A')) + 6:((int) (y[1] - 'C')) + 1;
    noteValue=(y[0]=='N')?noteValue+7:(y[0]=='H'?noteValue+14:noteValue);
    String s="     ";
    String b=" --- ";
    String[] out=new String[22];
    for (int i=1;i<=21;i+=2){out[i]=s;}
    for (int i=10;i<=18;i+=2){out[i]="-----";}
    out[20]=noteValue>19?b:s;
    out[2]=noteValue<3?b:s;
    out[4]=noteValue<5?b:s;
    out[6]=noteValue<7?b:s;
    out[8]=noteValue<9?b:s;

    char c=out[noteValue].charAt(0);
    char e=out[noteValue].charAt(1);
    char[] h=new char[]{c,y[2]=='!'?e:y[2],'O',e,c};
    out[noteValue]=new String(h);
    for (int i=0;i<22;i++)
    {
      if (noteValue<14&&i-noteValue<4&&i>noteValue)
        out[i]=out[i]!=null?out[i].substring(0,3)+"|"+out[i].charAt(4):s;
      else if (noteValue>13&&noteValue-i<4&&noteValue>i)
        out[i]=out[i]!=null?out[i].substring(0,3)+"|"+out[i].charAt(4):s;        
    }

    for (int i=21;i>=0;i--)
      if (!(i>noteValue&&i>18||i<noteValue&&i<10))
        System.out.println((out[i]==null)?s:out[i]);
  }
}
— Will_61
स्रोत
मुझे अनावश्यक व्हाट्सएप के टन (विशेष रूप से अर्धविराम के बाद और ऑपरेटरों और कोष्ठक और परेंस के बाद) और लंबे चर नाम (जैसे args) दिखाई देते हैं।
— दरवाज़े
वर्ण गणना प्रस्तुत करने में: 921 वर्ण, सभी
— व्हाट्सएप
हर जगह व्हॉट्सएप के साथ दूसरा सबमिशन लोगों को कोड पढ़ने देने के लिए है, जैसा कि मैंने कहा कि यह मेरी पहली बार है तो यकीन नहीं होता कि अगर हम 1 सबमिशन छोड़ने के लिए हैं और 1 जहां आप चरित्र सीमा को कम करने की कोशिश करते हैं ... या क्या?
— विल ०६१
नहीं; मुझे उस संस्करण में बेकार व्हाट्सएप की एक बड़ी मात्रा दिखाई देती है। उदाहरण के लिए, रिक्त स्थान अर्धविराम के बाद, ऑपरेटरों के साथ स्पेस, रिक्त स्थान के बाद [], कोष्ठक, आदि के साथ स्पेस
— दरवाज़े
उन सभी को अब हटा दिया (मुझे लगता है) धन्यवाद :)
— Will_61
1

हास्केल 377 सी

import Data.Char
(<.)=elem
n(c:r)|elem c"HL"=let(s,a)=n r in(s+case c of 'H'->7;_-> -7,a)|1<2=(mod(ord c-67)7-2,case r of[]->' ';[x]->x)
r(s,a)y x=c where d|s>4= -1|1<2=1;c|x<.[0,4]&&(y<0||y>8)=' '|x==2&&y==s='o'|y==s&&x==1&&' '/=a=a|x==2+d&&y<.[s+k*d|k<-[1..3]]='|'|1<2="- "!!mod y 2
g p@(s,a)=unlines$[map(r p y)[0..4]|y<-reverse[min 0 s..max 8 s]]
main=getLine>>=putStr.g.n

Ungolfed संस्करण:

import Data.Char

fromName ('H':s) = let (step, alter) = fromName s in ((step + 7), alter)
fromName ('L':s) = let (step, alter) = fromName s in ((step - 7), alter)
fromName (x:s) = (mod (ord x - 67) 7 - 2, if null s then ' ' else head s)

renderChar :: (Int, Char) -> Int -> Int -> Char
renderChar (step, alter) y x = let
    dir = if step >  4 then -1 else 1
    normal = "- "!!mod y 2
    stemYs = [step + k * dir | k <- [1..3]]
    c | elem x [0,4] && not(elem y [0,2,4,6,8]) = ' '
      | x == 2 && y == step = 'o'
      | y == step && x == 1 && alter /= ' ' = alter
      | elem y stemYs && x == 2 + dir = '|'
      | otherwise = normal
  in c

render :: (Int, Char)-> String
render (step, alter) = unlines [map (renderChar (step, alter) y) [0..4] | y <- ys] 
  where
    ys = reverse [min 0 step .. max 8 step]

main = getLine >>= (putStr.render.fromName)
— रे
स्रोत
0

लिटरेट कॉफीस्क्रिप्ट - 497 527 अक्षर

मुझे यकीन है कि ग्रिड बनाने का एक बेहतर तरीका है, लेकिन मैं इसका पता नहीं लगा सकता।

एक गोल्फ हेल्पर।

_=(q)->->q.split ""

एसी प्रमुख पैमाने और कर्मचारी।

s=_("CDEFGAB")()
l=_ "-----"
e=_ "     "
g=_ " --- "
t=->
  o=[e(),l(),e(),l(),e(),l(),e(),l(),e(),l(),e(),g(),e()]
  o.unshift e(),g() for [0..3]
  o

हमारा नोटेशन फ़ंक्शन एक नोट के स्ट्रिंग प्रतिनिधित्व को ले जाएगा।

f=(i)->
  o=1
  m=t()

पहले हम सप्तक का निर्धारण करेंगे।

  if /L|H/.test i[0]
    if i[0]=="L" then o=0 else o=2
    i=i[1..]

फिर नोट और आकस्मिक। प्यार करना डिकंस्ट्रक्टिंग असाइनमेंट।

  [n,a]=i

आइए नोट और ऑक्टेव को एक इंडेक्स में बदलें और नोट को प्लॉट करें।

  x=7*o+s.indexOf n

  m[x][1]=a if a
  m[x][2]='O'

अब हम केवल उतने ही कर्मचारियों को काटेंगे जितने की आवश्यकता है।

  j=9
  k=17
  if x>17
    k=x
  else if x<9
    j=x
  u=x-j
  m=m[j..k]

और नोट स्टेम।

  if x<13
    m[x][3]='|' for x in [u+3...u]
  else
    m[x][1]='|' for x in [u-3...u]

अब परिणाम को आउटपुट करते हैं।

  m.map((p)->p.join '').reverse().join '\n'

अंत में, हम कंसोल टेस्टिंग के लिए फंक्शन एक्सपोर्ट करेंगे। ये वर्ण कुल की ओर नहीं गिनते हैं।

module.exports = f
— couchand
स्रोत
करीब से देखने पर ऐसा लगता है जैसे मैंने नोट के तने को रिफलेक्ट किया था, इसलिए यह इस समय अवैध उत्पादन करता है।
— कौचंद
मैंने इसे ठीक कर दिया, लेकिन इसने 30 पात्रों को जोड़ा: - /
— couchand
0

सी, 325 304

अब @ बाइट के लिए 21 बाइट्स कम धन्यवाद !

i;j;c;n;main(t){char
x[133];for(i;i<132;i++){x[i]="-----\n     \n"[i%12];if((i<18||i>77)&&!((i%12)&11))x[i]=32;}for(;!n;){c=getchar();if(c>71)t=c^72?2:0;else
n=7*t+7-(c-4)%7;}x[i=n*6+2]=79;if((c=getchar())>32)x[i-1]=c;for(t=0,j=n<9?i+5:i-17;t<3;t++,j+=6)x[j]='|';x[n<13?77:n*6+5]=0;puts(x+(n>4?24:n*6));}

आउटपुट:

./a.out
HBb
 bO  
 |-- 
 |   
-|---

-----

-----

-----

-----


./a.out
LG#
-----

-----

-----

-----

-----

 --| 
   | 
 --| 
 #O
— बग़ल में ossifrage
स्रोत
वैश्विक चर को डिफ़ॉल्ट रूप से शून्य से प्रारंभ किया जाता है, इसलिए आपको आरंभ करने की आवश्यकता नहीं है nऔर आप i=0पहले forलूप में निकाल सकते हैं ।
— user12205
इसके अलावा, पहले ifबयान में, के ((i%12)&11)==0साथ प्रतिस्थापित किया जा सकता है !((i%12)&11)।
— user12205
अंत में, ?:की तुलना में बहुत कम पूर्वता है, ^और <इससे पहले कि आप शर्तों के ब्रैकेट को हटा सकते हैं ?। और आप के printf("%s",साथ बदल सकते हैं puts(।
— user12205
0

जावास्क्रिप्ट 390 388

एक चुनौती का एक सा, मुझे मानना ​​पड़ेगा ... मुझे यकीन है कि इसे कम करने के तरीके हैं ... मैं सुझाव के लिए खुला हूं ...

पहला Iteration

C=(a,x,o,c)=>{a[x]=a[x].substr(0,o)+c+a[x].substr(o+1)};l=7;s=[];for(i=21;i--;)s[i]="    ";for(j=1;19>j;j+=2)s[j]=" ---";for(k=3;12>k;k+=2)s[k]="-----";~(p="HL".indexOf((n=prompt())[i=0]))&&(l=14*p,i++);l+=(73-n.charCodeAt(i))%7;C(s,l,2,"O");m=n[n.length-1];"#"!=m&   "b"!=m||C(s,l,1,m);o=7<l?3:1;for(z=0;3>z;C(s,t=l-2*o+3+z++,o,"|"));S=s.splice(3<=l?3:l,11>=l?11:l);console.log(S.join("\n"))

दूसरा पुनरावृत्ति ( n.slice(-1)इसके बजाय का उपयोग करके n[n.length-1]), 2 बाइट्स को हिलाता है

C=(a,x,o,c)=>{a[x]=a[x].substr(0,o)+c+a[x].substr(o+1)};l=7;s=[];for(i=21;i--;)s[i]="    ";for(j=1;19>j;j+=2)s[j]=" ---";for(k=3;12>k;k+=2)s[k]="-----";~(p="HL".indexOf((n=prompt())[i=0]))&&(l=14*p,i++);l+=(73-n.charCodeAt(i))%7;C(s,l,2,"O");m=n.slice(-1);"#"!=m& "b"!=m||C(s,l,1,m);o=7<l?3:1;for(z=0;3>z;C(s,t=l-2*o+3+z++,o,"|"));S=s.splice(3<=l?3:l,11>=l?11:l);console.log(S.join("\n"))

Ungolfed संस्करण:

function C(a,x,o,c){
    a[x]=a[x].substr(0,o)+c+a[x].substr(o+1);
}
l=7;s=[];
for(i=21;i--;){
    s[i]="    ";
}
for(j=1;19>j;j+=2){
    s[j]=" ---";
}
for(k=3;12>k;k+=2){
    s[k]="-----";
}
i=0;n=prompt();
p="HL".indexOf(n[i]);
if(p>=0){
    l=14*p;i++;
}
l+=(73-n.charCodeAt(i))%7;
C(s,l,2,"O");
m=n.slice(-1);
if((m=="#")||m=="b"){
    C(s,l,1,m);
}
o=7<l?3:1;
for(z=0;3>z;z++){
    C(s,t=l-2*o+3+z,o,"|");
}
F=Math.min(3,l);
L=Math.max(11,l);
S=s.splice(F,L);
console.log(S.join("\n"));
— WallyWest
स्रोत
क्या आप एक ungolfed (पठनीय) संस्करण जोड़ सकते हैं, कृपया?
— मार्टिन एंडर
@ m.buettner हो गया ... मुझे आशा है कि यह आपको बेहतर तरीके से समझने में मदद करेगा कि मैंने क्या किया है :)
— WallyWest
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.