¡Es viernes y estoy cansado, así que hagamos uno rápido! No tome ninguna entrada, sin embargo, debe generar las trece cartas numeradas diferentes en una baraja de cartas estándar. Deberías enviar 2 a través de Ace (traje agnóstico).

Cada carta tiene una parte superior que se denota con un espacio y diez _y otro espacio .

La segunda fila desde la parte superior se denota con ay /diez espacios y un\

La tercera fila es la misma que todas las filas intermedias, excepto los caracteres que denotan que el valor de la tarjeta aparece dos espacios a la derecha (si está en la parte superior) o dos espacios a la izquierda (si está en la parte inferior) del borde.

Cada fila del medio es un simple |y diez espacios y uno más|

Finalmente la última línea es ay \diez _y finalmente un/

Si el valor es de varios dígitos, el ancho total por altura de la tarjeta no debería cambiar. (es decir, el 10 no ensanchará los lados de la tarjeta)

Rey Ejemplo:

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

9 Ejemplo

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

10 Ejemplo

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

Envíalos en orden de menor a mayor (¡los ases son altos!).

Este es el código de golf, por lo que gana el código más corto.

Diviértete y diviértete un fin de semana!

PowerShell v2 +, 120 116 114 108 bytes

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

Construye un rango 2..10y realiza una concatenación de matriz con char-array JQKA. Alimenta eso en un bucle |%{...}. Cada iteración, se establece $zigual a un número apropiado de espacios (en función de si estamos en la tarjeta 10o no), conjunto $xde 10guiones, y un conjunto $yde 10espacios.

Entonces, comenzamos nuestras colocaciones. Vamos a aprovechar el valor predeterminado Write-Outputpara insertar una nueva línea entre los elementos de la tubería, por lo que solo necesitamos obtener las cosas en la tubería. Tenga en cuenta que en la mayoría de los lugares, estamos usando una nueva línea literal en lugar de cerrar y volver a abrir nuestras cadenas para guardar un par de bytes.

El primero es solo $xcon dos espacios, luego $ycon dos barras, luego | $_$z|"la tubería, un espacio, el número apropiado de espacios y otra tubería. Esto forma la parte superior de las cartas hasta e incluyendo la línea de valor.

Tenemos que poner punto y coma aquí, ya que el siguiente usa una matriz. El ,"|$y|"*5construye una cadena de matriz, con la coma-operador, de la tubería con espacios - en la salida, cada elemento de esta matriz para crear una nueva línea de forma gratuita.

Luego, "|$z$_ |para la marca de valor inferior, y finalmente $xcon barras para la parte inferior de la tarjeta.

Fragmento de salida

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 bytes

Un byte guardado por Shebang

Esto podría usar algo de trabajo, pero aquí está:

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

Explicación

Hacemos una lista de todos los rangos en orden usando map(str,range(2,11). Luego recorremos cada uno de los rangos y hacemos una tarjeta.

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

Hacemos la parte superior de la tarjeta:

o+v+"\n"

Entonces el rango va a la izquierda:

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

Usamos .ljustporque 10son dos largos y todos los demás son uno ancho.

Luego imprimimos las 5 filas en el medio:

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

y el rango inferior:

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

Finalmente imprimimos la parte inferior de la tarjeta:

"\\"+v+"/"

JavaScript (ES6), 151 bytes

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

Perl, 128 117 111 bytes

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

Las 6 nuevas líneas literales ahorran 1 byte cada una. Esto no se puede ejecutar directamente desde la línea de comando debido a las comillas simples en las líneas 2 y 4 para ahorrar 1 byte al no tener que escapar de una barra diagonal inversa.

Editar: pongo Ace al principio, pero se supone que debe estar al final. No cambia el recuento de bytes.

Edición 2: -11 bytes: Eliminé algunas declaraciones innecesarias y agregué otra nueva línea literal. Ahora todo se genera a través de una sola impresión.

Edición 3: -5 bytes gracias a @Ton Hospel. Pero por alguna razón, obtengo 111 bytes en lugar de 112 en casa en comparación con el trabajo, así que voy con el recuento de bytes que me da la computadora de mi casa.

PHP, 233 bytes

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 bytes

/+/_____//*/# |
&//&/@@@@@|# //%/ |
\\\\++\\\/
//$/ ++
\\\/!\\\\
| //#/       //!/#   //@/|!|
/$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%

Pruébalo en línea!

-2 bytes gracias a m-chrzan

Python 3.5, 110 bytes

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

Huellas dactilares

• Las dos primeras líneas ' %s\n/%%11s\n'%u%'\\'donde uestá'_'*10
• Las 7 líneas centrales '| %-2s %2s |\n', cada una de las cuales tiene dos ranuras de formato de cadena. El primero y el último se llenan con el valor de la carta, y el resto con espacios sin efecto.
• El resultado final '\% s /'% u

Las nuevas características de desempaquetado de Python 3.5 se utilizan en dos lugares. La lista de etiquetas [*range(2,11),*'JQKA']desempaqueta los números y letras en una lista. Y, la tupla (c,*' '*12,c)desempaqueta doce entradas de espacios en el centro.

Scala, 161 bytes

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

Lote, 236 bytes

@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 \__________/

Intenté jugar al golf de tres maneras diferentes, pero terminé con el mismo número de bytes cada vez ...

05AB1E , 71 70 68 66 65 64 bytes

Utiliza la codificación CP-1252 .

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

Enlace ligeramente modificado, ya …que no funciona con ÿTIO atm.

Pruébalo en línea!

Explicación

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

Luego recorremos cada valor de tarjeta con v

ð'_Tשðconstruye " __________ "
ðT×…/ÿ\construye "/ \"
9yg-ð×y"| ÿÿ|"Âconstruye las 2 filas con valores de tarjeta (la segunda fila es la primera invertida)
ðT×…|ÿ|5×construye 5 filas del formulario"| |"

Entonces nosotros

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

®…\ÿ/ construye la fila inferior

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

V , 87 bytes

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

Pruébalo en línea!

Como esto contiene algunos no imprimibles, aquí hay 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 bytes

Con suerte, puedo encontrar una manera de acortar esto un poco más.

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,_);

Esto aprovecha printfpara repetir múltiples caracteres y formatear todo muy bien.

Versión antigua:

No es exactamente una pieza de belleza, ¡pero funciona!

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

Gracias a Jörg Hülsermann por detectar un error y por permitirme usar parte de su código, ¡eso lo redujo en 4 bytes! Y por encontrar un error fatal.

Ruby, 115 bytes

Uso bastante directo de printf.

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

Raqueta 327 bytes

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

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

Pruebas:

(main)

Salida:

 __________ 
/          \
| 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 bytes

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, esto es feo y no muy eficiente, pero funciona ... Eso 10como un caso especial con un espacio antes en la parte superior y después en la posición inferior realmente atornilla a todos ...

Sin codificar y código de prueba:

Pruébalo aquí.

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

Salida:

 __________ 
/          \
| 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 bytes

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="")}

Una respuesta bastante competitiva en R esta vez para un desafío ascii-art y definitivamente debería ser golfable.

Pruébalo en R-Fiddle

Desengañado y explicado

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
}

El aspecto más interesante donde se guardan algunos bytes es la asignación de la tercera fila:

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

Debido a que hay 8espacios en total entre el personaje que indica el valor de la carta y el final |(excepto 10) podemos repetir9 espacios y restar el número de caracteres en la tarjeta actualmente impresa.

Al almacenar cada carácter en la 3rdfila como su propio elemento en el vector de cadena r, podemos revertir el vector y reutilizarlo para la 9thfila.

C #, 385 bytes

Mi primer desafío de arte ASCII: ¡fue divertido!

Golfizado:

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

Sin 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 realidad , 91 bytes

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

Pruébalo en línea!

Explicación

Parte 1: configurar la lista de valores nominales:

"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

Parte 2: creación de las tarjetas (nueva línea reemplazada \npor legibilidad):

;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