language agnostic - upstream - Código Golf: Piano
upstream advanced c1 teacher''s book pdf (22)
El reto
El código más corto por recuento de caracteres para mostrar una parte de un teclado de piano a partir de una nota de entrada en una longitud determinada.
La entrada estará compuesta de una nota ( [ACDFG]#|[AG] ) para comenzar a imprimir el teclado y un número positivo que representa la longitud de las teclas para imprimir, incluida la primera nota.
La primera clave debe imprimirse en su totalidad; si tiene una tecla nítida hacia la izquierda, se cortará, lo mismo para cuando la tecla de inicio sea nítida, también se cortará la tecla de la izquierda.
No se cuenta una tecla aguda, solo teclas blancas.
Casos de prueba
Input
C 14
Output
| ### ### | ### ### ### | ### ### | ### ### ### |
| ### ### | ### ### ### | ### ### | ### ### ### |
| ### ### | ### ### ### | ### ### | ### ### ### |
| ### ### | ### ### ### | ### ### | ### ### ### |
| ### ### | ### ### ### | ### ### | ### ### ### |
| | | | | | | | | | | | | | |
| | | | | | | | | | | | | | |
| | | | | | | | | | | | | | |
|____|____|____|____|____|____|____|____|____|____|____|____|____|____|
Input
D# 1
Output
### |
### |
### |
### |
### |
| |
| |
| |
_|____|
Input
A 7
Output
## ### | ### ### | ### ##
## ### | ### ### | ### ##
## ### | ### ### | ### ##
## ### | ### ### | ### ##
## ### | ### ### | ### ##
| | | | | | | |
| | | | | | | |
| | | | | | | |
|____|____|____|____|____|____|____|
El recuento de códigos incluye entrada / salida (es decir, programa completo).
GolfScript - 80 Personajes
Cabe en una línea de #SO sin la barra de desplazamiento :)
'' '':s/~~5*/(7&5*/,.4*@+):k;+):c;9,{5<''#''9**'' | ''4*+3/4<.1>+c*s.+*k>c<n+}%)s/''_''*
GolfScript - 81 Personajes
'' '': /((7&/,.4*@5*+:k;/~~5*+):c;9,{5<''#''9**'' | ''4*+3/4<.1>+c* +*k)>c<n+}%) /''_''*
Versión muy formateada (27 x 3)
'' '': /((7&/,.4*@5*+:k;/~~5*
+):c;9,{5<''#''9**'' | ''4*+3/4
<.1>+9* +*k)>c<n+}%) /''_''*
GolfScript - 82 Personajes
'' ''/((7&/,.4*@5*+:k;/~~5*+):c;9,{5<3*''### ''*'' | ''4*+20<.5>+c*k)>c<n+}%)'' ''/''_''*
GolfScript - 85 Personajes
'' ''/((7&/,.4*@5*+:k;/~~5*+):c;9,{.5<3*''### ''*'' _''1/@8==''|''1$3*++4*+20<.5>+c*k)>c<n}%
Versión muy formateada (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 Personajes
'' '': /~~5*:c;(7&5*:^;,:&;[''### ''3*'' | ''+.5>+c*1>{^4&*+>&c+)<n}:f~]5*'' _''1/{''|''/4*+7*c*f}%
GolfScript - 98 Personajes
'' '': /~~5*:c;(7&5*:^;,:&;[''### ''3*'' | ''+.5>+c*^4&*+:^)>&c+):&<n]5*[ ''_'']{[''|''/4*+7*c*^>&<n]}%
GolfScript - 101 Personajes
'' '': /~~5*:c;(7&5*:^;,:&;[''### ''3*'' | ''+.5>+c*^4&*+)>&c+)<n]5*[ ''_'']{[''|''/4*+7*c*^4&*+>&c+)<n]}%
GolfScript - 109 Personajes
'' '': /~~5*:c;(7&5*:^;,:&;[''##'''' ###''.'' | ''++.'' #''+++c*^4&*+>&c+)<n]5*[ ''_'']{[''|''/4*+7*c*^4&*+>&c+)<n]}%
GolfScript - 120 Personajes
'' ''/~~5*:c;(7&5*:^;,:&;[''##'''' ###''.'' | ''++.'' #''+++c*^4&*+>&c+)<n]5*[''| ''7*c*^4&*+>&c+)<n]3*''|____''7*c*^4&*+>&c+)<
GolfScript - 127 Personajes
'' ''/~~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
## ### | ### ### | ### ##
## ### | ### ### | ### ##
## ### | ### ### | ### ##
## ### | ### ### | ### ##
## ### | ### ### | ### ##
| | | | | | | |
| | | | | | | |
| | | | | | | |
|____|____|____|____|____|____|____|
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]
Python3 - 158
Ahorre en la input vs raw_input . Perder en () para print
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])
Ruby - 113 caracteres
Se ejecuta con argumentos de línea 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]}
LilyPond, 285 288 291 310 315 330 333 340 350 caracteres
De acuerdo con el tema de la música, aquí hay una solución en un lenguaje diseñado para la composición de partituras, 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
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 qué utilizar solo C o C # o F # (o B o D) cuando puede programar con una Octava completa?
(envuelto cada 60 caracteres para mayor claridad)
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
Sí ... esta solución realmente computa la compleja transposición conjugada de una cuerda.
Uso: $ octave -q thisfile.m <input.in >output.out
PostScript: 239 245 293 312 (regular); 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[
Versión binaria expandida a través de la codificación ASCII85 en un programa de 219 caracteres con solo caracteres imprimibles ASCII:
/(|____)/(| )[/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
sed, 231 235 234 235 237 238 244 268 269 270 276 279 280 282 287 300 307 314 329 338 caracteres
Funciona con hasta 99 claves. El piano estándar tiene 52 teclas blancas, así que esto debería 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/ /_/
Ejemplos:
$ 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
## ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ##
## ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ##
## ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ##
## ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ##
## ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ### ### | ### ### ### | ##
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|
El último ejemplo imprime el teclado estándar, junto con teclas negras imaginarias en cada extremo.
C # - 315
Persisto en el golf en C # aunque no es un lenguaje muy escueto ...
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,"|__|__");}}
C - 197 203 207 216 224 232 240 caracteres
#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 versión equivalente de 194 caracteres asume que el desbordamiento del búfer está bien.
#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)]));}
D2 (plantillas): 331 370 400 + 17 caracteres
(basado en la solución de 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 no podemos pasar parámetros de dmd la entrada debe hacerse en el código. Admite solo hasta 99 llaves.
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
Usé módulos de 2 para detectar un espacio o una libra. '''' es 32% 2 = 0 ''#'' es 35% 2 = 1 y como mi condicional arrojó ceros falsos, simplemente multipliqué el resultado de los módulos.
Usó el <| operador para afeitarse un espacio char. Sobrecarga de operador utilizada para guardar otro 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
JavaScript - 195 caracteres
Oye, el golf es un juego donde solo compites contra ti ¿verdad? :)
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)
Solución por gnarf; portado a Rhino (con una pequeña corrección y cambios de formato) por KirarinSnow; más astillado por Gnarf; error corregido por KirarinSnow. caché k[1] por cwallenpoole
Uso: $ cp input.in 0; rhino thisfile.js $ cp input.in 0; rhino thisfile.js
Versión de demostración de HTML rápido: prueba de golf : agrega readFile=prompt;print=function(a) {document.write("<pre>"+a);}
Perl, 133 (129) caracteres
Perl, 167 160 156 147 142 133 ¡Oh! 147 144 137 134 133 caracteres
$_=shift;die grep{5>$n?y/*/#/:y/#*/ |/;$n++-8||y/ /_/} @Q=(substr(("*# #".("*# #*# | #")x2)x9, 4*/#/+(7&ord)*5,1+/#/+5*pop).$/)x9
Aquí hay una solución de 129 caracteres, tomando prestada varias ideas de la solución de Ruby de molf:
($_,$c)=@ARGV;$j=($k=/#/)+ord; for$n(0..8){print$/,substr+(join'''',map{8-$n?5>$n&&$_%7%4?"### " :" | ":"_|___"}$j..$j+$c),!$k,-3}
y con la ayuda de 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)
; '' / /
| | | |
/_/ /'';
PianoScript - 2 caracteres
Es un trazador de líneas:
go
Uso:
PianoScript piano.ps G# 11
Salida:
### ### | ### ### | ### ### ### | ### ##
### ### | ### ### | ### ### ### | ### ##
### ### | ### ### | ### ### ### | ### ##
### ### | ### ### | ### ### ### | ### ##
### ### | ### ### | ### ### ### | ### ##
| | | | | | | | | | | |
| | | | | | | | | | | |
_|____|____|____|____|____|____|____|____|____|____|____|
Puede encontrar más información sobre el lenguaje PianoScript here .
RetroGolf - Applesoft BASIC: 236 239 245 249 257 245 267 285
Se muestra en varias líneas para facilitar la lectura, pero debe ser una sola línea:
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)
Puede ser probado con este intérprete de Applesoft BASIC en Javascript o un emulador .
Ruby - 125 caracteres
146 144 140 137 134 126 125 caracteres
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,"_"}
(La segunda línea nueva no es necesaria y se agrega solo para evitar una barra de desplazamiento en SO. Los puntos y comas pueden reemplazarse por líneas nuevas si así lo desea).
La versión de Ruby 1.9 es diferente pero de igual longitud (reemplazando a[0] por a.ord y "_" 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,?_}
Llamar con
$ ruby piano.rb C 14
SETL
165 caracteres; Traducción de Gribblers Python solution.
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;
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, y un extra, este script manejará correctamente "F # 372" correctamente - No te molestaré pegándolo aquí ...
System.Console.ReadLine () es un fastidio ...
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
Todavía asume que las letras son compatibles con ascii (específicamente, la secuencia "@ABCDEFG"), pero ya no requiere Char.ord
F #: 355 caracteres significativos
Todo en una línea:
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"
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,~õ;
Tendrá que ser mejorado.
La entrada debe ser entregada en la constante llamada PIANO.