Es ist Freitag und ich bin müde, also lass uns schnell einen machen! Nehmen Sie keine Eingabe vor, aber Sie sollten alle dreizehn Karten mit unterschiedlichen Nummern in einem Standardkartenstapel ausgeben. Sie sollten 2 durch Ace (Suit Agnostic) ausgeben.

Jede Karte hat eine Oberseite, die mit einem Feld und zehn _und einem anderen Feld gekennzeichnet ist .

Die zweite Reihe von oben ist mit a /und zehn Leerzeichen und a gekennzeichnet\

Die dritte Zeile ist identisch mit allen mittleren Zeilen, außer dass die Zeichen, die den Kartenwert angeben, zwei Leerzeichen rechts (oben) oder zwei Leerzeichen links (unten) am Rand erscheinen.

Jede mittelgroße Reihe ist eine einfache |und zehn Leerzeichen und ein weiteres|

Schließlich ist die letzte Zeile a \und zehn _und schließlich a/

Wenn der Wert mehrstellig ist, sollte sich die Gesamtbreite nach Höhe der Karte nicht ändern. (dh die 10 macht die Kartenseiten nicht breiter)

König Beispiel:

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

9 Beispiel

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

10 Beispiel

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

Gib sie in der Reihenfolge vom kleinsten zum größten aus (Asse sind hoch!).

Das ist Code-Golf, also gewinnt der kürzeste Code.

Viel Spaß und ein schönes Wochenende!

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

Erstellt einen Bereich 2..10und führt die Array-Verkettung mit char-array durch JQKA. Füttert das in eine Schleife |%{...}. Jede Iteration setzten wir $zgleich eine entsprechende Anzahl von Räumen (je nachdem , ob wir auf Karte sind 10oder nicht), Satz $xzu 10Unterstrichen und Satz $yzu 10Räumen.

Dann beginnen wir mit unseren Praktika. Wir werden die Standardeinstellung nutzen Write-Output, um eine neue Zeile zwischen Pipeline-Elementen einzufügen, also müssen wir nur die Inhalte in die Pipeline aufnehmen. Beachten Sie, dass wir in den meisten Fällen einen wörtlichen Zeilenumbruch verwenden, anstatt unsere Zeichenfolgen zu schließen und erneut zu öffnen, um ein paar Bytes zu sparen.

Das erste ist nur $xmit zwei Leerzeichen, dann $ymit zwei Schrägstrichen, dann der | $_$z|"Pipe, einem Leerzeichen, der entsprechenden Anzahl von Leerzeichen und einer weiteren Pipe. Dies bildet die Oberseite der Karten bis einschließlich der Wertelinie.

Wir müssen hier ein Semikolon setzen, da der nächste ein Array verwendet. Das ,"|$y|"*5Konstruiert ein String-Array mit dem Komma-Operator der Pipe mit Leerzeichen - bei der Ausgabe erhält jedes Element dieses Arrays kostenlos eine neue Zeile.

Dann die "|$z$_ |Markierung für den unteren Wert und schließlich $xSchrägstriche für den unteren Kartenrand.

Ausgabefragment

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

Ein Byte von Shebang gespeichert

Dies könnte etwas Arbeit gebrauchen, aber hier ist es:

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

Erläuterung

Wir machen eine Liste aller Ränge in der Reihenfolge mit map(str,range(2,11). Dann durchlaufen wir die einzelnen Ränge und machen eine Karte.

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

Wir machen den Anfang der Karte:

o+v+"\n"

Dann geht der Rang nach links:

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

Wir verwenden, .ljustweil 10zwei lang ist und alle anderen eine Breite haben.

Dann drucken wir die 5 Zeilen in der Mitte:

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

und der unterste Rang:

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

Zum Schluss drucken wir den unteren Rand der Karte:

"\\"+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 Bytes

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

Die 6 wörtlichen Zeilenumbrüche sparen jeweils 1 Byte. Dies kann aufgrund der einfachen Anführungszeichen in den Zeilen 2 und 4 nicht direkt von der Befehlszeile aus ausgeführt werden, um 1 Byte zu sparen, da kein Backslash verwendet werden muss.

Edit: Ich habe Ace am Anfang gesetzt, aber es soll am Ende sein. Die Byteanzahl wird nicht geändert.

Edit 2: -11 Bytes: Einige unnötige Anweisungen wurden entfernt und eine weitere wörtliche Newline hinzugefügt. Alles wird jetzt über einen einzigen Ausdruck ausgegeben.

Bearbeiten Sie 3: -5 Bytes dank @Ton Hospel. Aber aus irgendeinem Grund erhalte ich zu Hause 111 Bytes anstatt 112 im Vergleich zur Arbeit, also gehe ich mit der Byteanzahl um, die mir mein Heimcomputer gibt.

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%

Probieren Sie es online!

-2 Bytes dank 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)

Druckt

• Die beiden obersten Zeilen ' %s\n/%%11s\n'%u%'\\' wo uist'_'*10
• Die mittleren 7 Zeilen '| %-2s %2s |\n' , von denen jede zwei Zeichenfolge-Formatierungsschlitze hat. Der erste und der letzte werden mit dem Kartenwert gefüllt, der Rest mit Leerzeichen, die keine Wirkung haben
• Die unterste Zeile '\% s /'% u

Die neuen Entpackungsfunktionen von Python 3.5 werden an zwei Stellen verwendet. Die Liste der Etiketten [*range(2,11),*'JQKA']packt die Zahlen und Buchstaben in eine Liste. Und das Tupel (c,*' '*12,c)packt zwölf Einträge von Leerzeichen in die Mitte aus.

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

Batch, 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 \__________/

Ich habe es auf drei verschiedene Arten versucht, habe aber jedes Mal die gleiche Anzahl von Bytes erhalten ...

05AB1E , 71 70 68 66 65 64 Bytes

Verwendet die CP-1252- Codierung.

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

Leicht modifizierter Link, wie …er bei ÿTIO atm nicht funktioniert .

Probieren Sie es online!

Erläuterung

TL¦"JQKA"S« drückt die Liste [2,3,4,5,6,7,8,9,10,J,Q,K,A]

Wir durchlaufen dann jeden Kartenwert mit v

ð'_Tשðconstructs " __________ "
ðT×…/ÿ\constructs "/ \"
9yg-ð×y"| ÿÿ|"Âkonstruiert die 2 Zeilen mit Kartenwerten (die zweite Zeile ist die erste umgekehrt)
ðT×…|ÿ|5×konstruiert 5 Zeilen des Formulars"| |"

Dann wir

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

®…\ÿ/ konstruiert die unterste Reihe

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.

Probieren Sie es online!

Da dies einige nicht druckbare Dateien enthält, ist hier ein 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

Ich hoffe, dass ich einen Weg finden kann, dies ein wenig zu verkürzen.

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

Dies nutzt den Vorteil printf, mehrere Zeichen zu wiederholen und alles schön zu formatieren.

Alte Version:

Nicht gerade ein Stück Schönheit, aber funktioniert!

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

Vielen Dank an Jörg Hülsermann für das Erkennen eines Fehlers und die Erlaubnis , einen Teil seines Codes zu verwenden, der ihn um 4 Byte reduziert hat ! Und um einen tödlichen Fehler zu finden.

Ruby, 115 Bytes

Ziemlich unkomplizierte Verwendung von printf.

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

Schläger 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)))

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

Testen:

(main)

Ausgabe:

 __________ 
/          \
| 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, das ist hässlich und nicht sehr effizient, aber es funktioniert .. Das 10als Sonderfall mit einem Leerzeichen vor oben und nach unten schraubt wirklich jeder mit ..

Ungolfed & Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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

Diesmal eine ziemlich konkurrenzfähige Antwort in R für eine Herausforderung im Ascii-Art-Bereich und sollte auf jeden Fall golffähig sein.

Probieren Sie es auf R-Geige

Ungolfed und erklärte

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
}

Der interessanteste Aspekt, bei dem einige Bytes gespeichert werden, ist die Zuweisung der dritten Zeile:

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

Weil es 8zwischen dem Zeichen, das den Kartenwert angibt, und dem Schlusszeichen insgesamt Leerzeichen gibt |(mit Ausnahme von10 ), können wir wiederholen9 Leerzeichen und die Anzahl der Zeichen auf der aktuell gedruckten Karte abziehen.

Durch Speichern jedes Zeichens in der 3rdZeile als eigenes Element im Zeichenfolgenvektor rkönnen wir den Vektor umkehren und für die 9thZeile wiederverwenden .

C #, 385 Bytes

Meine erste ASCII Art Challenge - es hat Spaß gemacht!

Golf gespielt:

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

Eigentlich 91 Bytes

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

Probieren Sie es online!

Erläuterung

Teil 1: Aufstellung der Liste der Nennwerte:

"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

Teil 2: Erstellen der Karten (Zeilenumbruch aus Gründen der \nLesbarkeit durch ersetzt):

;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