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 p
et q
en entrée; où p
est le nombre de joueurs et q
le 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
q
rangées dep
cartes à 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 < 10
vous pouvez avoir un comportement indéfini pour les scénarios où cela n'est pas respecté. - Vous devez produire des
q
lignes de cartes avec desp
cartes 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
code-golf
ascii-art
random
card-games
Urne de poulpe magique
la source
la source
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 ..?Réponses:
Charbon de bois ,
142133125 octetsEssayez-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:
Lisez le nombre de cartes
q
.Faites une boucle sur chaque joueur.
S'il ne s'agit pas du premier joueur, imprimez la ligne verticale entre le précédent et ce lecteur.
Imprimez le numéro du joueur.
Faites une boucle sur chaque carte.
Imprimez le bord de la carte.
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.
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.
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.
la source
Python 2 , 357 octets
Essayez-le en ligne!
Je n'ai aucune idée de friggin.
la source
Gelée , 126 octets
Essayez-le en ligne!
la source
JavaScript (ES6),
328... 312 octetsPrend des entrées dans la syntaxe de curry
(p)(q)
. Les joueurs sont indexés 0.Démo
Afficher l'extrait de code
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,
i
est initialisép*q*6
et décrémenté jusqu'à ce qu'il atteigne0
. Nous dessinons ensuite l'en-tête en décrémentant davantagei
jusqu'à 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 dea[]
, ce qui facilite la compréhension du reste du code.Formaté et commenté
la source
Python 2 ,
382358346338332 octetsEssayez-le en ligne!
la source
SOGL V0.12 , 106 octets
Essayez-le ici!
Génération de cartes:
Mélange:
Transaction:
la source
Rubis, 262 octets
Plus difficile à suivre, mais plus court!
Rubis, 279 octets
Construit un format pour chaque ligne, puis utilise l'
%
opérateur commesprintf
pour 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
01BC
substitué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
-4
la fin desj%4*4-4
codes 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.
la source
PHP, 509 octets
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. :)
la source
Java (OpenJDK 8) ,
784835843826815781775 octetsEssayez-le en ligne!
Pourquoi le downvote, il est conforme aux spécifications
la source
Function<String,String>
: cette dernière est très, très coûteuse. A la création comme à l'utilisation.n[c]=t<2?"A":t<10?""+t:""+"TJQK".charAt(t-10)
;for(j=0;j<p;j++){o+=...;l++;}
peut êtrefor(j=0;j<p;l++,j++)o+=...;
; vous pouvezreturn o;
au lieu d'System.out.print(o);
utiliser une secondeFunction
au lieu deConsumer
;,y=p*q
peut être supprimé et vous pouvez utiliserp*q
deux fois directement au lieu dey
. Il y a sans aucun doute beaucoup plus à jouer au golf, mais je n'ai pas le temps de me pencher làs[l]<2?":/\\:":s[l]<3?":/\\:"
peut êtres[l]<3?":/\\:"
ets[i*p+j]<1?":\\/:":s[i*p+j]<2?":\\/:"
peut êtres[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. ;)Python 3, 332 octets
la source