È venerdì e sono stanco, quindi facciamolo in fretta! Non ricevere input, tuttavia dovresti ottenere tutte e tredici le diverse carte numerate in un mazzo standard di carte. Dovresti produrre 2 attraverso Ace (Suit agnostic).

Ogni carta ha una cima che è indicata con uno spazio e dieci _e un altro spazio .

La seconda riga dall'alto è indicata con a /e dieci spazi e a\

La terza riga è la stessa di tutte le righe di mezzo che esclude i caratteri che indicano che il valore della carta appare due spazi a destra (se in alto) o due spazi a sinistra (se in fondo) del bordo.

Ogni riga di mezzo è un semplice |e dieci spazi e uno in più|

Finalmente l'ultima riga è a \e dieci _e infine a/

Se il valore è composto da più cifre, la larghezza complessiva per altezza della carta non deve cambiare. (ovvero il 10 non allargherà i lati della carta)

Esempio di re:

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

9 Esempio

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

10 Esempio

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

Distribuiscili in ordine dal minimo al massimo (gli assi sono alti!).

Questo è code-golf, quindi vince il codice più corto.

Buon divertimento e buon fine settimana!

PowerShell v2 +, 120 116 114 108 byte

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

Costruisce un intervallo 2..10ed esegue la concatenazione di array con char-array JQKA. Lo inserisce in un ciclo |%{...}. Ad ogni iterazione, impostiamo $zuguale a un numero appropriato di spazi (in base al fatto che siamo a carta 10o meno), impostato $xsu caratteri di 10sottolineatura e impostato $ysu 10spazi.

Quindi, iniziamo i nostri posizionamenti. Sfrutteremo il valore predefinito Write-Outputper inserire una nuova riga tra gli elementi della pipeline, quindi dobbiamo solo mettere le cose sulla pipeline. Si noti che nella maggior parte dei casi, stiamo usando una nuova riga letterale piuttosto che chiudere e riaprire le nostre stringhe per salvare un paio di byte.

Il primo è solo $xcon due spazi, quindi $ycon due barre, quindi | $_$z|"il tubo, uno spazio, il numero appropriato di spazi e un altro tubo. Ciò costituisce la parte superiore delle carte fino alla linea del valore inclusa.

Dobbiamo un punto e virgola qui, poiché il prossimo utilizza un array. Il ,"|$y|"*5costruisce una stringa-array, con la virgola-operatore, del tubo con spazi - su uscita, ciascun elemento di questa matrice ottiene una nuova riga per libero.

Quindi, "|$z$_ |per la marcatura del valore inferiore, e infine $xcon le barre per la parte inferiore della carta.

Snippet di output

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 byte

Un byte salvato da Shebang

Questo potrebbe usare del lavoro ma eccolo qui:

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

Spiegazione

Facciamo un elenco di tutti i gradi in ordine utilizzando map(str,range(2,11). Quindi passiamo attraverso ciascuno dei ranghi e creiamo una carta.

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

Facciamo la parte superiore della carta:

o+v+"\n"

Quindi il grado va a sinistra:

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

Usiamo .ljustperché 10è lungo due e tutti gli altri sono uno largo.

Quindi stampiamo le 5 righe nel mezzo:

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

e il grado inferiore:

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

Infine stampiamo il fondo della carta:

"\\"+v+"/"

JavaScript (ES6), 151 byte

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

Perl, 128 117 111 byte

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

Le 6 newline letterali risparmiano 1 byte ciascuna. Questo non può essere eseguito direttamente dalla riga di comando a causa delle virgolette singole nelle righe 2 e 4 per salvare 1 byte non dovendo sfuggire a una barra rovesciata.

Modifica: ho messo Ace all'inizio, ma dovrebbe essere alla fine. Non cambia il conteggio dei byte.

Modifica 2: -11 byte: si è sbarazzato di alcune dichiarazioni non necessarie e ha aggiunto un'altra nuova riga letterale. Ora tutto viene emesso tramite una singola stampa.

Modifica 3: -5 byte grazie a @Ton Hospel. Ma per qualche motivo, sto ottenendo 111 byte anziché 112 a casa rispetto al lavoro, quindi vado con il numero di byte che il mio computer di casa mi sta dando.

PHP, 233 byte

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 byte

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

Provalo online!

-2 byte grazie a m-chrzan

Python 3.5, 110 byte

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

stampe

• Le prime due linee ' %s\n/%%11s\n'%u%'\\'dove si utrova'_'*10
• Le 7 linee centrali '| %-2s %2s |\n' , ognuna delle quali ha due slot di formattazione delle stringhe. Il primo e l'ultimo sono riempiti con il valore della carta e il resto con spazi per nessun effetto
• La linea di fondo '\% s /'% u

Le nuove funzionalità di decompressione di Python 3.5 sono utilizzate in due punti. L'elenco di etichette [*range(2,11),*'JQKA']scompone i numeri e le lettere in un elenco. E la tupla (c,*' '*12,c)disimballa dodici voci di spazi nel centro.

Scala, 161 byte

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

Lotto, 236 byte

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

Ho provato a giocare a golf in tre modi diversi, ma ogni volta ho finito con lo stesso numero di byte ...

05AB1E , 71 70 68 66 65 64 byte

Utilizza la codifica CP-1252 .

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

Link leggermente modificato in quanto …non funziona con ÿTIO atm.

Provalo online!

Spiegazione

TL¦"JQKA"S« spinge l'elenco [2,3,4,5,6,7,8,9,10,J,Q,K,A]

Quindi eseguiamo il ciclo su ogni valore di carta con v

ð'_Tשðcostruisce " __________ "
ðT×…/ÿ\costruisce "/ \"
9yg-ð×y"| ÿÿ|"Âcostruisce le 2 righe con i valori delle carte (la seconda riga è la prima invertita)
ðT×…|ÿ|5×costruisce 5 righe del modulo"| |"

Quindi noi

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

®…\ÿ/ costruisce la riga inferiore

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

V , 87 byte

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

Provalo online!

Poiché questo contiene alcuni non stampabili, ecco 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 byte

Spero di trovare un modo per accorciarlo un po 'di più.

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

Questo si avvale di printfripetere più caratteri e formattare tutto in modo piacevole.

Vecchia versione:

Non esattamente un pezzo di bellezza, ma funziona!

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

Grazie a Jörg Hülsermann per il rilevamento di un bug e per avermi permesso di utilizzare parte del suo codice, che lo ha ridotto di 4 byte! E per trovare un insetto fatale.

Rubino, 115 byte

Uso abbastanza semplice di printf.

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

Racchetta 327 byte

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

Ungolfed:

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

test:

(main)

Produzione:

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

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, questo è brutto e non molto efficiente, ma funziona .. Quello 10 come caso speciale con uno spazio prima nella parte superiore e dopo nella posizione inferiore si avvita davvero con tutti ..

Codice non testato e test:

Provalo qui.

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

Produzione:

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

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 risposta abbastanza competitiva in R questa volta per una sfida ascii-art e dovrebbe sicuramente essere giocabile a golf.

Provalo su R-violino

Ungolfed e spiegato

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'aspetto più interessante in cui vengono salvati pochi byte è l'assegnazione della terza riga:

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

Perché ci sono 8spazi in totale tra il personaggio che indica il valore della carta e il finale |(tranne per 10) che possiamo ripetere9 spazi e sottrarre il numero di caratteri nella carta attualmente stampata.

Memorizzando ogni carattere nella 3rdriga come proprio elemento nel vettore stringa, rè possibile invertire il vettore e riutilizzarlo per la 9thriga.

C #, 385 byte

La mia prima sfida ASCII Art - è stato divertente!

golfed:

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

Ungolfed:

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

In realtà , 91 byte

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

Provalo online!

Spiegazione

Parte 1: impostazione dell'elenco dei valori facciali:

"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: creazione delle carte (newline sostituita con \nper leggibilità):

;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