Code Golf: Piano

88

O desafio

O código mais curto por contagem de caracteres para produzir uma parte de um teclado de piano a partir de uma nota de entrada em um determinado comprimento.

A entrada será composta de uma nota ( [ACDFG]#|[A-G]) para começar a imprimir o teclado e um número positivo representando o comprimento das teclas a serem impressas, incluindo a primeira nota.

A primeira chave deve ser impressa por extenso - se tiver uma chave sustenido à esquerda, será cortada, o mesmo para quando a chave de início for sustenido, a chave esquerda também será cortada.

Uma tecla Sharp não é contada, apenas teclas brancas.

Casos de teste

Input
    C 14
Output
    |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
    |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
    |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
    |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
    |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |
    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |
    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |
    |____|____|____|____|____|____|____|____|____|____|____|____|____|____|

Input
    D# 1
Output
    ###   |
    ###   |
    ###   |
    ###   |
    ###   |
     |    |
     |    |
     |    |
    _|____|

Input
    A 7
Output
    ##  ###   |   ###  ###   |   ###  ##
    ##  ###   |   ###  ###   |   ###  ##
    ##  ###   |   ###  ###   |   ###  ##
    ##  ###   |   ###  ###   |   ###  ##
    ##  ###   |   ###  ###   |   ###  ##
    |    |    |    |    |    |    |    |
    |    |    |    |    |    |    |    |
    |    |    |    |    |    |    |    |
    |____|____|____|____|____|____|____|

A contagem de códigos inclui entrada / saída (ou seja, programa completo).

language-agnostic code-golf rosetta-stone LiraNuna
fonte
5
[A-G]#*? Isso significa que precisamos lidar, digamos, B#####como E?
Anon.
5
Para a contagem de chaves, defina "chave". Por que o exemplo "C 14" está imprimindo 24 teclas?
Guffa
53
OK, agora que temos soluções C e C #, precisamos B, D e F #.
LiraNuna
7
Próximo código de golfe: implemente uma interface MIDI para esses pianos.
Mehrdad Afshari
10
Caros encerradores, saúdo-os por conseguirem encerrar este desafio após 3 dias. Precisamos reabrir em 5 minutos. Só isso já deve te dizer algo - a comunidade gosta e aceita esse tipo de pergunta, quer você goste ou não. Se você não fizer isso, entretanto, adicione code-golf à sua lista de tags ignoradas.
LiraNuna

Respostas:

27

GolfScript - 80 caracteres

Cabe em uma linha de #SO sem a barra de rolagem :)

' ':s/~~5*\(7&5*\,.4*@+):k;+):c;9,{5<'#'9**' | '4*+3/4<.1>+c*s.+*k>c<n+}%)s/'_'*

GolfScript - 81 caracteres

' ': /((7&\,.4*@5*+:k;\~~5*+):c;9,{5<'#'9**' | '4*+3/4<.1>+c*  +*k)>c<n+}%) /'_'*

Versão bem formatada (27 x 3)

' ': /((7&\,.4*@5*+:k;\~~5*
+):c;9,{5<'#'9**' | '4*+3/4
<.1>+9*  +*k)>c<n+}%) /'_'*

GolfScript - 82 caracteres

' '/((7&\,.4*@5*+:k;\~~5*+):c;9,{5<3*'###  '*' |   '4*+20<.5>+c*k)>c<n+}%)' '/'_'*

GolfScript - 85 caracteres

' '/((7&\,.4*@5*+:k;\~~5*+):c;9,{.5<3*'###  '*' _'1/@8=='|'1$3*++4*+20<.5>+c*k)>c<n}%

Versão bem formatada (17 x 5)

' '/((7&\,.4*@5*+
:k;\~~5*+):c;9,{.
5<3*'###  '*' _'1
/@8=='|'1$3*++4*+
20<.5>+c*k)>c<n}%

GolfScript - 94 caracteres

' ': /~~5*:c;(7&5*:^;,:&;['###  '3*' |   '+.5>+c*1>{^4&*+>&c+)<n}:f~]5*'   _'1/{'|'\4*+7*c*f}%

GolfScript - 98 caracteres

' ': /~~5*:c;(7&5*:^;,:&;['###  '3*' |   '+.5>+c*^4&*+:^)>&c+):&<n]5*[   '_']{['|'\4*+7*c*^>&<n]}%

GolfScript - 101 caracteres

' ': /~~5*:c;(7&5*:^;,:&;['###  '3*' |   '+.5>+c*^4&*+)>&c+)<n]5*[   '_']{['|'\4*+7*c*^4&*+>&c+)<n]}%

GolfScript - 109 caracteres

' ': /~~5*:c;(7&5*:^;,:&;['##''  ###'.'   | '++.'  #'+++c*^4&*+>&c+)<n]5*[   '_']{['|'\4*+7*c*^4&*+>&c+)<n]}%

GolfScript - 120 caracteres

' '/~~5*:c;(7&5*:^;,:&;['##''  ###'.'   | '++.'  #'+++c*^4&*+>&c+)<n]5*['|    '7*c*^4&*+>&c+)<n]3*'|____'7*c*^4&*+>&c+)<

GolfScript - 127 caracteres

' '/~~5*:c;(7&5*:^;,:&;['##  ###  ###   |   ###  ###   |   #'c*^4&*+>&c+)<n]5*['|    '7*c*^4&*+>&c+)<n]3*'|____'7*c*^4&*+>&c+)<

$ echo -n C 14 | ruby golfscript.rb piano.gs 
|   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
|   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
|   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
|   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
|   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|____|____|____|____|____|____|____|____|____|____|____|____|____|____|
$ echo -n D# 1| ruby golfscript.rb piano.gs 
###   |
###   |
###   |
###   |
###   |
 |    |
 |    |
 |    |
_|____|
$ echo -n A 7| ruby golfscript.rb piano.gs 
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
|    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |
|____|____|____|____|____|____|____|
gnibbler
fonte
Eu estava prestes a enviar minha primeira inscrição golfscript para outro desafio ( stackoverflow.com/questions/2104556/… ), mas ele foi fechado :-(
mob
2
Eu gostaria que eles ensinassem golfscript na escola. Eu quero meu dinheiro de volta.
Steve Tjoa
6
Agradável. Postarei minha solução no PianoScript mais tarde. São apenas 6 caracteres. :-)
molf
112

Perl, 133 (129) caracteres

Perl, 167 160 156 147 142 133 D'oh! 147 144 137 134 133 chars

    $ _ = shift; die grep {5> $ n? y / * / # /: y / # * / | /; $ n ++ - 8 || y / / _ /}
    @ Q = (substr (("* # #". ("* # # * # | #") X2) x9,
    4 * / # / + (7 & ord) * 5,1 + / # / + 5 * pop). $ /) X9

Aqui está uma solução de 129 caracteres, pegando emprestadas várias idéias da solução Ruby da molf:

    ($ _, $ c) = @ ARGV; $ j = ($ k = / # /) + ord;
    para $ n (0..8) {print $ /, substr + (join '', map {8- $ n? 5> $ n && $ _% 7% 4? "###"
    : "|": "_ | ___"} $ j .. $ j + $ c),! $ k, -3}

e com a ajuda do Acme :: AsciiArtinator :

                sub init_piano{$S=$";$H='#';
                (                            $
               T                              ,$P,$U)=qw(
              T                                          |
             _                                            |
            /                                              )
           ;                                                $
          d             =$T.$H.$S.$S;$t                     =
         $             d               .                   $H
        .              $               d                  . $
       S               .$P.$S.$S.$S.$H;$                t=  $
      d.$H.$t.$t;};$_=shift;-/-/;&init_piano();$Z=/#/;-/|   |
      |                                                 |   |
      |                    YAMAHA                       |  /
      ;die grep{4>$n++?y/T/#/:y/#T/ |/;$n-8||y/ /_/;}@q=(m{
     // // /// // /// // /// // /// // /// // /// // /// /   
    // // /// // /// // /// // /// // /// // /// // /// /
   }                                                   .
   substr(${t}x(9),4*${Z}+(7&ord)*5,1+$Z+5*pop).$/)x(8)
          ;   '                            \   /
           | |                              | |
           /_\                              /';
mob
fonte
7
Hahaha, incrível. Isso é um Steinway, Yamaha, Young Chang?
Steve Tjoa
2
Vou marcar isso para mostrar às pessoas que não entendem a piada do "macaco".
Mehrdad Afshari
3
@Steve - Vamos torná-lo uma Yamaha
mob
6
@mobrule, você odeia grep? porque você quer que ele morra? :(
LiraNuna
Golfscript * 1.3 seria 105 :)
John La Rooy
34

Ruby - 125 caracteres

146 144 140 137 134 126 125 chars

a,n=$*;h=a[1]?0:1;s=a[0]-h+1
9.times{|t|puts (s..s+n.to_i).map{|i|i%7%4<1||t>4?" |   ":"###  "
}.join[h..-4].tr t>7?" ":n,"_"}

(A segunda nova linha não é necessária e adicionada apenas para evitar uma barra de rolagem no SO. Os pontos e vírgulas podem ser substituídos por novas linhas, se desejado.)

A versão do Ruby 1.9 é diferente, mas de igual comprimento (substituindo a[0]pora.ord e "_"por ?_):

a,n=$*;h=a[1]?0:1;s=a.ord-h+1
9.times{|t|puts (s..s+n.to_i).map{|i|i%7%4<1||t>4?" |   ":"###  "
}.join[h..-4].tr t>7?" ":n,?_}

Ligue com

$ ruby piano.rb C 14
molf
fonte
Ei VIM conta 138 caracteres no primeiro?!?
hurikhan77
a, n = gets.split; ... faz o mesmo trabalho, -3 caracteres
hurikhan77
1
Você pode até substituir "gets.split" por "$ *" e fornecer a entrada na linha de comando, -8 chars
hurikhan77
Mude i%7%4<1||t>4?"_|___":"###__"para i%7%4&&t<5?"###__":"_|___"e salve 2 caracteres. Eu amo esse %7%4idioma
mob
1
Então, chegamos à solução mais curta, hein? Ruby rulez! :-D
hurikhan77
29

LilyPond, 285 288 291 310 315 330 333 340 350 caracteres

De acordo com o tema musical, aqui está uma solução em uma linguagem projetada para composição de partituras musicais, LilyPond:

x=#ly:string-substitute
u=#(x"*""###  ""|   *** |   ** ")t=#(x"###"" | "u)q=#read-char
z=#(q)v=#(if(eq?(q)#\#)1 0)y=#(iota(+(*(read)5)1 v))#(format #t"~{~{~a~}
~}"(map(lambda(s)(map(lambda(i)(string-ref s(modulo(+(*(char->integer z)5)i(* v
4))35)))y))(list u u u u u t t t(x" ""_"t))))

Uso: $ lilypond thisfile.ly <input.in >output.out 2>/dev/null

12 rotações
fonte
4
esta é possivelmente a primeira e única vez que vi LilyPond ser usado no golfe de código.
cobbal
3
@cobbal: Consulte também stackoverflow.com/questions/1433263/decision-tree-code-golf/… , stackoverflow.com/questions/1575096/code-golf-musical-notes/… , stackoverflow.com/questions/383403/… (mais curto do que qualquer outra solução), golf.shinh.org/p.rb?Counting+adventure
KirarinSnow
26

RetroGolf - Applesoft BASIC: 236 239 245 249 257 245 267 285

Mostrado em várias linhas para facilitar a leitura, mas deve ser uma única linha:

1K$="##   |   ###  #":K$="##  #"+K$+K$:
 FORI=1TO21:F$=F$+"|____":L$=L$+"|    ":NEXT:
 INPUTN$:S=MID$(N$,2,1)="#":O=(ASC(N$)-65)*5+1+S*4:L=VAL(RIGHT$(N$,2))*5+1+S:
 FORI=1TO5:?MID$(K$+K$+K$,O,L):NEXT:FORI=1TO3:?MID$(L$,O,L):NEXT:?MID$(F$,O,L)

Pode ser testado com este Interpretador BASIC da Applesoft em Javascript ou um emulador .

Piano http://img685.imageshack.us/img685/3407/piano2.png

Carlos Gutiérrez
fonte
É possível ler os dois argumentos na mesma linha, de acordo com as especificações?
KirarinSnow
18

C # - 315

Eu insisto no golfe em C # embora não seja uma linguagem muito concisa ...

using C=System.Console;class P{static void L(int o,int c,string s){while(c-->0)C.Write(s[(420>>o++%5*2&3)+(91>>(o+2)/5%7&1)*3]);C.WriteLine();}static void Main(string[]a){int i=0,s=a[0].Length-1,c=int.Parse(a[1])*5+1+s,o=(a[0][0]-65+s)*5-s;while(i++<5)L(o,c,"|  ## ");while(i++<8)L(o,c,"|  |  ");L(o,c,"|__|__");}}
Guffa
fonte
23
Agora, para a solução de F # para completar a melodia.
LiraNuna
13
+1 para humor, -1 para humor cafona e +1, pois C # e F # são concordantes.
Steve Tjoa
Recebi um System.IndexOutOfRangeException quando tentei executá-lo.
Fitzchak Yitzchaki
@Mendy: Você deve fornecer argumentos de linha de comando ao executá-lo. Se você executá-lo no Visual Studio, abra as propriedades do projeto, vá para a guia de depuração e em Opções de inicialização você pode inserir argumentos de linha de comando. Se você compilou o código em um exe, apenas execute-o em uma janela de console com os argumentos após o nome do programa.
Guffa
1
Muito bom uso do operador ->.
Kevin
16

Python - 164

k,n=raw_input().split()
m=k[1:]>""
n=int(n)*5+1
o=(ord(k[0])-65)*5+4*m
for x in["##  ###   |   ### "]*5+[n*"|    "]*3+[n*"|____"]:print((x+x[::-1][:-1])*n)[o:o+n+m]
gnibbler
fonte
Você não poderia salvar alguns caracteres removendo a parte repetida de te ue multiplicando por 7?
Matthew Crumley
@Matthew Crumley, sinta-se à vontade para pegar emprestado minha solução :)
John La Rooy
@gnibbler, não sou realmente um programador python (já brinquei com ele um pouco, mas não muito), então duvido que seria capaz de fazer muito com ele. Eu nem sabia que python poderia multiplicar strings assim até que vi sua solução original.
Matthew Crumley
@gnibbler - boa solução, adoraria executá-lo, mas obtendo um SyntaxError .... C 14 Traceback (última chamada mais recente): Arquivo "piano.py", linha 1, em? k, n = input (). split () Arquivo "<string>", linha 1 C 14 ^
AJ.
@AJ, parece que esse erro é da solução Python3. Não sei por que você está recebendo isso
John La Rooy
15

Octave, 153 154 155 158 159 162 172 180 186 185 188 197 199 200 206 207 209 212 214 215 219 240 244 268 caracteres

Por que usar apenas C ou C # ou F # (ou B ou D) quando você pode programar com um oitavo completo?

(agrupado a cada 60 caracteres para maior clareza)

x=5*scanf("%2c%d");for k=-8:0disp((s={[t="|   ###  ###  ","#
##   ",t" "]"|    ","|____"}{(k>-4)+!k+1})(1+mod(5*(y=x(2)>1
60)+(-y:x(3))+x(1),rows(s'))))end

Sim ... esta solução realmente calcula a transposta conjugada complexa de uma string.

Uso: $ octave -q thisfile.m <input.in >output.out

22 rotações
fonte
13

C - 197 203 207 216 224 232 240 personagens

#define S"#   |   ###  ###  ##"
main(i,j,l,h,t){char*X[]={"____|","    |",S S,S S},s[i=11];for(scanf("%s%n%d",s,&h,&l);--i>1;puts(""))for(j=t=*s%7*5+h*4;j<t+l*5+h;putchar(X[i/3][j++%(i>5?35:5)]));}

Esta versão equivalente de 194 caracteres assume que o estouro de buffer está correto.

#define S"#   |   ###  ###  ##"
i=11;main(j,l,h,t){char*X[]={"____|","    |",S S,S S},s;for(scanf("%s%n%d",&s,&h,&l);--i>1;puts(""))for(j=t=s%7*5+h*4;j<t+l*5+h;putchar(X[i/3][j++%(i>5?35:5)]));}
KennyTM
fonte
1
for(j=0; j<=l*5+h; j++)<- espaços inúteis, e você parece tê-los incluído na contagem de caracteres também
Nicolás
12

PostScript: 239 245 293 312 (normal); 219 224 225 231 (ASCII85)

/r{(%stdin)(r)file token pop}def[(]){mul add}/z r(:-)cvs dup length 1
sub/v exch/p r/s(|   ###  ###  ###   |   ###  ###   )([){0 1 v p 5]{s
exch z 0 get 5]v 4]s length mod 1 getinterval print}for/
=}>>begin[[[[[/s(|    )def[[[/s(|____)def[

Versão binária expandida por meio da codificação ASCII85 em um programa de 219 caracteres com apenas caracteres ASCII imprimíveis:

/(|____)/(|    )[/r/(|   ###  ###  ###   |   ###  ###   )<~Ou%G5-$+0=Bl5@JE[d/;P,jagI?HCK@<*JGP,4<rOuSV60p8LhG*5%O8oc=a.=3b)!HsVu23Md=!IHJ_A<K->@5*j;23Md=!HoSBP&-9^09Tk/@ZkI\P"_$^I?I,S+?b-:5*?@Z>?b<9Ou$<H>EUc~>cvx
exec[

Uso: $ gs -q -dNOPROMPT -dNODISPLAY -dBATCH thisfile.ps <input.in >output.out

11 rotações
fonte
10
Adoro ver as línguas menos tradicionais nestes concursos.
mob
12

F #: 224 225, 226, 248, 252, 270, 276, 299, 306 Caracteres

let x,(/)=System.Console.ReadLine(),String.replicate
let t,p=(int x.[0]-60)%7*5,int x.[1]%2
let g s i=printf"%s"(i/((99/s).[t+4*p..t+int x.[2..]*5+5*p]+"\n"))
g"|   ###  ###   |   ###  ###  ###   "5 
g"|    "3
g"|____"1

Usei módulos de 2 para detectar um espaço ou libra. '' é 32% 2 = 0 '#' é 35% 2 = 1 e como minha condicional retornou zeros para falso, eu apenas multipliquei o resultado dos módulos.

Usou o <| operador para raspar um caractere de espaço. Sobrecarga de operador usado para salvar outro char.

original

let piano_long (input:string) = 
    let sharp, flat = if input.[1] = '#' then 4, 1 else 0, 0

    let note = (int input.[0] - 60) % 7
    let num = int (input.Substring 2)

    let start = note * 5 + sharp
    let stop = num * 5 + 1 + flat

    let top    = "|   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |"
    let middle = "|    |    |    |    |    |    |    |    |    |    |    |    |    |    |"
    let bottom = "|____|____|____|____|____|____|____|____|____|____|____|____|____|____|"


    let mutable piano = ""

    for i in 1..5 do 
        piano <- piano + top.Substring(start, stop) + "\n"

    for i in 1..3 do 
        piano <- piano + middle.Substring(start, stop) + "\n"

    piano <- piano + bottom.Substring(start, stop)

    printf "%s\n\n" piano
10 revs
fonte
Eu poderia cortar 46 caracteres se F # tivesse um operador de multiplicação de string
gradbot
Um pouco mais curto:let g s i=for i=1 to i do printfn"%s"(String.replicate 99 s).[t+4*p..t+int(x.[2..])*5+5*p]
cfern
Incrível, obrigado! Não sei por que não consegui encontrar isso. Eu atribuí a uma variável e usei duas vezes.
gradbot
Agora, estou pagando apenas a taxa de 48 caracteres de nomes de função .net.
gradbot
Parabéns pela versão 8! Estou surpreso com o quanto você cortou.
ChaosPandion
11

sed, 231 235 234 235 237 238 244 268 269 270 276 279 280 282 287 300 307 314 329 338 caracteres

Funciona com até 99 teclas. O piano padrão tem 52 teclas brancas, então isso deve ser suficiente.

s/.*/CDEFGABC&=0123456789-/
s/(.).=(.*)\1.*/&\2\2\2\2\2\2\2\2\2\2/
s/ .?(.)=(.*)\1.*-/\2/
s/.*#/%&/
:
s/((.)(.).*\2)[#-9]/\1  \3/
t
s/[^ %CF]/###/g
s/C|F/ | /g
s/(%....)?.{25}(.*)./\2/p
p
p
p
p
s/## /|  /g
s/#[|#]/ |/g
p
p
p
y/ /_/

Exemplos:

$ echo C 14 | sed -rf piano.sed
|   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
|   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
|   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
|   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
|   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|____|____|____|____|____|____|____|____|____|____|____|____|____|____|
$ echo D# 1 | sed -rf piano.sed
###   |
###   |
###   |
###   |
###   |
 |    |
 |    |
 |    |
_|____|
$ echo A 7 | sed -rf piano.sed
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
|    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |
|____|____|____|____|____|____|____|
$ echo A 52 | sed -rf piano.sed
##  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ##
##  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ##
##  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ##
##  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ##
##  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ##
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|

O último exemplo imprime o teclado padrão, junto com teclas pretas imaginárias em cada extremidade.

20 rotações
fonte
10

PianoScript - 2 caracteres

É uma linha simples:

go

Uso:

PianoScript piano.ps G# 11

Resultado:

###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ##
###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ##
###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ##
###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ##
###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ##
 |    |    |    |    |    |    |    |    |    |    |    |
 |    |    |    |    |    |    |    |    |    |    |    |
_|____|____|____|____|____|____|____|____|____|____|____|

Mais informações sobre a linguagem PianoScript podem ser encontradas aqui .

Sem noção
fonte
1
Pode ter 0 caracteres, não é?
VOCÊ
Presumo que em PianoScript ++ você será capaz de escrever o programa em um caractere a menos.
gradbot de
4
Pena que você não foi o primeiro a ter essa ideia.
LiraNuna
4
-1 por trapacear e nem mesmo inventar um nome legal para o idioma;)
gnarf
1
pianos têm partituras, não scripts
Jimmy
10

JavaScript - 195 caracteres

Ei, o golfe é um jogo onde você só compete contra você mesmo, certo? :)

k=readFile(0).split(' ')
q=!k[0][1]
r=k[1]
o=''
for(x=10;x--;){p=k[0].charCodeAt(0)-65+!q
s=''
for(j=+r+1;j--;){p=++p%7
s+=x>4&&!p|p%3?'###  ':x?' |   ':'_|___'}o+=s.substring(q,r*5+2)+'\n'}print(o)

Solução por gnarf; portado para Rhino (com uma pequena correção e alterações de formatação) por KirarinSnow; ainda mais lascado por gnarf; erro corrigido por KirarinSnow. esconderijok[1] por cwallenpoole

Uso: $ cp input.in 0; rhino thisfile.js

Versão de demonstração HTML rápida: Teste de golfe - AdicionareadFile=prompt;print=function(a) {document.write("<pre>"+a);}

gnarf
fonte
Bem, você também compete contra a especificação ... e acho que você perdeu. ;) Ele nem passa nos casos de teste. Parece que começa um.
Guffa
Você só tem 1 referência para b. altere readFile (b) para apenas readFile ('substring')
Ponkadoodle
@wallacoloo - necessária mais tarde, a parte inferior:s=s[b](1-q,p=s.length-3)
gnarf
6

Python3 - 158

Economizar em inputvs raw_input. Perde ()paraprint

k,n=input().split()
o=(ord(k[0])-65)*5
n=int(n)*5+1
for x in["##  ###   |   ### "]*5+[n*"|    "]*3+[n*"|____"]:print(((x+x[::-1][:-1])*n)[o+3*len(k[1:]):o+n])
John La Rooy
fonte
5

F #: 355 caracteres significativos

Tudo em uma linha:

let[|x;y|]=System.Console.ReadLine().Split([|' '|])in[for i in 1..9->let r (a:string) b j (s:string)=s.Replace(a,if i>j then b else a)in((String.replicate(int y+1)"23012123012121").Substring(int(x.[0])-65,int y*2+x.Length).Replace("0","|   ")|>r"1""#"0|>r"2""##  "0|>r"3"" "0).TrimEnd()|>r"###"" | "5|>r"##""| "5|>r" ""_"8]|>String.concat"\n"|>printfn "%s"

Expandido:

let piano() =
    let[|x;y|]=System.Console.ReadLine().Split([|' '|])in
    [for i in 1..9->
        let r (a:string) b j (s:string) = s.Replace(a,if i>j then b else a) in
        ((String.replicate (int y+1) "23012123012121")
            .Substring(int(x.[0])-65,int y*2+x.Length).Replace("0","|   ")
            |> r "1" "#" 0
            |> r "2" "##  " 0
            |> r "3" " " 0)
            .TrimEnd()|> r "###" " | " 5|> r "##" "| " 5|> r " " "_" 8]
    |> String.concat "\n"
    |> printfn "%s"
Juliet
fonte
@Brian, peça que a equipe implemente getsou equivalente, economizaríamos 22 caracteres!
Benjol
Acho que, ao jogar golfe, a recursão é uma boa maneira de remover anotações de tipo.
gradbot
3

SETL

165 caracteres; Tradução da solução Gribblers Python.

get(l);[k,n]:=split(l);o:=(abs k(1)-65)*5;n:=1+5*val n;(for x in['##  ###   |   ### ']*5+[n*'|    ']*3+[n*'|____'])print(((x+reverse x(2..))*n)(o+4*#k-3..o+n));end;
Finnw
fonte
3

D2 (modelos): 331 370 400 + 17 caracteres

(com base na solução Ruby.)

Comprimido:

template J(alias T,int b,int e,r...){static if(e)enum J=T!(b,r)~J!(T,b+1,e-1,r);else enum J="";}template K(int i,int t){enum K=t>7?"_|___":t<5&&3&i%7?"###  ":" |   ";}template R(int t,int s,int l,int h){enum R=J!(K,s-h,l,t)[h..$-3]~"\n";}template M(alias k){enum M=J!(R,0,9,k[0]+1,k[$-2]>32?k[$-1]+10*k[$-2]-527:k[$-1]-47,k[0]&1);}

Explicado:

/**
    Macros:
        D = <tt>$0</tt>
 */
 ;

/**
    $(D_PSYMBOL J) (short for "join") will evaluate $(D T!(i,r)) for
    $(D_PARAM i) in $(D [b..b+e]). Then, these compile-time strings will be
    concatenated.
 */
template J(alias T,int b,int e,r...){
    static if(e)
        enum J=T!(b,r)~J!(T,b+1,e-1,r);
    else
        enum J="";
}

/**
    $(D_PSYMBOL K) (short for "key") will generate 5 characters as a row of
    key $(D_PARAM i) at row $(D_PARAM t).
 */
template K(int i,int t){
    enum K=t>7?"_|___":t<5&&3&i%7?"###  ":" |   ";
}

/**
    $(D_PSYMBOL R) (short for "row") will generate the keyboard at row
    $(D_PARAM t), from key $(D_PARAM s) and sharpness $(D_PARAM h) with a
    length of $(D_PARAM l) keys.
 */
template R(int t,int s,int l,int h){
    enum R=J!(K,s-h,l,t)[h..$-3]~"\n";
}

/**
    $(D_PSYMBOL M) (short for "main") results in the whole keyboard as a string.

    Example:
    -----
    pragma(msg,M!("C 14"));
    pragma(msg,M!("D# 1"));
    pragma(msg,M!("A 7"));
    -----
 */
template M(alias k){
    enum M=J!(R,0,9,k[0]+1,k[$-2]>32?k[$-1]+10*k[$-2]-527:k[$-1]-47,k[0]&1);
}

Como não podemos passar parâmetros da dmdentrada, isso deve ser feito no código. Suporta apenas até 99 chaves.

KennyTM
fonte
2
Você pode transformar a entrada em uma única string? Parte do desafio é analisar a linha em uma nota, um sustenido opcional e uma duração. A análise em si pode levar alguns caracteres em alguns idiomas ...
KirarinSnow
2

Haskell: 212 211 208 caracteres

a="  |  "
b=" ### "
d=concat.cycle
e=d[b,b,a,b,b,a,b]
f=d[a]
t x s m n=map(take(5*read s+m).drop(5*length['@'..x]-n))[e,e,e,e,e,f,f,f,d["__|__"]]
u(x:'#':s)=t x s 2 4 
u(x:s)=t x s 1 8
main=interact$unlines.u

Ele ainda assume letras compatíveis com ASCII (especificamente, a sequência "@ABCDEFG"), mas não requer mais Char.ord

3 rotações
fonte
2

Ruby - 113 caracteres

É executado com argumentos de linha de comando

$ ruby piano.rb A 7

k,c=$*
9.times{|x|puts (((b=x<8?'  |  ':'__|__')+(a=x<5?' ### ':b)*3+b+a*2)*j=k[0]*5-2+4*s=k.size)[j,c.to_i*5+s]}

Ruby - 118 caracteres

k,c=$*
9.times{|x|puts (((b=x<8?'  |  ':'__|__')+(a=x<5?' ### ':b)*3+b+a*2)*j=2+k[0]*5+4*s=k.size-1)[j..c.to_i*5+s+j]}
gnibbler
fonte
2

PHP - 208 caracteres

<?$e=45*substr($a=PIANO,2+$d=!($a[1]^~ì))+9+$d*45;$j=9*$c=4*$d;for($b=ord($a[0])-65,--$c;$j<$e;$f[$i=$j++%9].=($c=($c+!$i)%5)%4<2&$i>3&$b%3!=2?Ü:($c?$i?ß: :))$j%45-36?:$b=++$b%7;for(;$a=$f[$i--];)echo~$a,~õ;

Deve ser melhorado.

A entrada deve ser entregue na constante chamada PIANO.

user581149
fonte
1

F # 414 386 372 caracteres significativos:

//wins me 2 characters
open System

//String.replicate, didn't know this existed before reading Juliet
let r=String.replicate  

//print s n times, each time on a newline
let P n s=printf"%s"(r n (s+"\n"))  

//define top rows
let t="##  ###   |   ###  ###   |   ###  #" 

//middle and bottom rows can be defined using 'r'
let m,b=r 7"|    ",r 7"|____" 

//pick of chars from O to n+O from string, wrap round if we go beyond s.Length
let L(s:string)O n=String([|5*O..5*(n+O)|]|>Array.map(fun i->s.[i%35]))

//match input string into two halves
let[|k;n|]=Console.ReadLine().Split([|' '|])

//work out start pos and length (in chars, not keys)
let O,N=
 let K=int k.[0]-65                    //'A'=65, this is why t starts at A
 if k.[0]='#'then(K+3,int n+2)else(K,int n) 

//Print 5 top rows, 3 middle rows and the bottom row
P 5(L t O N)
P 3(L m O N)
P 1(L b O N)

Ah, e um bônus, este script vai realmente lidar com "F # 372" corretamente - não vou incomodá-lo colando-o aqui ...

System.Console.ReadLine () é uma chatice ...

Benjol
fonte