C'est vendredi et je suis fatigué, alors faisons-en un rapide! Ne prenez aucune entrée, mais vous devez sortir les treize cartes numérotées différentes dans un jeu de cartes standard. Vous devez sortir 2 via Ace (Suit agnostic).

Chaque carte a un dessus qui est indiqué par un espace et dix _et un autre espace .

La deuxième ligne à partir du haut est indiquée par un /et dix espaces et un\

La troisième ligne est la même que toutes les lignes du milieu sauf les caractères indiquant la valeur de la carte apparaissent deux espaces à droite (si en haut) ou deux espaces à gauche (si en bas) du bord.

Chaque ligne du milieu est un simple |et dix espaces et un de plus|

Enfin, la dernière ligne est un \et dix _et enfin un/

Si la valeur est à plusieurs chiffres, la largeur totale en hauteur de la carte ne doit pas changer. (c'est-à-dire que le 10 n'élargira pas les côtés de la carte)

Exemple roi:

 __________ 
/          \
| K        |
|          |
|          |
|          |
|          |
|          |
|        K |
\__________/

9 Exemple

 __________ 
/          \
| 9        |
|          |
|          |
|          |
|          |
|          |
|        9 |
\__________/

10 Exemple

 __________ 
/          \
| 10       |
|          |
|          |
|          |
|          |
|          |
|       10 |
\__________/

Sortez-les dans l'ordre du plus petit au plus grand (les As sont élevés!).

C'est le code-golf donc le code le plus court l'emporte.

Amusez-vous et passez un week-end amusant!

PowerShell v2 +, 120 116 114 108 octets

2..10+[char[]]'JQKA'|%{$z=' '*(8-!($_-10));$x='_'*10;$y=' '*10;" $x 
/$y\
| $_$z|";,"|$y|"*5;"|$z$_ |
\$x/"}

Construit une plage 2..10et effectue la concaténation de tableau avec char-array JQKA. Alimente cela dans une boucle |%{...}. Chaque itération, nous définissons $zégal à un nombre approprié d'espaces (selon que nous sommes à la carte 10ou non), défini $xsur des 10traits de soulignement et défini $ysur des 10espaces.

Ensuite, nous commençons nos stages. Nous allons tirer parti de la valeur par défaut Write-Outputpour insérer une nouvelle ligne entre les éléments du pipeline, nous avons donc juste besoin de mettre les choses sur le pipeline. Notez que dans la plupart des endroits, nous utilisons une nouvelle ligne littérale plutôt que de fermer et de rouvrir nos chaînes pour économiser quelques octets.

Le premier est juste $xavec deux espaces, puis $yavec deux barres obliques, puis | $_$z|"le tuyau, un espace, le nombre approprié d'espaces et un autre tuyau. Cela forme le haut des cartes jusqu'à et y compris la ligne de valeur.

Nous devons mettre un point-virgule ici, car le suivant utilise un tableau. Le ,"|$y|"*5construit un tableau de chaînes, avec l'opérateur virgule, du tuyau avec des espaces - en sortie, chaque élément de ce tableau obtient une nouvelle ligne gratuitement.

Ensuite, le "|$z$_ |pour la marque de valeur inférieure, et enfin $xavec des barres obliques pour le bas de la carte.

Extrait de sortie

PS C:\Tools\Scripts\golfing> 2..10+[char[]]'JQKA'|%{$z=' '*(8,7)[$_-eq10];" $(($x='_'*10)) ";"/$(($y=' '*10))\";"| $_$z|";,"|$y|"*5;"|$z$_ |";"\$x/"}
 __________ 
/          \
| 2        |
|          |
|          |
|          |
|          |
|          |
|        2 |
\__________/
 __________ 
/          \
| 3        |
|          |
|          |
|          |
|          |
|          |
|        3 |
\__________/
 __________ 
/          \
| 4        |
...

Python, 161 160 156 149 149 octets

Un octet enregistré par Shebang

Cela pourrait nécessiter du travail, mais voici:

o=" ";v="_"*10
for x in map(str,range(2,11)+list("JKQA")):print o+v+"\n/",o*9+"\\\n|",x.ljust(8),"|"+("\n|"+o*10+"|")*5+"\n|",o*6+x.ljust(3)+"|\n\\"+v+"/"

Explication

Nous faisons une liste de tous les rangs dans l'ordre en utilisant map(str,range(2,11). Ensuite, nous parcourons chacun des rangs et faisons une carte.

print o+"_"*10+"\n/",o*9+"\\\n|",x.ljust(8),"|"+("\n|"+o*10+"|")*5+"\n|",o*6+x.ljust(3)+"|\n\\"+"_"*10+"/"

Nous faisons le haut de la carte:

o+v+"\n"

Ensuite, le rang va à gauche:

"/",o*9+"\\\n|",x.ljust(8),"|"

Nous utilisons .ljustcar 10est long et tous les autres sont larges.

Ensuite, nous imprimons les 5 lignes au milieu:

"|"+("\n|"+o*10+"|")*5+"\n|"

et le dernier rang:

"\n|",o*6+x.ljust(3)+"|\n"

Enfin, nous imprimons le bas de la carte:

"\\"+v+"/"

JavaScript (ES6), 151 octets

f=
_=>`2345678910JQKA`.replace(/.0?/g,s=>` __________
/          \\
| `+(s+=`   `+s).slice(0,4)+`     |
|     `.repeat(6)+s.slice(-4)+` |
\\__________/
`)
;
document.write('<pre>'+f());

Perl, 128 117 111 octets

map{printf$"."_"x10 ."
/".$"x10 .'\
| %-9s|
'.("|".$"x10 ."|
")x5 ."|%9s |
\\"."_"x10 ."/
",$_,$_}2..10,J,Q,K,A

Les 6 nouvelles lignes littérales économisent 1 octet chacune. Cela ne peut pas être exécuté directement à partir de la ligne de commande en raison des guillemets simples dans les lignes 2 et 4 afin d'économiser 1 octet sans avoir à échapper à une barre oblique inverse.

Edit: j'ai mis Ace au début, mais c'est censé être à la fin. Cela ne change pas le nombre d'octets.

Edit 2: -11 octets: Débarrassé de quelques déclarations inutiles et ajouté un autre saut de ligne littéral. Tout est maintenant sorti via un seul printf.

Edit 3: -5 octets grâce à @Ton Hospel. Mais pour une raison quelconque, je reçois 111 octets au lieu de 112 à la maison par rapport au travail, donc je vais avec le nombre d'octets que mon ordinateur personnel me donne.

PHP, 233 octets

foreach([2,3,4,5,6,7,8,9,10,J,Q,K,A]as$k){for($c="",$i=0;$i<10;$i++)$c.=str_pad($i?$i>1&$i<9?"|":($i<2?"/":"\\"):" ",11,$i%9?" ":_).($i?$i>1&$i<9?"|":($i<2?"\\":"/"):" ")."\n";$c[113]=$c[28]=$k;$k>9&&$c[29]=$c[113]=0&$c[112]=1;echo$c;}

///, 182 180 octets

/+/_____//*/# |
&//&/@@@@@|# //%/ |
\\\\++\\\/
//$/ ++
\\\/!\\\\
| //#/       //!/#   //@/|!|
/$2*2%$3*3%$4*4%$5*5%$6*6%$7*7%$8*8%$9*9%$10#|
@@@@@|#10 |
\\++\/
$J*J%$K*K%$Q*Q%$A*A%

Essayez-le en ligne!

-2 octets grâce à m-chrzan

Python 3.5, 110 octets

u='_'*10
for c in[*range(2,11),*'JQKA']:print(' %s\n/%%11s\n'%u%'\\'+'| %-6s%2s |\n'*7%(c,*' '*12,c)+'\%s/'%u)

Impressions

• Les deux premières lignes ' %s\n/%%11s\n'%u%'\\'où uest'_'*10
• Les 7 lignes du milieu '| %-2s %2s |\n' , chacune ayant deux emplacements de formatage de chaîne. Le premier et le dernier sont remplis avec la valeur de la carte, et le reste avec des espaces sans effet
• La ligne de fond '\% s /'% u

Les nouvelles fonctionnalités de déballage de Python 3.5 sont utilisées à deux endroits. La liste des étiquettes [*range(2,11),*'JQKA']décompresse les chiffres et les lettres en une seule liste. Et, le tuple (c,*' '*12,c)déballe douze entrées d'espaces au centre.

Scala, 161 octets

val a=" "*7
val u="_"*10
((2 to 10)++"JQKA")map(_+"")map{x=>val p=" "*(2-x.size)
s" $u \n/$a   \\\n| $x$p$a|\n" + s"|$a   |\n" * 5 + s"|$a$p$x |\n\\$u/\n"}

Lot, 236 octets

@echo off
for %%v in (2 3 4 5 6 7 8 9 10 J Q K A)do call:v %%v
exit/b
:v
set s=%1       %1
echo  __________
echo /          \
echo ^| %s:~0,8% ^|
for /l %%l in (1,1,5)do echo ^|          ^|
echo ^| %s:~-8% ^|
echo \__________/

J'ai essayé de jouer au golf de trois manières différentes, mais j'ai fini avec le même nombre d'octets à chaque fois ...

05AB1E , 71 70 68 66 65 64 octets

Utilise CP-1252 encodage .

TL¦"JQKA"S«vð'_TשððT×…/ÿ\9yg-ð×y"| ÿÿ|"ÂðT×…|ÿ|5×sT‡®…\ÿ/JTä»,

Lien légèrement modifié car …ne fonctionne pas avecÿ TIO atm.

Essayez-le en ligne!

Explication

TL¦"JQKA"S« pousse la liste [2,3,4,5,6,7,8,9,10,J,Q,K,A]

Nous bouclons ensuite sur chaque valeur de carte avec v

ð'_Tשðconstruit " __________ "
ðT×…/ÿ\construit "/ \"
9yg-ð×y"| ÿÿ|"Âconstruit les 2 lignes avec des valeurs de carte (la deuxième ligne est la première inversée)
ðT×…|ÿ|5× construit 5 lignes du formulaire"| |"

Ensuite nous

s     # move the 2nd card value row after the 5 "middle rows"
 T‡  # and replace 1 with 0 and vice versa

®…\ÿ/ construit la rangée du bas

J       # join everything into 1 string
 Tä     # split into 10 parts
   »,   # merge by newline and print with newline

V , 87 octets

i ±_ 
/± \Ypr|$.Y6P3|r2Lhhr2o\±_/
H8ñy}GP2j6j? _ñ2j$X6jxG"04p/9
rJn.nrQn,nrKn.nrAn.

Essayez-le en ligne!

Puisqu'il contient des éléments non imprimables, voici un hexdump:

0000000: 6920 b15f 200a 2fb1 205c 1b59 7072 7c24  i ._ ./. \.Ypr|$
0000010: 2e59 3650 337c 7232 4c68 6872 326f 5cb1  .Y6P3|r2Lhhr2o\.
0000020: 5f2f 0a1b 4838 f179 7d47 5032 6a01 366a  _/..H8.y}GP2j.6j
0000030: 013f 205f f132 6a24 5836 6a78 4722 3034  .? _.2j$X6jxG"04
0000040: 702f 390a 724a 6e2e 6e72 516e 2c6e 724b  p/9.rJn.nrQn,nrK
0000050: 6e2e 6e72 416e 2e                        n.nrAn.

PHP, 135 131 158 134 octets

Si tout va bien, je peux trouver un moyen de raccourcir un peu plus.

foreach([2,3,4,5,6,7,8,9,10,J,Q,K,A]as$C)printf(" %'_9s
/%12s| %-8s|%s
|%8s |
\\%'_9s/
",_,'\
',$C,str_repeat('
|         |',5),$C,_);

Cela permet de printfrépéter plusieurs caractères et de tout formater correctement.

Ancienne version:

Pas exactement un morceau de beauté, mais ça marche!

$L=__________;$S='        ';foreach([2,3,4,5,6,7,8,9,10,J,Q,K,A]as$C)echo" $L
/  $S\
| $C".($P=substr($S,$C>9))."|
",str_repeat("|  $S|
",5),"|$P$C |
\\$L/
";

Merci à Jörg Hülsermann d' avoir détecté un bug et de m'avoir permis d'utiliser une partie de son code, qui l'a réduit de 4 octets! Et pour avoir trouvé un bug fatal.

Rubis, 115 octets

Utilisation assez simple de printf.

([*(?2.."10")]+%w{J Q K A}).map{|e|printf" #{u=?_*10} 
/%11s
| %-9s|
#{(?|+' '*10+"|
")*5}|%9s |
\\#{u}/
",?\\,e,e}

Raquette 327 octets

(let*((ms make-string)(p #\space)(e? equal?)(sa string-append)(f(λ(s)(display(sa" "(ms 10 #\_)" \n""/"(ms 10 p)"\\\n""| "s
(ms(if(e? s"10")7 8)p)"|\n"(apply sa(for/list((i 6))"|          |\n"))"| "(ms(if(e? s"10")6 7)p)s" |\n"
"\\"(ms 10 #\_)"/\n")))))(for((i(range 2 11)))(f(number->string i)))(for((i'("J""Q""K""A")))(f i)))

Non golfé:

(define (main)
(let* ((ms make-string)
       (e? equal?)
       (sa string-append)
      (f(lambda(s)
  (display
   (sa
    " "
    (ms 10 #\_)
    " \n"
    "/"
    (ms 10 #\space)
    "\\\n"
    "| " s   (ms (if(e? s "10") 7 8) #\space)   "|\n"
    (apply sa (for/list ((i 6)) "|          |\n"))
    "| "  (ms (if(e? s "10") 6 7) #\space)  s " |\n"
    "\\" (ms 10 #\_) "/\n")
   ))))
(for ((i(range 2 11)))
  (f (number->string i)))
(for ((i '("J" "Q" "K" "A")))
  (f i))
))

Essai:

(main)

Production:

 __________ 
/          \
| 2        |
|          |
|          |
|          |
|          |
|          |
|          |
|        2 |
\__________/
 __________ 
/          \
| 3        |
|          |
|          |
|          |
|          |
|          |
|          |
|        3 |
\__________/
 __________ 
/          \
| 4        |
|          |
|          |
|          |
|          |
|          |
|          |
|        4 |
\__________/
 __________ 
/          \
| 5        |
|          |
|          |
|          |
|          |
|          |
|          |
|        5 |
\__________/
 __________ 
/          \
| 6        |
|          |
|          |
|          |
|          |
|          |
|          |
|        6 |
\__________/
 __________ 
/          \
| 7        |
|          |
|          |
|          |
|          |
|          |
|          |
|        7 |
\__________/
 __________ 
/          \
| 8        |
|          |
|          |
|          |
|          |
|          |
|          |
|        8 |
\__________/
 __________ 
/          \
| 9        |
|          |
|          |
|          |
|          |
|          |
|          |
|        9 |
\__________/
 __________ 
/          \
| 10       |
|          |
|          |
|          |
|          |
|          |
|          |
|       10 |
\__________/
 __________ 
/          \
| J        |
|          |
|          |
|          |
|          |
|          |
|          |
|        J |
\__________/
 __________ 
/          \
| Q        |
|          |
|          |
|          |
|          |
|          |
|          |
|        Q |
\__________/
 __________ 
/          \
| K        |
|          |
|          |
|          |
|          |
|          |
|          |
|        K |
\__________/
 __________ 
/          \
| A        |
|          |
|          |
|          |
|          |
|          |
|          |
|        A |
\__________/

Java 7, 287 octets

String c(){String r="",l="__________",c=(" "+l+" \n/s\\\n| z       |\nxxxxxx|       y|\n\\"+l+"/\n").replace("x","|s|\n").replace("s","          ");for(int i=0;i++<13;r+=c.replace("z",i==10?"10":(l=i<2?"A ":i>12?"K ":i>11?"Q ":i>10?"J ":i+" ")).replace("y",i==10?"10 ":" "+l));return r;}

Ok, c'est moche et pas très efficace, mais ça marche .. C'est 10comme cas particulier avec un espace avant en haut et après en bas vraiment vis avec tout le monde ..

Code non testé et testé:

Essayez-le ici.

class M{
  static String c(){
    String r = "",
           l = "__________",
           c = (" " + l + " \n/s\\\n| z       |\nxxxxxx|       y|\n\\" + l + "/\n")
                 .replace("x", "|s|\n")
                 .replace("s", "          ");
    for(int i = 0; i++ < 13; r += c
        .replace("z", i == 10
                       ? "10"
                       : (l = i < 2
                               ? "A "
                               : i > 12
                                  ? "K "
                                  : i > 11
                                     ? "Q "
                                     : i > 10
                                        ? "J "
                                        : i+" "))
        .replace("y", i == 10
                       ? "10 "
                       : " "+l));
    return r;
  }

  public static void main(String[] a){
    System.out.println(c());
  }
}

Production:

 __________ 
/          \
| A        |
|          |
|          |
|          |
|          |
|          |
|          |
|        A |
\__________/
 __________ 
/          \
| 2        |
|          |
|          |
|          |
|          |
|          |
|          |
|        2 |
\__________/
 __________ 
/          \
| 3        |
|          |
|          |
|          |
|          |
|          |
|          |
|        3 |
\__________/
 __________ 
/          \
| 4        |
|          |
|          |
|          |
|          |
|          |
|          |
|        4 |
\__________/
 __________ 
/          \
| 5        |
|          |
|          |
|          |
|          |
|          |
|          |
|        5 |
\__________/
 __________ 
/          \
| 6        |
|          |
|          |
|          |
|          |
|          |
|          |
|        6 |
\__________/
 __________ 
/          \
| 7        |
|          |
|          |
|          |
|          |
|          |
|          |
|        7 |
\__________/
 __________ 
/          \
| 8        |
|          |
|          |
|          |
|          |
|          |
|          |
|        8 |
\__________/
 __________ 
/          \
| 9        |
|          |
|          |
|          |
|          |
|          |
|          |
|        9 |
\__________/
 __________ 
/          \
| 10       |
|          |
|          |
|          |
|          |
|          |
|          |
|       10 |
\__________/
 __________ 
/          \
| J        |
|          |
|          |
|          |
|          |
|          |
|          |
|        J |
\__________/
 __________ 
/          \
| Q        |
|          |
|          |
|          |
|          |
|          |
|          |
|        Q |
\__________/
 __________ 
/          \
| K        |
|          |
|          |
|          |
|          |
|          |
|          |
|        K |
\__________/

R, 175 octets

for(x in c(2:10,"J","Q","K","A")){r=c("|"," ",x,rep(" ",9-nchar(x)),"|");cat(" __________ \n/          \\\n",r,"\n",rep("|          |\n",5),rev(r),"\n\\__________/\n",sep="")}

Une réponse assez compétitive en R cette fois pour un défi d'ascii-art et devrait certainement être jouable au golf.

Essayez-le sur R-fiddle

Non golfé et expliqué

for(x in c(2:10,"J","Q","K","A")){          # For each card in vector 1,...,10,J,Q,K,A
    r=c("|"," ",x,rep(" ",9-nchar(x)),"|")  # Create variable for 3rd row called "r".
    ;cat(" __________ \n/          \\\n",   # Print: hardcoded top two rows,
    r,"\n",                                 # 3rd row,
    rep("|          |\n",5),                # Repeat middle section 5 times,
    rev(r),                                 # Reversed 3rd row,
    "\n\\__________/\n",                    # Hardcoded bottom row
    sep="")                                 # Set separator to empty string
}

L'aspect le plus intéressant où quelques octets sont enregistrés est l'affectation de la troisième ligne:

r=c("|"," ",x,rep(" ",9-nchar(x)),"|")

Parce qu'il y a des 8espaces au total entre le caractère indiquant la valeur de la carte et la finale |(sauf pour10 ), nous pouvons répéter les 9espaces et soustraire le nombre de caractères dans la carte actuellement imprimée.

En stockant chaque caractère de la 3rdligne comme son propre élément dans le vecteur chaîne, rnous pouvons inverser le vecteur et le réutiliser pour la 9thligne.

C #, 385 octets

Mon premier défi ASCII Art - c'était amusant!

Golfé:

string D(){var d=new string[15];for(int i=2;i<15;i++){var a=i>10?new Dictionary<int,string>(){{ 11,"J"},{12,"Q"},{13,"K"},{14,"A"},}[i]:i+"";var r="|          |";d[i]=string.Join("\n",new string[]{" __________",@"/          \",a.Length>1?"| "+a+"       |":"| "+a+"        |",r,r,r,r,r,a.Length>1?"|       " + a +" |" : "|        "+a+" |",@"\__________/"});}return string.Join("\n",d);}

Non golfé:

public string D()
{
  var d = new string[15];

  for (int i = 2; i < 15; i++)
  {
    var a = i > 10 ? new Dictionary<int, string>() {
    { 11, "J" },
    { 12, "Q" },
    { 13, "K" },
    { 14, "A" },
    }[i] 
      : i+"";

    var r = "|          |";

    d[i] = string.Join("\n", new string[] {
      " __________",
      @"/          \",
      a.Length > 1 ? "| " + a + "       |" : "| " + a + "        |",
      r,
      r,
      r,
      r,
      r,
      a.Length > 1 ? "|       " + a +" |" : "|        " + a +" |",
      @"\__________/"});
  }

  return string.Join("\n", d);
}

En fait , 91 octets

"JQKA"#9⌐2x+`;k' ;'_9u*@++'\' 9u*'/++"| {:<9}|"5'|;' 9u*@++n"|{:>9} |"'/'_9u*'\++kp@'
jf`Mi

Essayez-le en ligne!

Explication

Partie 1: établir la liste des valeurs faciales:

"JQKA"#9⌐2x+`PART 2 CODE`Mi
       9⌐2x                  range(2,11) ([2, 10])
"JQKA"#    +                 extend with ["J", "Q", "K", "A"]
            `PART 2 CODE`M   do Part 2 for each item in list
                          i  flatten resulting list and implicitly print

Partie 2: création des cartes (nouvelle ligne remplacée par \npour plus de lisibilité):

;k' ;'_9u*@++'\' 9u*'/++"| {:<9}|"5'|;' 9u*@++n"|{:>9} |"'/'_9u*'\++kp@'\njf
;k                                                                            duplicate the face value, push both copies to a list
  ' ;'_9u*@++                                                                 construct the top line
             '\' 9u*'/++                                                      construct the second line
                        "| {:<9}|"                                            create a format string to place the value in a left-aligned 9-width field in the top left of the card, one space away from the edge
                                  5'|;' 9u*@++n                               create 5 copies of the blank middle section
                                               "|{:>9} |"                     like before, but right-align the face value
                                                         '/'_9u*'/++          construct the bottom of the card
                                                                    kp@'\nj   push entire stack to a list, pop the list containing the face values out of that list, and join the rest (the card strings) with newlines
                                                                           f  format the card with the face values