Distribuer un deck ASCII

13

Il n'y a jamais vraiment eu de défi définitif pour les cartes ASCII AFAIK. Donc, en utilisant le jeu de cartes ASCII suivant:

.------..------..------..------..------..------..------..------..------..------..------..------..------.
|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|
'------''------''------''------''------''------''------''------''------''------''------''------''------'

Prenez deux entiers pet qen entrée; où pest le nombre de joueurs et qle nombre de cartes que chaque joueur obtient.

  • Mélangez aléatoirement le jeu de cartes (c'est ambigu, mais cela signifie que toutes les cartes doivent être également susceptibles d'apparaître n'importe où une fois).
  • Distribuez 1 tour de cartes par joueur, produisant des qrangées de pcartes à chaque rangée.

Règles:

  • Les résultats doivent être uniformément aléatoires, chaque carte devrait également apparaître n'importe où.
  • Il est garanti que 0 < p*q <= 52 and p < 10vous pouvez avoir un comportement indéfini pour les scénarios où cela n'est pas respecté.
  • Vous devez produire des qlignes de cartes avec des pcartes par ligne.
  • Chaque colonne doit être séparée par | (un caractère de tuyau entouré d'espaces); si vous choisissez un caractère différent de celui-ci, expliquez pourquoi. Les espaces environnants ici ne sont PAS facultatifs.
  • Chaque ligne doit avoir au moins une nouvelle ligne entre elles, plus d'une est acceptable, 0 ne l'est pas (1 nouvelle ligne signifie la nouvelle ligne par défaut).
  • Chaque ligne doit être étiquetée avec le joueur qui la possède dans le format "Player N" (0 ou 1 indexé est très bien).
  • Aucune carte ne peut apparaître plus d'une fois.
  • T est pour Ten.

Exemples:

Fonction ( p=1,q=1):

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

Fonction ( p=2,q=1):

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

Fonction ( p=2,q=2):

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

Crédit artistique pour une police sur: http://patorjk.com/software/taag

Urne de poulpe magique
la source
5
Allez-vous publier de nombreux défis de cartes à partir des cartes que vous avez trouvées sur patorjk.com/software/taag ?
1
Soooo ... Pouvons-nous "utiliser" ce site pour sortir le résultat ???
J42161217
1
Je veux dire: puis-je créer un programme qui génère patorjk.com/software/taag/… pour votre dernier test?
J42161217
5
Aussi, Each row must have 1 or more newlines inbetween them, more than one is acceptable, 0 is not.... Mais vos cas de test n'ont pas de retour à la ligne entre les cartes ..?
2017 totalement humain
1
Il y avait presque un défi sur les cartes ASCII: le temps de jeu affiché par moi.
sergiol

Réponses:

6

Charbon de bois , 142 133 125 octets

NθFN«F¬¬ι«→↑×⁶θ| »Player IιFθ«↙↓.↓⁴←'←⁶↑'↑⁴.P⁶↓≔‽⁵²εW№υε≔‽⁵²ε⊞υε≔§”w↘τ[⁵PkxτG”εδδ.--.¶✂”{➙aETê;s∨Hμ⁼⎚↑Z~SÀd~⌀Tê”﹪ε⁴φ⁴'--'δ↘

Essayez-le en ligne! Le lien est vers la version détaillée du code. Edit: économisé 9 octets en améliorant mon code d'échantillonnage aléatoire. Enregistré 8 octets supplémentaires en améliorant le code d'impression de ma combinaison. Explication:

Nθ

Lisez le nombre de cartes q.

FN«

Faites une boucle sur chaque joueur.

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

S'il ne s'agit pas du premier joueur, imprimez la ligne verticale entre le précédent et ce lecteur.

Player Iι

Imprimez le numéro du joueur.

Fθ«

Faites une boucle sur chaque carte.

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

Imprimez le bord de la carte.

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

Choisissez un index de carte qui n'a pas encore été sélectionné et ajoutez-le à la liste des index de carte sélectionnés.

≔§”w↘τ[⁵PkxτG”εδδ

Choisissez et imprimez le rang de la carte en l'indexant cycliquement dans une chaîne de rangs de carte valides ( 2-9, T, J, Q, K, A).

.--.¶

Imprimez le haut du costume.

✂”{➙aETê;s∨Hμ⁼⎚↑Z~SÀd~⌀Tê”﹪ε⁴φ⁴

Imprimez le milieu du costume en le découpant en ficelle. La tranche commence à l'index de la carte modulo 4 et prend tous les 4 caractères jusqu'à ce que la chaîne s'épuise (ou que le f= 1000e caractère soit atteint). Étant donné que 4 et 13 sont des coprimes, cela garantit que les 52 cartes sont possibles.

'--'δ↘

Imprimez le bas de la combinaison et une copie du classement, puis déplacez-vous vers un point qui n'est commodément pas trop éloigné de la copie du classement, du début de la carte suivante ou du début de la ligne de division du joueur suivant.

Neil
la source
Quand j'ai vu cela dans le bac à sable, c'était un défi kc d'imprimer le jeu, ce qui m'a pris 102 octets: Essayez-le en ligne! Le lien est vers la version détaillée du code.
Neil
3

Python 2 , 357 octets

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

Essayez-le en ligne!

Je n'ai aucune idée de friggin.

totalement humain
la source
3

Gelée , 126 octets

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

Essayez-le en ligne!

fireflame241
la source
3

JavaScript (ES6), 328 ... 312 octets

Prend des entrées dans la syntaxe de curry (p)(q). Les joueurs sont indexés 0.

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)]):''

Démo

Comment?

Il s'agit d'une fonction récursive, qui génère la sortie de bas en haut. Pendant la partie principale dans laquelle les cartes sont tirées, iest initialisé p*q*6et décrémenté jusqu'à ce qu'il atteigne 0. Nous dessinons ensuite l'en-tête en décrémentant davantage ijusqu'à ce qu'il atteigne -p.

L'art ASCII est divisé en petits morceaux stockés dans le tableau a[]. Le tableau ci-dessous décrit le contenu de a[], ce qui facilite la compréhension du reste du code.

 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

Formaté et commenté

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
la source
2

Python 2 , 382 358 346 338 332 octets

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

Essayez-le en ligne!

TFeld
la source
2

SOGL V0.12 , 106 octets

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

Essayez-le ici!

Génération de cartes:

...‘                     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

Mélange:

'#             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

Transaction:

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
la source
2

Rubis, 262 octets

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

Plus difficile à suivre, mais plus court!

Rubis, 279 octets

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

Construit un format pour chaque ligne, puis utilise l' %opérateur comme sprintfpour le remplir.

Le fait que la valeur de la carte apparaisse à chaque 3e ligne est pratique. Les valeurs des cartes sont présentées en hexadécimal avec les chiffres 01BCsubstitués à TJQK.

Enregistré 4 octets à partir des symboles de la combinaison en considérant que le sommet des diamants et des piques est le même, mais ajouté 2 de retour pour -4la fin des j%4*4-4codes de combinaison sont -4 0 4 ou 8 où [-4,4]signifie 4 caractères commençant le 4ème dernier caractère de la chaîne.

Pourrait probablement économiser quelques octets supplémentaires. Devoir répéter le code pour les identifications des joueurs est moche.

Level River St
la source
2

PHP, 509 octets

<?$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);

Essayez-le en ligne!

Ceci est ma première tentative de golf de code, donc il peut probablement être beaucoup amélioré. J'ai pensé que je devais commencer quelque part. :)

Jo.
la source
1

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

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

Essayez-le en ligne!

Pourquoi le downvote, il est conforme aux spécifications

Roberto Graham
la source
En outre, vous devez créer des méthodes alternatives au lieu de créer Function<String,String>: cette dernière est très, très coûteuse. A la création comme à l'utilisation.
Olivier Grégoire
Je suppose que le downvote était pour la réponse bogue d'origine, mais le courant semble correct, j'ai donc voté pour le neutraliser. Quelques petites choses au golf: les parenthèses peuvent être supprimées à n[c]=t<2?"A":t<10?""+t:""+"TJQK".charAt(t-10); for(j=0;j<p;j++){o+=...;l++;}peut être for(j=0;j<p;l++,j++)o+=...;; vous pouvez return o;au lieu d' System.out.print(o);utiliser une seconde Functionau lieu de Consumer; ,y=p*qpeut être supprimé et vous pouvez utiliser p*qdeux fois directement au lieu de y. Il y a sans aucun doute beaucoup plus à jouer au golf, mais je n'ai pas le temps de me pencher là
dessus pour le
1
@KevinCruijssen En fait, non. J'ai rétrogradé après la première modification pour "aucun effort dans le golf" au-delà de la suppression d'espaces et de l'utilisation de noms de variables à 1 caractère. Je suppose que Roberto Graham devrait relire entièrement les astuces pour jouer au golf à Java . Le fait est qu'il est en effet conforme à la spécification du défi, mais pas à la spécification du code-golf tag.
Olivier Grégoire
Comment puis-je savoir qu'il peut être joué au golf plus loin? J'avais environ 400 octets lorsque j'ai abandonné après avoir vu cette réponse, et j'ai estimé environ 50 octets de plus pour le terminer. 450 octets contre 850, il n'y a pratiquement pas de golf impliqué.
Olivier Grégoire
s[l]<2?":/\\:":s[l]<3?":/\\:"peut être s[l]<3?":/\\:"et s[i*p+j]<1?":\\/:":s[i*p+j]<2?":\\/:"peut être s[i*p+j]<2?":\\/:". @ OlivierGrégoire Et je suis conscient qu'il peut très probablement être divisé par deux, donc je comprends le downvote. Mais c'est surtout un manque d'expérience, et en effet de ne pas lire tous les conseils plusieurs fois. Certaines des choses dans la réponse que j'ai faites dans le passé également, et ce n'est pas un défi particulièrement facile pour Java. Btw, si vous avez une réponse de 400 à 450 octets, pourquoi ne la postez-vous pas alors comme une réponse séparée (si elle est suffisamment différente)? Vous auriez mon vote positif. ;)
Kevin Cruijssen
1

Python 3, 332 octets

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
la source