introduction

Il y a longtemps, lorsque je codais des jeux de cartes avec des cartes à jouer habituelles, je spécifiais un numéro pour chaque carte et appelais une fonction avec un certain nombre pour obtenir une carte. Cela m'a un peu inspiré pour relever ce défi.

Ainsi, pour les personnes qui ne connaissent pas les cartes à jouer, un jeu de cartes se compose de 52 cartes (13 dans chacune des quatre couleurs, c.-à-d. Coeurs, Diamants, Pique, Clubs). Dans chaque couleur, il y a 13 cartes - d'abord les cartes numérotées de 2 à 10, puis le valet (J), la reine (Q), le roi (K) et l'as (A). C'est l'ordre

Défi

Le défi est de prendre un entier entre 1-52 en entrée et d'afficher la carte à cette position. Mais, votre sortie doit être en mots. De plus, l'ordre doit être maintenu, c'est-à-dire que les 13 premières cartes seront des coeurs, puis des diamants, puis des piques et enfin des clubs.

Par exemple, si quelqu'un choisit le numéro, la 30carte appartiendrait alors à la troisième couleur, c'est-à-dire les piques. En outre, ce serait la quatrième carte de la couleur, ce qui signifie le numéro 5. Par conséquent, votre sortie en mots doit être: five of spadeset elle doit toujours suivre ce format , c'est-à-dire d'abord la carte, suivie d'un ofet du nom de la couleur à la fin, avec les espaces requis entre les deux.

Entrée et sortie

L'entrée sera un entier compris entre 1 et 52 (les deux inclus). Notez que le décompte commence ici à partir de 1. Vous pouvez choisir de commencer à partir de 0 . Cependant, vous devez conserver l'ordre des cartes mentionné ci-dessus. Votre sortie devrait être la carte à cette position écrite en mots. Vous n'avez pas besoin de gérer des entrées non valides. En outre, votre sortie peut être en minuscules ou en majuscules.

Ci-dessous se trouve la liste de toutes les entrées possibles et de leurs sorties:

1 -> two of hearts
2 -> three of hearts
3 -> four of hearts
4 -> five of hearts
5 -> six of hearts
6 -> seven of hearts
7 -> eight of hearts
8 -> nine of hearts
9 -> ten of hearts
10 -> jack of hearts
11 -> queen of hearts
12 -> king of hearts
13 -> ace of hearts
14 -> two of diamonds
15 -> three of diamonds
16 -> four of diamonds
17 -> five of diamonds
18 -> six of diamonds
19 -> seven of diamonds
20 -> eight of diamonds
21 -> nine of diamonds
22 -> ten of diamonds
23 -> jack of diamonds
24 -> queen of diamonds
25 -> king of diamonds
26 -> ace of diamonds
27 -> two of spades
28 -> three of spades
29 -> four of spades
30 -> five of spades
31 -> six of spades
32 -> seven of spades
33 -> eight of spades
34 -> nine of spades
35 -> ten of spades
36 -> jack of spades
37 -> queen of spades
38 -> king of spades
39 -> ace of spades
40 -> two of clubs
41 -> three of clubs
42 -> four of clubs
43 -> five of clubs
44 -> six of clubs
45 -> seven of clubs
46 -> eight of clubs
47 -> nine of clubs
48 -> ten of clubs
49 -> jack of clubs
50 -> queen of clubs
51 -> king of clubs
52 -> ace of clubs

Notation

C'est le code-golf , donc le code le plus court l'emporte.

Python 3 ,  115  90 octets

from unicodedata import*
lambda n:name(chr(n%13+n%13//11+[6,0,4,2][-n//13]*8+127137))[13:]

Une fonction sans nom renvoyant la chaîne en majuscules.

Essayez-le en ligne!

Comment?

Les caractères Unicode ont des noms. Les noms de certains d'entre eux sont comme "JOUER UNE CARTE DEUX PESES", donc nous pouvons obtenir les caractères du caractère Unicode représentant la carte requise et retirer les 13 premiers caractères pour obtenir notre sortie.

Les caractères Unicode d'intérêt sont dans un bloc comme ceci:

            0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
U+1F0Ax     x   As  2s  3s  4s  5s  6s  7s  8s  9s  Ts  Js  x   Qs  Ks  x
U+1F0Bx     x   Ah  2h  3h  4h  5h  6h  7h  8h  9h  Th  Jh  x   Qh  Kh  x
U+1F0Cx     x   Ad  2d  3d  4d  5d  6d  7d  8d  9d  Td  Jd  x   Qd  Kd  x
U+1F0Dx     x   Ac  2c  3c  4c  5c  6c  7c  8c  9c  Tc  Jc  x   Qc  Kc  x                           

Lorsque ce xne sont pas des caractères que nous recherchons (les quatre dans la Ccolonne sont des "chevaliers"; trois en Fsont des "farceurs"; un en 0est générique; les autres sont des caractères réservés).

En tant que tel, nous pouvons ajouter une valeur à 0x1F0A1 = 127137 (As) pour trouver la carte que nous voulons.

La valeur à ajouter n'est compliquée que par trois choses:

1. Nous devons réorganiser les combinaisons (de s, h, d, c à h, d, s, c)
2. Nous devons réorganiser les rangs de (A, 2, ..., K à 2, ..., K, A)
3. Nous devons éviter les colonnes sans cartes d'intérêt.

L'utilisation de l'option d'indexation unique permet d'utiliser une division entière négative pour indexer dans un tableau de décalages par ligne pour la réorganisation de la combinaison avec [6,0,4,2][-n//13]*8+(effectivement [48,0,32,16][-n//13]), nous pouvons ensuite également placer les as aux emplacements corrects avec n%13+puis éviter la chevaliers en colonne Cavec n%13//11+(effectivement (n%13>10)+).

Perl6 / Rakudo 70 octets

Index 0

Utilisation perl6 -peet sans compression de dictionnaire:

chr('🂱🃁🂡🃑'.ords[$_/13]+($_+1)%13*1.091).uniname.substr(13)

Il recherche simplement la carte en Unicode (à partir de l'As), demande le nom et l'utilise. C'est un itinéraire similaire (bien que je ne le connaissais pas à l'époque!) À la réponse Python de Jonathan Aitken - seulement j'indexe à partir des 4 as plutôt que 4 décalages de l'as de pique, et je multiplie par 1,091 pour faire l'index autour de l'entrée Knight dans Unicode.

Voir toutes les sorties (pour les valeurs d'entrée 0 à 51) https://glot.io/snippets/ez5v2gkx83

Modifié pour faire face aux chevaliers dans le jeu Unicode, car Unicode.

Perl6 ♥ Unicode

05AB1E , 54 octets

0 indexé

“»€Å‹¡Šdesž…“#“‚•„í†ìˆÈŒšï¿Ÿ¯¥Š—¿—ÉŸÄ‹ŒÁà“#âí" of "ýsè

Essayez-le en ligne!

Explication

“»€Å‹¡Šdesž…“#                                          # push list of suits
              “‚•„í†ìˆÈŒšï¿Ÿ¯¥Š—¿—ÉŸÄ‹ŒÁà“#             # push list of ranks
                                           â            # cartesian product
                                            í           # reverse each
                                             " of "ý    # join on " of "
                                                    sè  # index into cardlist with input

Python 2 , 167 148 octets

n=input();print 'two three four five six seven eight nine ten jack queen king ace'.split()[n%13]+' of '+['hearts','diamonds','spades','clubs'][n/13]

Zéro indexé.

Essayez-le en ligne!

EDIT: Bubbler a fait un bon point en utilisant la méthode de partage (et en fournissant une réponse plus courte). Sur le deuxième bloc, l'utilisation de split () donne le même nombre d'octets.

R , 154 octets

paste(el(strsplit("Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King,Ace",",")),"of",rep(c("Hearts","Diamonds","Spades","Clubs"),e=13))[scan()]

Essayez-le en ligne!

Prend l'entrée (indexée 1) de STDIN et avec source(...,echo=T)affichera le résultat sur la console.

Ce n'est pas joli, MAIS il est disponible en 2 octets de moins que la meilleure solution que j'ai pu utiliser outer(présentée ci-dessous), alors laissez- moi vous rappeler d'examiner une autre approche!

paste(                          # concatenate together, separating by spaces,
                                # and recycling each arg to match the length of the longest
el(strsplit("Two,...",",")),    # split on commas and take the first element
"of",                           # 
 rep(c("Hearts",...),           # replicate the suits (shorter as a vector than using strsplit
               e=13)            # each 13 times
                    )[scan()]   # and take the input'th index.

R , 156 octets

outer(el(strsplit("Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King,Ace",",")),c("Hearts","Diamonds","Spades","Clubs"),paste,sep=" of ")[scan()]

Essayez-le en ligne!

Essentiellement les mêmes que ci-dessus; cependant, outerfera le recyclage correctement, mais avoir à régler sep=" of "pour le pastefait cela juste un cheveu plus long.

Emojicode , 202 octets

🍇i🚂😀🍪🍺🐽🔫🔤two.three.four.five.six.seven.eight.nine.ten.jack.queen.king.ace🔤🔤.🔤🚮i 13🔤 of 🔤🍺🐽🔫🔤hearts.diamonds.spades.clubs🔤🔤.🔤➗i 13🍪🍉

0 indexé. Essayez-le en ligne!

Explication :

🍇		start of the closure block
  i🚂		 closure takes an integer argument i
  😀		 print:
    🍪		  concatenate these strings:
      🍺🐽🔫🔤...🔤🔤.🔤🚮i 13  [a]
      🔤 of 🔤
      🍺🐽🔫🔤...🔤🔤.🔤➗i 13  [b]
    🍪
🍉

[a]:
🍺		tell Emojicode to dereference without checking
🐽		 get the nth element of the following array
  🔫		  create an array using the following string and separator
    🔤...🔤
    🔤.🔤
  🚮 i 13	n, i mod 13

[b]
🍺🐽🔫🔤...🔤🔤.🔤➗i 13
same but with ⌊i÷13⌋

Excel, 156 octets

=TRIM(MID("two  threefour five six  seveneightnine ten  jack queenking ace",1+MOD(A1,13)*5,5))&" of "&CHOOSE(1+(A1/13),"hearts","diamonds","spades","clubs")

Cartes de 0 à 51. Malheureusement, Excel ne dispose pas d'une fonction pour convertir 1en "one"...

Utiliser TRIMet MIDest plus court que l'utilisation CHOOSEpour les valeurs faciales, mais plus long que l'utilisation CHOOSEpour le costume.

Java 8, 141 octets

n->"two;three;four;five;six;seven;eight;nine;ten;jack;queen;king;ace".split(";")[n%13]+" of "+"hearts;diamonds;spades;clubs".split(";")[n/13]

L'entrée est indexée 0.

Explication:

Essayez-le en ligne.

n->         // Method with integer parameter and String return-type
  "two;three;four;five;six;seven;eight;nine;ten;jack;queen;king;ace".split(";")[n%13]
            //  Take `n` modulo-13 as 0-indexed card value
   +" of "  //  append " of "
   +"hearts;diamonds;spades;clubs".split(";")[n/13]
            //  append `n` integer-divided by 13 as 0-indexed suit

Kotlin , 154 152 140 octets

i->"two,three,four,five,six,seven,eight,nine,ten,jack,queen,king,ace".split(',')[i%13]+" of ${"heart,diamond,spade,club".split(',')[i/13]}s"

Essayez-le en ligne!

Mis à jour pour utiliser uniquement l'expression lambda.

JavaScript ES6, 124 118 Octets, 0-index

F= x=>(h=btoa`O
?NÞ{ñhº¿Å÷¿J,IëÞñ"6)Þý7§üô.yéÿ*)àüÿÿÿæ«·÷bjj'wû)i׿r[`.split`/`)[x%13]+` of ${h[x/13|16]}s`

console.log (F(51))

Version Base64

eD0+KGg9YnRvYWBPCj9OGt578Wi6v8WK979KLH9J696f8SKCG382Kd79N6f8lpyT9C556f8qKeD8Bx7///+F5qu392Jqaid3+ylp179yW5tgLnNwbGl0YC9gKVt4JTEzXStgIG9mICR7aFt4LzEzfDE2XX1zYA==

Stax , 58 57 56 octets

î↑à■?R╢8«E▄¡╔ÿ•L╫<<⌠ï∞∟⌡♪Ös1"TàLα╥▀¢¡◄└%≈δñM;;}'░o=⌡»╬í√

Exécuter et déboguer

Voici la représentation non golfée commentée du même programme. Il utilise fortement les littéraux compressés de stax. L'entrée est indexée 0. Il s'agit de l'algorithme 05AB1E d'Emigna.

`SsUI'S~pTU5T@T^Ez+`j   suits
`fV:l7eTkQtL*L2!CZb6u[&YNO4>cNHn;9(`j   ranks
|*  cross-product
@   index with input
r   reverse pair
`%+(`*  join with " of "

Exécutez celui-ci

Bash, 133 octets

V=(two three four five six seven eight nine ten jack queen king ace hearts diamonds spades clubs)
echo ${V[$1%13]} of ${V[$1/13+13]}

Choisir d'utiliser 0 en fonction de l'option donnée, en soutenant 0 (deux de cœur) à 51 (as de clubs)

Husk , 52 octets

;↔!Πmw¶¨×‼sÿẋδẎ₆ṡ⁷Ḃ6‰fωθ»&⌈θƒV₆x⁵▼Ëġ`nıEṅ'jĊk⁸"eïkÄc

Essayez-le en ligne!

Je suis toujours heureux de montrer le système de compression de cordes de Husk: D

Explication

La majorité du programme (à ¨partir de) est évidemment une chaîne compressée. Lorsqu'il n'est pas compressé, il se transforme en:

hearts diamonds spades clubs
of
two three four five six seven eight nine ten jack queen king ace

Le programme est alors:

;↔!Πmw¶¨…
       ¨…    The previous string
      ¶      Split on lines
    mw       Split each line into words
             - we now have a list of lists of words
   Π         Cartesian product of the three lists
             - with this we obtain all possible combinations of suits and values
               with "of" between the two (e.g. ["spades","of","king"])
  !          Pick the combination at the index corresponding to the input
 ↔           Reverse it, so words are in the correct order
;            Wrap it in a list. Result: [["king","of","spades"]]

Il reste quelques éléments à expliquer:

• Nous construisons les cartes avec des combinaisons avant les valeurs en raison du fonctionnement du produit cartésien Π: si nous le faisions dans l'autre sens, la liste des cartes serait ordonnée par valeur (c'est-à-dire deux de coeurs, deux de diamants, deux de piques, deux de clubs, trois de coeurs ...). En conséquence, nous devons inverser notre résultat.

• Le résultat du programme est une matrice bidimensionnelle de chaînes. Ceci est automatiquement imprimé par Husk comme une chaîne unique construite en joignant des lignes de la matrice avec des sauts de ligne et des cellules avec des espaces. La raison pour laquelle nous construisons cette matrice au lieu d'utiliser la plus simple w(joindre une liste de mots avec des espaces) est que si l'utilisation wdu type inféreur suppose une autre interprétation pour le programme, produisant un résultat différent.

mIRCScript , 157 octets

c echo $token(ace two three four five six seven eight nine ten jack queen king,$calc(1+$1% 13),32) of $token(clubs spades diamonds hearts,$calc(-$1// 13),32)

Charge comme un alias, puis utilisez: /c N. mIRC est indexé 1, donc la division du plancher (//) sur la valeur négative de l'entrée produit -1 à -4 selon les besoins.

C (gcc) , 148 octets

f(n){printf("%.5s of %.7ss","two\0 threefour\0five\0six\0 seveneightnine\0ten\0 jack\0queenking\0ace"+n%13*5,"heart\0 diamondspade\0 club"+n/13*7);}

Essayez-le en ligne!

Basé sur 0.

Haskell , 132 octets

(!!)[v++" of "++s|s<-words"hearts diamonds spades clubs",v<-words"two three four five six seven eight nine ten jack queen king ace"]

Essayez-le en ligne!

Une fonction anonyme, utilisant la compréhension de la liste pour construire toutes les combinaisons de costume et de valeur, et l'indexation dans la liste résultante avec l'entrée.

F #, 174 168 octets

Suppression de certains espaces supplémentaires, comme l'a noté Manish Kundu. Merci!

let c x=["two";"three";"four";"five";"six";"seven";"eight";"nine";"ten";"jack";"queen";"king";"ace"].[(x-1)%13]+" of "+["hearts";"diamonds";"spades";"clubs"].[(x-1)/13]

Essayez-le en ligne!

Je vais être honnête - je suis nouveau au code golf, donc je ne sais pas s'il est plus approprié de répondre avec une fonction pure comme celle-ci (avec des paramètres, mais pas d'E / S) ou avec un bloc de code fonctionnel avec l'utilisateur E / S.

Octave , 155 153 151 150 octets

@(x)[strsplit(' of ,s,heart,diamond,spade,club,ace,two,three,four,five,six,seven,eight,nine,ten,jack,queen,king',','){[mod(x,13)+7,1,ceil(2+x/13),2]}]

Essayez-le en ligne!

Cela crée une chaîne commençant par ' of 'et 's', puis toutes les combinaisons suivies de tous les rangs. Cette chaîne est séparée par des virgules en chaînes distinctes. Les combinaisons sont avant les rangs, car cela permet d'économiser un octet lors de la création des indices. Après cela, nous l'indexons en utilisant des crochets avec les indices suivants:

{[mod(x,13)+7,1,ceil(2+x/13),2]}

qui est le rang, suivi du premier élément ' of ', suivi du costume, suivi de 's'.

Le fait 's'de faire partie des costumes ( hearts,diamonds,spades,clubs) au lieu d'une chaîne distincte est exactement de la même longueur mais moins amusant.

Le fractionnement sur le séparateur par défaut économiserait 4 octets dans l' strsplitappel, mais les espaces autour ' of 'seraient supprimés et devraient être ajoutés manuellement, ce qui coûterait plus d'octets.

V , 154 147 144 142 142 octets

-7 octets grâce à DJMcMayhem

13i1heart
2diamond
3spade
4club
ÚGxCtwo
three
four
five
six
seven
eight
nine
ten
jack
queen
king
aceH$A of 012j$d4ñ13jPñÍ «/ 
{ÀjYHVGpAs

Essayez-le en ligne!

Hexdump:

00000000: 3133 6931 6865 6172 740a 3264 6961 6d6f  13i1heart.2diamo
00000010: 6e64 0a33 7370 6164 650a 3463 6c75 620a  nd.3spade.4club.
00000020: 1bda 1647 7843 7477 6f0a 7468 7265 650a  ...GxCtwo.three.
00000030: 666f 7572 0a66 6976 650a 7369 780a 7365  four.five.six.se
00000040: 7665 6e0a 6569 6768 740a 6e69 6e65 0a74  ven.eight.nine.t
00000050: 656e 0a6a 6163 6b0a 7175 6565 6e0a 6b69  en.jack.queen.ki
00000060: 6e67 0a61 6365 1b16 4824 4120 6f66 201b  ng.ace..H$A of .
00000070: 3016 3132 6a24 6434 f131 336a 50f1 cd20  0.12j$d4.13jP.. 
00000080: ab2f 200a 7bc0 6a59 4856 4770 4173       ./ .{.jYHVGpAs

C # , 219 207 202 197 octets (0 indexé)

static string O(int i){string[]s={"two","three","four","five","six","seven","eight","nine","ten","jack","queen","king","ace","hearts","diamonds","spades","clubs"};return s[i%13]+" of "+s[i/14+13];}

grâce aux contributions de @Ciaran_McCarthy et @raznagul

Prend une entrée de int I, soustrait 1 pour correspondre à l'indexation 0 du tableau de chaînes et sort le nombre basé sur I mod 13 et la combinaison basée sur i / 14 + 13.

fonctionne assez bien pour mon deuxième code de golf, je me demande simplement si je pourrais le raccourcir en utilisant LINQ ou autre chose.

PowerShell , 207 192 182 174 165 163 161 157 octets

0 indexé

$args|%{(-split'two three four five six seven eight nine ten jack queen king ace')[$_%13]+' of '+('hearts','diamonds','spades','clubs')[$_/13-replace'\..*']}

Essayez-le en ligne!

4 octets économisés grâce à AdmBorkBork dans les commentaires

CJam , 114 octets

riDmd"two three four five six seven eight nine ten jack queen king ace"S/=" of "@"hearts diamonds spades clubs"S/=

Essayez-le en ligne!

Zéro indexé. Sera probablement battu par les langues avec compression de dictionnaire, mais bon ...

Gelée , 61 octets

d13Uị"“¢¶/CŻ)Gụ+Ḷ}ċ<ʂḤaỴ£k7Ỵ€^ḥæ]¿9Ụ“¡¢|hḂṗƬßĖ,$ðĿȧ»Ḳ€¤j“ of 

0 indexation. Essayez-le en ligne!

Julia 0,6 , 156 octets

f(n)=print(split(" of ,hearts,diamonds,spades,clubs,two,three,four,five,six,seven,eight,nine,ten,jack,queen,king,ace",',')[[(n-1)%13+6,1,div(n-1,13)+2]]...)

Essayez-le en ligne!

-2 octets grâce à @Stewie Griffin

Haskell , 144 octets

f n=words"two three four five six seven eight nine ten jack queen king ace"!!(n`mod`13)++" of "++words"hearts diamonds spades clubs"!!(n`div`13)

Essayez-le en ligne!

Cela frappe toutes sortes de points douloureux de Haskell.

SOGL V0.12 , 53 octets

ķζ≡◄Τū┌p9P7šH□≡⅝'╗ΦqΖ▒ƨM.‘θ.wo"C█}y1+►ΚqΚ‘θJ¼ o.'⁰/wp

Essayez-le ici!

Javascript 149 143 140 octets

a=_=>"two three four five six seven eight nine ten jack queen king ace".split` `[_%13]+' of '+["hearts","diamonds","spades","clubs"][_/13|0]

-3 bits grâce à @rick hitchcock

a=_=>"two three four five six seven eight nine ten jack queen king ace".split` `[_%13]+' of '+["hearts","diamonds","spades","clubs"][_/13|0]
console.log(a(14))
console.log(a(34))
console.log(a(51))
console.log(a(8))
console.log(a(24))

Perl 5 -p , 119 octets

Basé sur 0

$_=(TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE,TEN,JACK,QUEEN,KING,ACE)[$_%13].' OF '.(HEART,DIAMOND,SPADE,CLUB)[$_/13].S

Essayez-le en ligne!

Japt , 91 86 octets

0 indexé.

J'ai utilisé un outil écrit par @Shaggy pour générer les listes compressées.

`{`twodÈ(‚fÆfivÀ£xç P ightdÍÂdȈjackdquÁÈkˆg»­`qd gU}  {`Ê#tsk¹aÚˆäi£kclubs`qk gUzD

Essayez-le en ligne!

Explication:

La première chaîne compressée contient les valeurs de carte délimitées par d. La deuxième chaîne compressée contient les rangs de carte délimités par k.

Ces caractères ont été choisis à l'aide de l'outil de Shaggy, qui génère une chaîne délimitée par un caractère qui est compressé de manière optimale à l'aide de shoco (la compression que Japt utilise). Cela nous permet de créer une liste de valeurs et de classements de cartes.

Nous utilisons des raccourcis `pour décompresser ces chaînes, puis nous divisons la chaîne à l'aide q, suivi du caractère pour effectuer la décomposition.

Une fois que nous avons les listes, nous cartographions les valeurs de la carte, puis nous obtenons l'index de l'entrée. Il est important de noter que Japt encapsule ses index, nous n'avons donc pas à modulo par 13.

À chaque élément, nous parcourons les rangs des cartes. Nous obtenons l'indice en divisant l'entrée par 13.

Une fois que nous avons les deux éléments, nous les concaténons avec " of ", ce qui produit la chaîne finale.

Gelée , 58 55 octets

“ıĿ⁽⁷lg3e/“ẏ“£Ṣ¢÷yḊ⁾⁶ƭ⁼ẎẇḄṡ¿Onṃ⁶ḂḂfṠȮ⁻ẉÑ%»Ḳ€p/⁸ịṚj“ of 

Essayez-le en ligne!