Giới thiệu

Từ lâu, khi tôi thường viết mã các trò chơi bài với các thẻ chơi thông thường, tôi thường chỉ định một số cho mỗi thẻ và gọi một hàm với một số để lấy thẻ. Điều này phần nào truyền cảm hứng cho tôi để thực hiện thử thách này.

Vì vậy, đối với những người không biết về các thẻ chơi, một bộ bài gồm 52 thẻ (13 trong mỗi bốn bộ quần áo, tức là Trái tim, Kim cương, Spades, Câu lạc bộ). Trong mỗi bộ đồ, có 13 lá bài - đầu tiên là các lá bài được đánh số từ 2-10, sau đó là Jack (J), Queen (Q), King (K) và Ace (A). Đây là thứ tự

Thử thách

Thách thức là lấy một số nguyên trong khoảng 1-52 làm đầu vào và hiển thị thẻ ở vị trí đó. Nhưng, đầu ra của bạn phải bằng lời. Ngoài ra, thứ tự phải được duy trì, tức là, 13 thẻ đầu tiên sẽ là của Hearts, sau đó là Diamonds, sau đó là Spades và cuối cùng là Club.

Ví dụ: nếu ai đó chọn số 30. Thẻ sau đó sẽ thuộc về bộ thứ ba, tức là Spades. Ngoài ra, nó sẽ là thẻ thứ tư trong vụ kiện, có nghĩa là số 5. ​​Do đó, đầu ra của bạn bằng từ phải là: five of spadesvà nó phải luôn tuân theo định dạng này , tức là thẻ đầu tiên, tiếp theo là ofvà tên của vụ kiện tại kết thúc, với không gian cần thiết ở giữa.

Đầu vào và đầu ra

Đầu vào sẽ là một số nguyên trong khoảng 1-52 (bao gồm cả hai). Lưu ý rằng ở đây đếm bắt đầu từ 1. Bạn có thể chọn bắt đầu từ 0 . Tuy nhiên, bạn phải duy trì thứ tự của các thẻ được đề cập ở trên. Đầu ra của bạn phải là thẻ ở vị trí đó được viết bằng chữ. Bạn không cần phải xử lý các đầu vào không hợp lệ. Ngoài ra, đầu ra của bạn có thể ở dạng chữ thường hoặc chữ hoa.

Đưa ra dưới đây là danh sách tất cả các đầu vào có thể và đầu ra của chúng:

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

Chấm điểm

Đây là môn đánh gôn , vì vậy đoạn mã ngắn nhất sẽ thắng.

Python 3 ,  115  90 byte

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

Một hàm không tên trả về chuỗi bằng chữ hoa.

Hãy thử trực tuyến!

Làm sao?

Ký tự Unicode có tên. Tên của một số trong số này giống như "CHƠI THẺ HAI HAI SPADES", do đó chúng ta có thể lấy các ký tự của ký tự Unicode đại diện cho thẻ cần thiết và loại bỏ 13 ký tự đầu tiên để có đầu ra.

Các ký tự Unicode quan tâm nằm trong một khối như vậy:

            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                           

Trường hợp xkhông phải là các ký tự mà chúng ta theo sau (bốn người trong Ccột là "hiệp sĩ", ba trong Flà "những người thích đùa", một trong 0là chung chung, phần còn lại là các nhân vật dành riêng).

Như vậy, chúng ta có thể thêm một số giá trị vào 0x1F0A1 = 127137 (As) để tìm thẻ chúng ta muốn.

Giá trị để thêm chỉ phức tạp bởi ba điều:

1. Chúng ta cần sắp xếp lại các bộ quần áo (từ s, h, d, c đến h, d, s, c)
2. Chúng ta cần sắp xếp lại thứ hạng từ (A, 2, ..., K đến 2, ..., K, A)
3. Chúng ta cần tránh các cột không có thẻ quan tâm.

Sử dụng tùy chọn một chỉ mục cho phép sử dụng phân chia số nguyên âm để lập chỉ mục vào một loạt các giá trị bù theo hàng cho việc sắp xếp lại phù hợp với [6,0,4,2][-n//13]*8+(một cách hiệu quả [48,0,32,16][-n//13]), sau đó chúng ta cũng có thể đặt các con át chủ bài vào đúng vị trí n%13+và sau đó tránh hiệp sĩ trong cột Cvới n%13//11+(hiệu quả (n%13>10)+).

Perl6/Rakudo 70 bytes

Index 0

Using perl6 -pe, and with no dictionary compression:

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

It just looks up the card in Unicode (starting from the Ace), asks for the name and uses that. This is a similar route (though I didn't know it at the time!) to Jonathan Aitken's Python answer - only I index from all 4 aces rather than 4 offsets from the Ace of Spades, and I multiply by 1.091 to make the index round away from the Knight entry in Unicode.

See all the output (for input values 0 to 51) https://glot.io/snippets/ez5v2gkx83

Edited to cope with Knights in the Unicode deck, because Unicode.

Perl6 ♥ Unicode

05AB1E, 54 bytes

0-indexed

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

Try it online!

Explanation

“»€Å‹¡Š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 bytes

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]

Zero-indexed.

Try It Online!

EDIT: Bubbler made a great point using the split method (and providing a shorter answer). On the second block using split() yields the same byte count.

R, 154 bytes

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

Try it online!

Takes input (1-indexed) from STDIN and with source(...,echo=T) will print the result to console.

It's not pretty, BUT it comes in 2 bytes shorter than the best solution I could using outer (presented below), so let this be a reminder to examine another approach!

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 bytes

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

Try it online!

Essentially the same as above; however, outer will do the recycling properly, but having to set sep=" of " for the paste made this just a hair longer.

Emojicode, 202 bytes

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

0 indexed. Try it online!

Explanation:

🍇		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 bytes

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

Cards from 0-51. Unfortunately, Excel does not feature a function to convert 1 to "one"...

Using TRIM and MID is shorter than using CHOOSE for the face values, but longer than using CHOOSE for the Suit.

Java 8, 141 bytes

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]

Input is 0-indexed.

Explanation:

Try it online.

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 bytes

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"

Try it online!

Updated to use just lambda expression.

JavaScript ES6, 124 118 Bytes, 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))

Base64 version

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

Stax, 58 57 56 bytes

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

Run and debug it

Here's the commented ungolfed representation of the same program. It uses stax's compressed literals heavily. The input is 0-indexed. It's Emigna's 05AB1E algorithm.

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

Run this one

Bash, 133 bytes

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

Choosing to use 0 based as per the option given, supporting 0 (two of hearts) through 51 (ace of clubs)

Husk, 52 bytes

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

Try it online!

I'm always happy to show off Husk's string compression system :D

Explanation

The majority of the program (from ¨ onwards) is obviously a compressed string. When uncompressed it turns into:

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

The program then is:

;↔!Π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"]]

There are a couple of things left to explain:

• We build the cards with suits before values because of how the cartesian product Π works: if we did it the other way around, the list of cards would be ordered by value (i.e. two of hearts, two of diamonds, two of spades, two of clubs, three of hearts...). As a consequence, we have to reverse our result.

• The result of the program is a two-dimensional matrix of strings. This is automatically printed by Husk as a single string built by joining rows of the matrix with newlines and cells with spaces. The reason we build this matrix instead of using the more straightforward w (join a list of words with spaces) is that if using w the type inferencer guesses another interpretation for the program, producing a different result.

mIRCScript, 157 bytes

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)

Load as an alias, then use: /c N. mIRC is 1-indexed, so floor division (//) on the negative value of the input produces -1 to -4 as required.

C (gcc), 148 bytes

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

Try it online!

0-based.

Haskell, 132 bytes

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

Try it online!

An anonymous function, using list comprehension to build all the combinations of suit and value, and indexing into the resulting list with the input.

F#, 174 168 bytes

Removed some extra whitespace as noted by Manish Kundu. Thanks!

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]

Try it online!

I'll be honest - I'm new at code golf, so I don't know if it's more appropriate to answer with a pure function like this (with parameters, but no I/O) or with a working code block with user I/O.

Octave, 155 153 151 150 bytes

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

Try it online!

This creates a string starting with ' of ' and 's', then all the suits followed by all the ranks. This string is split at commas into separate strings. The suits are before the ranks, because since that saves a byte when creating the indices. After this, we index it using square brackets with the following indices:

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

which is the rank, followed by the first element ' of ', followed by the suit, followed by 's'.

Having the 's' as part of the suits (hearts,diamonds,spades,clubs) instead of a separate string is the exact same length but less fun.

Splitting on the default separator would save 4 bytes in the strsplit-call, but the spaces around ' of ' would be removed and would have to be added manually, costing more bytes.

V, 154 147 144 142 Bytes

-7 Bytes thanks to DJMcMayhem

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

Try it online!

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 bytes (0 indexed)

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

thanks to input from @Ciaran_McCarthy and @raznagul

Takes an input of int I, subtracts 1 to match 0 indexing of the string array and outputs the number based on I mod 13 and the suit based on i/14+13.

works pretty well for my second code golf, just wondering if i could get it shorter using LINQ or something else.

PowerShell, 207 192 182 174 165 163 161 157 bytes

0-Indexed

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

Try it online!

4 bytes saved thanks to AdmBorkBork in the comments

CJam, 114 bytes

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

Try it online!

Zero-indexed. Will probably be beaten by languages with dictionary compression, but oh well...

Jelly, 61 bytes

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

0-indexing. Try it online!

Julia 0.6, 156 bytes

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

Try it online!

-2 bytes thanks to @Stewie Griffin

Haskell, 144 bytes

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)

Try it online!

This hits all kinds of Haskell's pain points.

SOGL V0.12, 53 bytes

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

Try it Here!

Javascript 149 143 140 bytes

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 thanks to @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 bytes

0-based

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

Try it online!

Japt, 91 86 bytes

0-indexed.

I used a tool written by @Shaggy to generate the compressed lists.

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

Try it online!

Explanation:

The first compressed string contains the card values delimited by d. The second compressed string contains the card ranks delimited by k.

These chars were picked using Shaggy's tool, which generates a string delimited by a char that is optimally compressed using shoco (the compression that Japt uses). This allows us to create a list of card values and ranks.

We use backticks ` to decompress these strings, then we split the string using q, followed by the char to split on.

Once we have the lists, we map through the card values, then we get the index of the input. It is important to note that Japt wraps its indexes, so we don't have to modulo by 13.

At each item, we loop through the card ranks. We get the index by dividing the input by 13.

Once we have both items, we concatenate them with " of ", which produces the final string.

Jelly, 58 55 bytes

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

Try it online!