Die Zombie-Apokalypse ist da und die Welt geht unter. Plötzlich entdeckt jemand eine Formel, die die aktuelle Stunde, Minute und den aktuellen Tag enthält, und spuckt die perfekte Note aus, um auf einem Klavier zu spielen, das jeden Zombie, der sie hört, sofort tötet. Leider gibt es nur noch einen Klavierspieler auf der Welt, und er hat vergessen, Noten zu lesen, weiß aber immer noch, wie man Noten liest. Natürlich ist dies eine sehr zeitkritische Sache, daher scheint es natürlich, dass ein Computer dies tut. ¹

Ihre Herausforderung besteht darin, eine Notiz wie Gdie folgende zu notieren und sie auf einem Notensystem (im Violinschlüssel) auszugeben:

-----

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

-----

Spezifikation:

• Sie müssen einen Stab mit abwechselnden Zeilen von -----(5 Bindestrichen) und eine Leerzeile ausgeben . Es werden -----insgesamt 5 s sein. Die Notiz muss oben auf diesen Stab gelegt werden.
• Die Eingabe gibt an, wo sich die Notiz befindet. Die Eingabe wird sein:
  • ein optionales Hoder L, wobei "hoch" oder "niedrig" angegeben wird
  • ein Brief von Abis G, der die Tonhöhe angibt
  • ein optionales #oder b, scharf oder flach spezifizierend.
• Die "Notiz" ist definiert als:
  • Einer O(Großbuchstabe O) ist auf die Mitte des Stabes ausgerichtet, die sich an der Stelle der Notiz befindet. (Die oberste Zeile ist HF(hohes F) und die unterste Zeile ist E(ein normales E).)
  • Drei |s (vertikale Balken), der Stiel, der sein wird:
    • ein Leerzeichen links von der Note und abwärts (beginnend ein Leerzeichen unter der Note), wenn sich die Note in der Mittellinie ( B) oder darüber befindet, oder
    • Ein Leerzeichen rechts von der Note und nach oben (beginnend ein Leerzeichen über der Note), wenn sich die Note unter der Mittellinie befindet.
  • Ein #oder bein Leerzeichen direkt links von der Note, falls in der Eingabe angegeben.
• Ledgerzeilen müssen hinzugefügt werden, wenn die Note zu hoch oder zu niedrig ist. Diese Linien sind ---(nur 3 Striche in der Breite im Gegensatz zu 5) und werden nur angezeigt, wenn sich die Notiz auf oder über / unter (jeweils für die oberen / unteren Hauptbuchlinien) den Hauptbuchlinien befindet.
• Überflüssige Leerzeichen können beliebig platziert werden. Sie können beispielsweise festlegen, dass die leeren Zeilen Leerzeichen enthalten oder dass nach den Hauptbuchzeilen ein Leerzeichen steht, wenn dies beim Speichern von Zeichen hilfreich ist.

Hier ist eine Visualisierung, um die Spezifikation leichter zu verstehen, mit allen Notennamen neben den Zeilen:

      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)

Hier sind einige weitere Beispiele, mit denen Sie Ihr Programm testen können:

Eingang: HG#

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

-----

-----

-----

Eingang: LAb

-----

-----

-----

-----

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

Eingang: HB

  O
 |--
 |
-|---

-----

-----

-----

-----

Eingang: C

-----

-----

-----

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

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

^{1: realistischste ausstellung evar! :-P}

Golfscript, 211 210 209 197 195 192 Zeichen

Kommen Sie für den (ab diesem Post) Gewinn, eine GolfScript-Version meiner neuesten Python-Version :

"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}/

Testen Sie es hier (die ersten beiden Zeilen sind Benutzereingaben, normalerweise kommt es von stdin).

"Lesbare" Version:

;"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
}/

Ruby - 271 267 252 249 234 229 220 214 Zeichen

Ich habe Ruby buchstäblich nur dafür gelernt. Es gibt also durchaus Verbesserungspotential beim Golfspielen. Oder etwas wirklich zu tun. Aber ich brauchte eine Sprache mit veränderlichen Zeichenfolgen. :)

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

Etwas ungolfed:

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

Ich kann es um weitere 2 Zeichen auf 212 Zeichen reduzieren, wenn führende Leerzeilen zulässig sind. Diese Lösung füllt die nicht gedruckten Zeilen nicht aus:

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

Sind Lambdas faires Spiel? Dann kann ich mit dem ersten Ansatz 210 Zeichen bekommen

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]}

Oder 207 Zeichen mit zusätzlichen Leerzeilen:

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}

Natürlich müsstest du das jetzt tun f.call("HGb").

Python, 329 309 295 286 280 277 Zeichen

Jetzt ein bisschen mehr golfen. Noch kann verbessert werden, aber nicht sicher, ob ich die Rubin- oder Golfscript-Lösungen mit diesem Ansatz schlagen kann.

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])

Ursprünglich habe ich zeilenweise gedruckt, aber es hat sich herausgestellt, dass dies zu viel Zeit in Anspruch nimmt. Daher erstelle ich ein Zeichenfolgenraster und gebe dann ein, was ausgefüllt werden muss. Die Eingabe erfolgt über die Befehlszeile, z.

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

-----

-----

-----

GolfScript - 243 232 228 227 Zeichen

Ich habe meine CoffeeScript-Antwort in GolfScript übersetzt, das viel besser für die Manipulation von Strings geeignet ist.

BEARBEITEN: Sie haben sechs Zeichen gespeichert, indem Sie den Inkrement-Operator ordnungsgemäß verwendet haben, drei Zeichen, indem Sie den Stapel gut ausgenutzt haben, sechs weitere Zeichen, indem Sie nicht verwendete Operatoren unverantwortlich neu definiert haben, und eines, indem Sie das nachstehende Leerzeichen nach den Kulanzlinien nicht drucken.

Völlig golfen:

..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*

Mit Kommentaren:

# 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*

Python, 250 245 242 235 Zeichen

Eine ganz andere Herangehensweise, die meine andere übertroffen hat! Der eingegebene Verarbeitungscode ist ähnlich, aber das war's auch schon.

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

Ich habe den Wert jedes Zeichens basierend auf der Zeile und der Spalte festgelegt und dann den Druck ausgeführt:

#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]

Java - 921 907 863 Zeichen

Ich baue jeden String einzeln auf und speichere jeden String in einem Array. Durchlaufen Sie dann das Array und drucken Sie jede Zeile aus.

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]);}}

Oh bitte, hasse mich nicht, es ist mein erstes Mal. Ich konnte keine FAQ / Einführung finden, also hoffe ich, dass mein Beitragsformat in Ordnung ist. Ich bin mir nicht sicher, wie ernst die Leute mit der Anzahl der Zeichen umgegangen sind ... normale Version des Codes - extra ist Zeilenumbruch / Leerzeichen (1313 Zeichen):

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]);
  }
}

Haskell 377C

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-Version:

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)

Literate CoffeeScript - 497 527 Zeichen

Ich bin mir sicher, dass es einen besseren Weg gibt, das Gitter aufzubauen, aber ich kann es nicht herausfinden.

Ein Golfhelfer.

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

Wechselstrom-Hauptskala und Personal.

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

Unsere Notationsfunktion übernimmt die Zeichenfolgendarstellung einer Note.

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

Zuerst bestimmen wir die Oktave.

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

Dann die Notiz und versehentlich. Ich muss es lieben, Aufträge zu dekonstruieren.

  [n,a]=i

Lassen Sie uns die Note und die Oktave in einen Index konvertieren und die Note plotten.

  x=7*o+s.indexOf n

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

Jetzt schneiden wir nur so viel Personal ab, wie wir brauchen.

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

Und der Notenstamm.

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

Lassen Sie uns nun die Ergebnisse ausgeben.

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

Zuletzt exportieren wir die Funktion für Konsolentests. Diese Zeichen zählen nicht zur Gesamtsumme.

module.exports = f

C 325 304

Jetzt 21 Bytes kürzer dank @ace !

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));}

Ausgabe:

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

-----

-----

-----

-----


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

-----

-----

-----

-----

 --| 
   | 
 --| 
 #O  

JavaScript 390 388

Ich muss zugeben, dass dies eine Herausforderung ist. Ich bin mir sicher, dass es Möglichkeiten gibt, dies weiter zu reduzieren. Ich bin offen für Vorschläge.

Erste 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"))

Bei der zweiten Iteration (mit n.slice(-1)anstelle von n[n.length-1]) werden 2 Byte gespart

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-Version:

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"));