Code Golf: Piano

Question 1

Le défi

Le code le plus court par nombre de caractères pour sortir une partie d'un clavier de piano à partir d'une note d'entrée d'une longueur donnée.

L'entrée sera composée d'une note ( [ACDFG]#|[A-G]) pour commencer l'impression du clavier et d'un nombre positif représentant la longueur des touches à imprimer, y compris la première note.

La première clé doit être imprimée en entier - si elle a une touche pointue gauche, elle sera coupée, de même que lorsque la touche de démarrage est nette, la touche gauche sera également coupée.

Une touche Sharp n'est pas comptée, seules les touches blanches.

Cas de test

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

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

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

Le décompte des codes comprend l'entrée / la sortie (c'est-à-dire le programme complet).

Question 2

GolfScript - 80 caractères

Convient à une ligne de #SO sans la barre de défilement :)

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

GolfScript - 81 caractères

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

Version joliment formatée (27 x 3)

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

GolfScript - 82 caractères

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

GolfScript - 85 caractères

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

Version joliment formatée (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 caractères

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

GolfScript - 98 caractères

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

GolfScript - 101 caractères

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

GolfScript - 109 caractères

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

GolfScript - 120 caractères

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

GolfScript - 127 caractères

' '/~~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 
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
##  ###   |   ###  ###   |   ###  ##
|    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |
|____|____|____|____|____|____|____|

Question 3

Perl, 133 (129) caractères

Perl, ~~167~~ ~~160~~ ~~156~~ ~~147~~ ~~142~~ ~~133~~ D'oh! ~~147~~ ~~144~~ ~~137~~ ~~134~~ 133 caractères

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

Voici une solution de 129 caractères, empruntant plusieurs idées à la solution Ruby de molf:

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

et avec l'aide d' 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)
          ;   '                            \   /
           | |                              | |
           /_\                              /';

Question 4

Rubis - 125 caractères

~~146~~ ~~144~~ ~~140~~ ~~137~~ ~~134~~ ~~126~~ 125 caractères

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 deuxième nouvelle ligne n'est pas nécessaire et ajoutée uniquement pour éviter une barre de défilement sur SO. Les points-virgules peuvent être remplacés par des nouvelles lignes si vous le souhaitez.)

La version Ruby 1.9 est différente mais de longueur égale (remplacée a[0]par a.ordet "_"par ?_):

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,?_}

Appeler avec

$ ruby piano.rb C 14

Question 5

LilyPond, 285 288 291 310 315 330 333 340 350 caractères

En accord avec le thème de la musique, voici une solution dans un langage conçu pour la composition de partitions musicales, 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))))

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

Question 6

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

Montré sur plusieurs lignes pour plus de lisibilité, mais doit être une seule ligne:

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)

Peut être testé avec cet interpréteur Applesoft BASIC en Javascript ou un émulateur .

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

Question 7

C # - 315

Je persiste à jouer au golf en C # bien que ce ne soit pas un langage très laconique ...

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,"|__|__");}}

Question 8

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]

Question 9

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 caractères

Pourquoi n'utiliser que C ou C # ou F # (ou B ou D) quand vous pouvez programmer avec une octave complète?

(enveloppé tous les 60 caractères pour plus de clarté)

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

Oui ... cette solution calcule vraiment la transposition conjuguée complexe d'une chaîne.

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

Question 10

C - 197 203 207 216 224 232 240 personnages

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

Cette version équivalente à 194 caractères suppose que le dépassement de la mémoire tampon est correct.

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

Question 11

PostScript: 239 245 293 312 (régulier); 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[

Version binaire étendue via le codage ASCII85 dans un programme de 219 caractères avec uniquement des caractères imprimables 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[

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

Question 12

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

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

J'ai utilisé des modules de 2 pour détecter un espace ou une livre. '' vaut 32% 2 = 0 '#' vaut 35% 2 = 1 et comme mon conditionnel a renvoyé des zéros pour faux, je viens de multiplier le résultat des modules.

Utilisé le <| opérateur pour raser un caractère d'espace. Utilisation de la surcharge d'opérateur pour enregistrer un autre caractère.

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

Question 13

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

Fonctionne jusqu'à 99 clés. Le piano standard a 52 touches blanches, donc cela devrait être suffisant.

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/ /_/

Exemples:

$ 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
##  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ##
##  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ##
##  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ##
##  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ##
##  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ###  ###   |   ###  ###  ###   |   ##
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |
|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|

Le dernier exemple imprime le clavier standard, ainsi que des touches noires imaginaires à chaque extrémité.

Question 14

PianoScript - 2 caractères

C'est un one-liner:

go

Usage:

PianoScript piano.ps G# 11

Production:

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

Vous trouverez plus d'informations sur le langage PianoScript ici .

Question 15

JavaScript - 195 caractères

Hé, le golf est un jeu où tu n'es que contre toi, non? :)

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)

Solution par gnarf; porté sur Rhino (avec un correctif mineur et des changements de formatage) par KirarinSnow; encore ébréché par le gnarf; erreur corrigée par KirarinSnow. cache k[1]par cwallenpoole

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

Version de démonstration HTML rapide: Test de golf - AjoutsreadFile=prompt;print=function(a) {document.write("<pre>"+a);}

Question 16

Python3 - 158

Économisez sur inputvs raw_input. Perdez ()pourprint

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

Question 17

F #: 355 caractères significatifs

Tout sur une seule ligne:

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"

Étendu:

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"

Question 18

SETL

165 caractères; Traduction de la solution 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;

Question 19

D2 (modèles): 331 370 400 + 17 caractères

(basé sur la solution Ruby.)

Comprimé:

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

Expliqué:

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

Comme nous ne pouvons pas passer de paramètres à partir de dmdl'entrée, il faut le faire dans le code. Prend en charge jusqu'à 99 clés seulement.

Question 20

Haskell: ~~212~~ ~~211~~ 208 caractères

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

Il suppose toujours des lettres compatibles ascii (en particulier, la séquence "@ABCDEFG"), mais ne nécessite plus Char.ord

Question 21

Rubis - 113 caractères

Fonctionne avec des arguments de ligne de commande

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

Rubis - 118 caractères

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

Question 22

PHP - 208 caractères

<?$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,~õ;

Doit être amélioré.

L'entrée doit être fournie dans la constante nommée PIANO.

Question 23

F # 414 386 372 caractères significatifs:

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

Oh, et un bonus, ce script gérera correctement "F # 372" - Je ne vous ennuierai pas en le collant ici cependant ...

System.Console.ReadLine () est une telle déception ...