Gib ein ASCII-Deck aus

13

Es gab noch nie eine endgültige ASCII-Karten-Herausforderung für AFAIK. Verwenden Sie also das folgende ASCII-Kartenspiel:

.------..------..------..------..------..------..------..------..------..------..------..------..------.
|2.--. ||3.--. ||4.--. ||5.--. ||6.--. ||7.--. ||8.--. ||9.--. ||T.--. ||J.--. ||Q.--. ||K.--. ||A.--. |
| (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) |
| :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: |
| '--'2|| '--'3|| '--'4|| '--'5|| '--'6|| '--'7|| '--'8|| '--'9|| '--'T|| '--'J|| '--'Q|| '--'K|| '--'A|
'------''------''------''------''------''------''------''------''------''------''------''------''------'
.------..------..------..------..------..------..------..------..------..------..------..------..------.
|2.--. ||3.--. ||4.--. ||5.--. ||6.--. ||7.--. ||8.--. ||9.--. ||T.--. ||J.--. ||Q.--. ||K.--. ||A.--. |
| :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: |
| :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: |
| '--'2|| '--'3|| '--'4|| '--'5|| '--'6|| '--'7|| '--'8|| '--'9|| '--'T|| '--'J|| '--'Q|| '--'K|| '--'A|
'------''------''------''------''------''------''------''------''------''------''------''------'
.------..------..------..------..------..------..------..------..------..------..------..------..------.
|2.--. ||3.--. ||4.--. ||5.--. ||6.--. ||7.--. ||8.--. ||9.--. ||T.--. ||J.--. ||Q.--. ||K.--. ||A.--. |
| :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: |
| (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) |
| '--'2|| '--'3|| '--'4|| '--'5|| '--'6|| '--'7|| '--'8|| '--'9|| '--'T|| '--'J|| '--'Q|| '--'K|| '--'A|
'------''------''------''------''------''------''------''------''------''------''------''------''------'
.------..------..------..------..------..------..------..------..------..------..------..------..------.
|2.--. ||3.--. ||4.--. ||5.--. ||6.--. ||7.--. ||8.--. ||9.--. ||T.--. ||J.--. ||Q.--. ||K.--. ||A.--. |
| :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): |
| ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() |
| '--'2|| '--'3|| '--'4|| '--'5|| '--'6|| '--'7|| '--'8|| '--'9|| '--'T|| '--'J|| '--'Q|| '--'K|| '--'A|
'------''------''------''------''------''------''------''------''------''------''------''------''------'

Nehmen Sie zwei ganze Zahlen pund qals Eingabe; Wo pist die Anzahl der Spieler und qwie viele Karten bekommt jeder Spieler?

  • Das Kartenspiel wird zufällig gemischt (dies ist nicht eindeutig, bedeutet jedoch, dass alle Karten mit gleicher Wahrscheinlichkeit einmal überall auftauchen müssen).
  • Gib 1 Runde Karten pro Spieler aus und gib jede Reihe eine qReihe von pKarten aus.

Regeln:

  • Die Ergebnisse sollten gleichmäßig zufällig sein, und jede Karte sollte überall gleich wahrscheinlich erscheinen.
  • Es ist garantiert, dass 0 < p*q <= 52 and p < 10Sie möglicherweise undefiniertes Verhalten für Szenarien haben, in denen dies nicht erfüllt ist.
  • Sie sollten qKartenreihen mit pKarten pro Reihe ausgeben .
  • Jede Spalte sollte durch | (ein von Leerzeichen umgebenes Pipe-Zeichen) getrennt werden. Wenn Sie ein anderes Zeichen als dieses wählen, erklären Sie, warum. Die umgebenden Leerzeichen sind hier NICHT optional.
  • Jede Zeile muss 1 oder mehr Zeilenumbrüche enthalten, mehr als einer ist zulässig, 0 ist nicht zulässig (1 Zeile bedeutet standardmäßig den Zeilenumbruch).
  • Jede Zeile sollte mit dem Spieler, dem sie gehört, im Format "Spieler N" beschriftet sein (0 oder 1-indiziert ist in Ordnung).
  • Keine Karte darf mehr als einmal auftauchen.
  • T ist für zehn.

Beispiele:

Funktion ( p=1,q=1):

Player 1 # Can also be 0.
.------.
|2.--. |
| (\/) |
| :\/: |
| '--'2|
'------'

Funktion ( p=2,q=1):

Player 1 | Player 2 # Can also be "Player 0 | Player 1"
.------. | .------.
|2.--. | | |T.--. |
| (\/) | | | (\/) |
| :\/: | | | :\/: |
| '--'2| | | '--'T|
'------' | '------'

Funktion ( p=2,q=2):

Player 1 | Player 2 # Can also be "Player 0 | Player 1"
.------. | .------.
|J.--. | | |3.--. |
| (\/) | | | :/\: |
| :\/: | | | :\/: |
| '--'J| | | '--'3|
'------' | '------'
.------. | .------.
|8.--. | | |6.--. |
| :(): | | | :/\: |
| ()() | | | (__) |
| '--'8| | | '--'6|
'------' | '------'

Künstlerische Anerkennung für eine Schriftart unter: http://patorjk.com/software/taag

code-golf ascii-art random card-games Magic Octopus Urn
quelle
5
Werden Sie viele Kartenherausforderungen aus den Karten veröffentlichen, die Sie unter patorjk.com/software/taag gefunden haben ?
1
Soooo ... Können wir diese Seite benutzen, um das Ergebnis auszugeben ???
J42161217
1
Ich meine: Kann ich ein Programm erstellen , das patorjk.com/software/taag/... für Ihren letzten Testfall ausgibt ?
J42161217
5
Also, Each row must have 1 or more newlines inbetween them, more than one is acceptable, 0 is not.... Aber Ihre Testfälle haben keine Zeilenumbrüche zwischen den Karten.
Totalhuman
1
Bei ASCII-Karten gab es fast eine Herausforderung: Die von mir gepostete Spielzeit .
Sergiol

Antworten:

6

Charcoal , 142 133 125 Bytes

ＮθＦＮ«Ｆ¬¬ι«→↑×⁶θ| »Player ＩιＦθ«↙↓.↓⁴←'←⁶↑'↑⁴.Ｐ⁶↓≔‽⁵²εＷ№υε≔‽⁵²ε⊞υε≔§”w↘τ[⁵ＰkxτG”εδδ.--.¶✂”{➙aＥTê；s∨Hμ⁼⎚↑Ｚ～ＳÀd～⌀Ｔê”﹪ε⁴φ⁴'--'δ↘

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: 9 Bytes durch Verbesserung meines Zufallsstichprobencodes gespeichert. Sparte weitere 8 Bytes, indem ich meinen Code für den Anzugsdruck verbesserte. Erläuterung:

Ｎθ

Lesen Sie die Anzahl der Karten in q.

ＦＮ«

Schleife über jeden Spieler.

Ｆ¬¬ι«→↑×⁶θ| »

Wenn dies nicht der erste Spieler ist, drucken Sie die vertikale Linie zwischen dem vorherigen und diesem Spieler.

Player Ｉι

Spielernummer drucken.

Ｆθ«

Schleife über jede Karte.

↙↓.↓⁴←'←⁶↑'↑⁴.Ｐ⁶↓

Drucken Sie die Kartenkante.

≔‽⁵²εＷ№υε≔‽⁵²ε⊞υε

Wählen Sie eine Karteikarte aus, die noch nicht ausgewählt wurde, und fügen Sie sie der Liste der ausgewählten Kartenindizes hinzu.

≔§”w↘τ[⁵ＰkxτG”εδδ

Wählen Sie den Kartenrang aus und drucken Sie ihn aus, indem Sie ihn zyklisch in eine Reihe gültiger Kartenränge indexieren ( 2-9, T, J, Q, K, A).

.--.¶

Drucken Sie die Oberseite des Anzugs.

✂”{➙aＥTê；s∨Hμ⁼⎚↑Ｚ～ＳÀd～⌀Ｔê”﹪ε⁴φ⁴

Drucken Sie die Mitte des Anzugs, indem Sie ihn in eine Schnur schneiden. Der Slice beginnt bei der Karteikarte Modulo 4 und nimmt jedes vierte Zeichen auf, bis die Zeichenfolge abgelaufen ist (oder das f= 1000ste Zeichen erreicht ist). Da 4 und 13 Coprime sind, ist sichergestellt, dass alle 52 Karten möglich sind.

'--'δ↘

Drucken Sie den unteren Teil der Farbe und eine Kopie des Ranges aus und bewegen Sie sich dann zu einem Punkt, der nicht zu weit von der Kopie des Ranges, dem Beginn der nächsten Karte oder dem Beginn der Trennlinie für das Symbol entfernt ist nächster Spieler.

Neil
quelle
Als ich das im Sandkasten sah, war es eine große Herausforderung, das Deck zu drucken, was mich 102 Bytes gekostet hat: Online ausprobieren! Link ist eine ausführliche Version des Codes.
Neil
3

Python 2 , 357 Bytes

from random import*
p,q=input()
A,V=':/\:',':\/:'
c=sample([(""".------.
|%s.--. |
| %s |
| %s |
| '--'%s|
'------'"""%(n,s,t,n)).split('\n')for s,t in('(\/)',V),(A,V),(A,'(__)'),(':():','()()')for n in'123456789TJQKA'],p*q)
print' | '.join('Player '+`i`for i in range(p))
for i in range(0,p*q,p):print'\n'.join(map(' | '.join,zip(c[i:i+p][0],c[i:i+p][1])))

Probieren Sie es online!

Ich habe keine Ahnung.

total menschlich
quelle
3

Jelly , 126 Bytes

³‘Ḷj“×ṁẹHY»;⁶¤ṫ5W;
2r9;“TJQKA”
“¡ẏ%TZ=ẹaɦAY’ṃ“(\/)_:”s4s2
“E¬ƭḊHẈḢ“ðİ“|e*Ḳ?BḤ’ṃ“. -|1¶'”żÐ€¢FỴ$€p2£j/€Ẋ
¢ssḢµṣ€”1Zj€“ | ”Yµ€ÑY

Probieren Sie es online!

fireflame241
quelle
3

JavaScript (ES6), 328 ... 312 Byte

Übernimmt Eingaben in der Currying-Syntax (p)(q). Spieler sind 0-indiziert.

p=>g=(q,i=p*q*6,d=[...Array(52).keys(a=`:\\/:,(__),()(),(\\/),:/\\:,:():, | ,
,.3.,|0.--. |,| 1 |,| 2 |,| '--'0|,'3',Player 4`.split`,`)].sort(_=>Math.random()-.5))=>i--+p?g(q,i,d)+a[i%p?6:7]+a[i<0?14:i/p%6|8].replace(/\d/,c=>['TJQKA'[j=x>>2]||j-3,a['3454'[x&=3]],a[x%3],'------',p+i][c],x=d[i%p+p*(i/p/6|0)]):''

Demo

Code-Snippet anzeigen

Wie?

Dies ist eine rekursive Funktion, die die Ausgabe von unten nach oben erstellt. Während des Hauptteils, in dem die Karten gezogen werden, iwird auf initialisiert p*q*6und dekrementiert, bis es erreicht ist 0. Wir zeichnen dann den Header, indem wir ihn weiter dekrementieren, ibis er erreicht ist -p.

Die ASCII-Grafik ist in kleine Teile aufgeteilt, die im Array gespeichert sind a[]. In der folgenden Tabelle wird der Inhalt von beschrieben a[], wodurch der Rest des Codes verständlicher wird.

 Index | Content    | Description
-------+------------+------------------------------------------------
    0  | ":\\/:"    | bottom of 'diamonds' and 'hearts'
    1  | "(__)"     | bottom of 'spades'
    2  | "()()"     | bottom of 'clubs'
    3  | "(\\/)"    | top of 'hearts'
    4  | ":/\\:"    | top of 'diamonds' and 'spades'
    5  | ":():"     | top of 'clubs'
    6  | " | "      | player separator
    7  | "\n"       | line-feed
    8  | ".3."      | card row #1, "3" --> "------"
    9  | "|0.--. |" | card row #2, "0" --> symbol of card value
   10  | "| 1 |"    | card row #3, "1" --> top of color ASCII art
   11  | "| 2 |"    | card row #4, "2" --> bottom of color ASCII art
   12  | "| '--'0|" | card row #5, "0" --> symbol of card value
   13  | "'3'"      | card row #6, "3" --> "------"
   14  | "Player 4" | header, "4" --> player ID

Formatiert und kommentiert

p => g = (                                // p = number of players
  q,                                      // q = number of cards
  i = p * q * 6,                          // i = counter
  d = [...Array(52).keys(                 // d = deck
    a = `:\\/:,(__),...`.split`,`         // a = ASCII art pieces (truncated, see above)
  )].sort(_ => Math.random() - .5)        // shuffle the deck
) =>                                      //
  i-- + p ?                               // if i is greater than -p:
    g(q, i, d) +                          //   do a recursive call and append ...
    a[i % p ? 6 : 7] +                    //   separator or line-feed
    a[i < 0 ? 14 : i / p % 6 | 8]         //   header or card row
    .replace(/\d/, c => [                 //   where digits are replaced with:
        'TJQKA'[j = x >> 2] || j - 3,     //     0: symbol of card value
        a['3454'[x &= 3]],                //     1: top of color ASCII art
        a[x % 3],                         //     2: bottom of color ASCII art
        '------',                         //     3: horizontal border
        p + i                             //     4: player ID
      ][c],                               //
      x = d[i % p + p * (i / p / 6 | 0)]  //   x = current card with: bits 0-1 = color
    )                                     //                          bits 2-5 = value
  :                                       // else:
    ''                                    //   stop recursion
Arnauld
quelle
2

Python 2 , 382 358 346 338 332 Bytes

from random import*
p,n=input()
d=zip([0,1,2,3]*13,'23456789TJQKA'*4)
shuffle(d)
C=""".------.
|%s.--. |
| %s |
| %s |
| '--'%s|
'------'"""
print' | '.join('Player '+`i`for i in range(p))
exec"for l in zip(*[(C%(v,'(:::\/(//\)\):::'[s::4],':((:\_)\/_(/:)):'[s::4],v)).split('\\n')for s,v in d[:p]]):print' | '.join(l)\nd=d[p:]\n"*n

Probieren Sie es online!

TFeld
quelle
2

SOGL V0.12 , 106 Bytes

E⁽⁰⅜║(Ηe─t¦4»\$²‘8n{"1<ω⅛┘‘4n╬¡;4n33žASUjk"TJQKA”+{a;22žF75ž}}'#δ№{ψ⌡≤οc+C}c_.∫:"▓⅛▲ŗ‘Κ⁽e{≤+};H?;lƧ |Γ∙┼;┼

Probieren Sie es hier aus!

Kartengenerierung:

...‘                     push "(\/):\/::/\::\/::/\:(__):():()()" - the suits
    8n                   split to line lengths of 8 - individual suits
      {                  for each suit
       "...‘               push ".---| .-|   " - a quarter of a suit
            4n             split to line lengths of 4 - [".---", "| .-", "|   "]
              έ           quad palindromize - empty card
                ;          get the suit on top
                 4n        split to line lengths of 4
                   33ž     insert in the card at [3; 3]
                      A    save on variable A - card template
SU                         push "1234567890"
  jk                       remove the first and last digits
    "TJQKA”+               append "TJQKA"
            {         }    for each number - "23456789TJQKA"
             a               load the template
              ;22ž           at [2; 2] insert the current number
                  F75ž       at [7; 5] insert the current number

Mischen:

'#             push 52
  δ            lower range - [0, 1, ..., 50, 51]
   №           reverse - [51, 50, ..., 1, 0]
    {       }  for each, pushing the current item
     ψ           get a random number from 0 to ToS (inclusive)
      ⌡          that many times
       ≤           put the first item of the stack on the top
        οc+C     prepend that to the variable C, predefined with an empty array

Umgang:

c_              push Cs contents on the stack - the stack is now a mess of cards
  .∫            repeat input times - each player - pushing the current player number
    :             duplicate the number
     "..‘         push "player "
         Κ        prepend "player " to the number
          ⁽       uppercase the 1st letter
           e{  }  repeat 2nd input times
             ≤      put the first stack item on the top
              +     append it to "Player X" vertically (making an array)
;                 get the other copy of the player number
 H?               if POP-1 (aka if it's not 1)
   ;                swap the top 2 items - the current collumn and all the previous ones (by then they've been joined together)
    l               get its (vertical) length
     Ƨ |            push " |"
        Γ           palindromize - [" | "]
         ∙          multiply " | " vertically that length times
          ┼         append it horizontally (to the previous collumns)
           ;┼       append the current collumn
dzaima
quelle
2

Ruby, 262 Bytes

->p,q{a=[*0..51].shuffle
puts ["Player %d"]*p*(d=" | ")%[*1..p],(1..q*6).map{|i|(["'------'
.------.
|%X.--. |
| %s |
| %s |
| '--'%X|".split($/)[i%6]]*p*d%a[i/6*p,p].map{|j|["(\\/):()::/\\:"[u=j%4*4-4,4],":\\/:()():\\/:(__)"[u,4],j/4][i%3]}).tr("01BC","TJQK")}}

Schwerer zu folgen, aber kürzer!

Ruby, 279 Bytes

->p,q{puts [*1..p].map{|k|"Player #{k}"}*" | "
a=[*0..51].shuffle
(q*6).times{|i|puts [".------.
|%s.--. |
| %s |
| %s |
| '--'%s|
'------'".split($/)[i%6]]*p*" | "%a[i/6*p,p].map{|j|[":\\/:()():\\/:(__)"[u=j%4*4-4,4],("%X"%(j/4)).tr("01BC","TJQK"),"(\\/):()::/\\:"[u,4]][i%3]}}}

Erstellt für jede Zeile ein Format und verwendet dann den %Operator likesprintf , um es aufzufüllen.

Die Tatsache, dass der Kartenwert in jeder dritten Reihe erscheint, ist praktisch. Kartenwerte werden hexadezimal dargestellt, wobei die Ziffern durch 01BCersetzt werden TJQK.

4 Bytes von den Farbsymbolen wurden gespeichert, indem berücksichtigt wurde, dass die Oberseite der Rauten und Pik gleich ist, jedoch 2 für die -4am Ende des j%4*4-4Farbcodes hinzugefügten Ziffern -4 0 4 oder 8, wobei [-4,4]4 Zeichen bedeuten, die mit dem viertletzten Zeichen in der beginnen Zeichenfolge.

Könnte wahrscheinlich ein paar Bytes mehr sparen. Es ist hässlich, den Code für die Spieleridentifikationen wiederholen zu müssen.

Level River St
quelle
2

PHP, 509 Bytes

<?$hu='(\/}';$hv=$dv=':\/:';$du=$su=':/\:';$sv='(__)';$cu=':():';$cv='()()';$q="------";$t=$argv[1];foreach([h,d,s,c]as$a)foreach([2,3,4,5,6,7,8,9,T,J,Q,K,A]as$b)$c[]=[$b,$a];shuffle($c);$h=$a=0;for(;$a<$t;$a++)$e[]="Player $a";$f[]=join(" | ",$e);for($g=$argv[2];$g--;){$p=$i=$k=$l=$m=$r=[];$j=$h+$t;for(;$h<$j;$h++){$n=$c[$h][0];$o=$c[$h][1];$p[]=".$q.";$i[]="|$n.--. |";$k[]="| ${$o.u} |";$l[]="| ${$o.v} |";$m[]="| '--'$n|";$r[]="'$q'";}foreach([p,i,k,l,m,r]as$b)$f[]=join(" | ",${$b});}echo join('
',$f);

Probieren Sie es online!

Dies ist mein erster Versuch, Code Golf zu spielen, daher kann es wahrscheinlich noch viel verbessert werden. Ich dachte, ich müsste irgendwo anfangen. :)

Jo.
quelle
1

Java (OpenJDK 8) , 784 835 843 826 815 781 775 Bytes

String k(String s){return s.replaceAll("...$","\n");}
p->q->{int c=0,l=0,s[]=new int[p*q],i=0,j,t,b;java.util.List e=new java.util.Stack();String v="TJQK",o="",n[]=new String[p*q],x=o;for(;i<p;o+="Player "+i+++" | ",x+=v);o=k(o);for(i=0;i<q;i++){o=k(o+x.replace(v,".------. | "));for(j=0;j<p;j++){do{t=(int)(Math.random()*13)+1;b=(int)(Math.random()*4);}while(e.contains(t+""+v.charAt(b)));e.add(t+""+v.charAt(b));s[c]=b;n[c]=t<2?"A":t<10?""+t:""+v.charAt(t-10);o+="|2.--. | | ".replace("2",n[c++]);}o=k(o);for(j=0;j<p;j++,l++)o+="| "+(s[l]<1?"(\\/)":s[l]<3?":/\\:":":():")+" | | ";o=k(o);for(j=0;j<p;j++)o+="| "+(s[i*p+j]<2?":\\/:":s[i*p+j]<3?"(__)":"()()")+" | | ";o=k(o);for(j=0;j<p;)o+="| '--'2| | ".replace("2",n[i*p+j++]);o=k(k(o)+x.replace(v,"'------' | "));}return o;}

Probieren Sie es online!

Warum das Downvote, es entspricht der Spezifikation

Roberto Graham
quelle
Außerdem sollten Sie alternative Methoden erstellen, anstatt sie zu erstellen Function<String,String>: Letztere sind sehr, sehr kostspielig. Sowohl bei der Erstellung als auch bei der Verwendung.
Olivier Grégoire
Ich gehe davon aus, dass das Downvote für die ursprüngliche fehlerhafte Antwort war, aber die aktuelle scheint korrekt zu sein, also habe ich mich dafür entschieden, sie zu neutralisieren. Einige Kleinigkeiten zum Golfspielen: Klammern können bei entfernt werden n[c]=t<2?"A":t<10?""+t:""+"TJQK".charAt(t-10); for(j=0;j<p;j++){o+=...;l++;}kann sein for(j=0;j<p;l++,j++)o+=...;; Sie können return o;stattdessen System.out.print(o);eine Sekunde Functionanstelle von verwenden Consumer; ,y=p*qkann entfernt werden und Sie können statt p*qzweimal direkt verwenden y. Golf hat zweifellos noch viel mehr zu bieten, aber ich habe im Moment keine Zeit, mich damit zu befassen.
befassen Kevin Cruijssen
1
@ KevinCruijssen Eigentlich nein. Ich habe nach der ersten Bearbeitung für "keine Mühe beim Golfen" gestimmt, abgesehen vom Entfernen von Leerzeichen und der Verwendung von 1-Zeichen-Variablennamen. Ich vermute, dass Roberto Graham die Tipps zum Golfen in Java noch einmal vollständig durchlesen sollte . Der Punkt ist, dass es in der Tat der Spezifikation der Herausforderung entspricht, aber nicht der Spezifikation des Code-Golf-Tags.
Olivier Grégoire
Woher weiß ich, dass man weiter Golf spielen kann? Ich hatte ungefähr 400 Bytes, als ich aufgab, nachdem ich diese Antwort gesehen hatte, und ich schätzte ungefähr 50 Bytes mehr, um sie zu beenden. 450 Bytes gegen 850, es ist kaum Golf beteiligt.
Olivier Grégoire
s[l]<2?":/\\:":s[l]<3?":/\\:"kann sein s[l]<3?":/\\:"und s[i*p+j]<1?":\\/:":s[i*p+j]<2?":\\/:"kann sein s[i*p+j]<2?":\\/:". @ OlivierGrégoire Und mir ist bewusst, dass es höchstwahrscheinlich fast halbiert werden kann, also verstehe ich die Ablehnung. Dies ist jedoch meist ein Mangel an Erfahrung, und in der Tat nicht alle Tipps mehrmals zu lesen. Einige der Dinge in der Antwort habe ich auch in der Vergangenheit getan, und dies ist keine besonders einfache Herausforderung für Java. Übrigens, wenn Sie eine 400-450-Byte-Antwort haben, warum posten Sie sie dann nicht als getrennte Antwort (wenn sie signifikant unterschiedlich genug ist)? Du hättest meine Zustimmung. ;)
Kevin Cruijssen
1

Python 3, 332 Bytes

from random import*
P=lambda x:print(*x,sep=' | ')
R=range
def f(p,c):
 P(f"Player {i}"for i in R(p))
 d=[f".------.,|{n}.--. |,| {a[:4]} |,| {a[4:]} |,| '--'{n}|,'------'".split(",")for a,n in sample([*zip(r':/\:(__) (\/):\/: :/\::\/: :():()()'.split()*13,'A23456789TJQK'*4)],p*c)]
 for i in R(c):
  for t in zip(*d[i::c]):
   P(t)
RootTwo
quelle