前書き

昔、私は通常のトランプでカードゲームをコーディングするときに、各カードに番号を指定し、カードを取得するためにいくつかの番号で関数を呼び出していました。これはやや私にこの挑戦をするよう促しました。

そのため、トランプを知らない人のために、カードのデッキは52枚のカードで構成されています（4つのスーツ、つまり、ハート、ダイアモンド、スペード、クラブのそれぞれに13枚）。各スーツには13枚のカードがあります。最初に2〜10の番号が付けられ、次にジャック（J）、クイーン（Q）、キング（K）、エース（A）です。これが注文です

チャレンジ

課題は、入力として1〜52の整数を取り、その位置にカードを表示することです。ただし、出力は言葉で行う必要があります。また、順序を維持する必要があります。つまり、最初の13枚のカードはハート、次にダイヤモンド、次にスペード、最後にクラブになります。

たとえば、誰かが番号を選択した場合、30カードは3番目のスーツ、つまりスペードに属します。また、それは数5を意味スーツ、中に4枚目のカードだろうそこで言葉であなたの出力は次のようにする必要がありますfive of spadesし、それがなければならない、常にこの形式に従うが続く、すなわち、最初のカード、ofおよびスーツの名前でを最後に、間にスペースが必要です。

入出力

入力は 1〜52の整数です（両方を含む）。ここでカウントは1 から開始することに注意してください。0から開始することもできます。ただし、上記のカードの順序を維持する必要があります。出力は、単語で書かれたその位置のカードになります。無効な入力を処理する必要はありません。また、出力は小文字でも大文字でもかまいません。

以下に、すべての可能な入力とその出力のリストを示します。

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

得点

これはcode-golfなので、最短のコードが優先されます。

Pythonの3、 115の  90バイト

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

文字列を大文字で返す名前のない関数。

オンラインでお試しください！

どうやって？

Unicode文字には名前があります。これらの一部の名前は「PLAYING CARD TWO OF SPADES」に似ているため、必要なカードを表すUnicode文字を取得し、最初の13文字を削除して出力を取得できます。

対象のUnicode文字は、次のようなブロック内にあります。

            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                           

xが後の文字ではない場合（C列の4つは「騎士」、3つFは「ジョーカー」、1つ0は汎用、残りは予約文字です）。

そのため、我々は追加することができ、いくつかの私たちが望むカードを見つけるために0x1F0A1 = 127137（AS）に値を。

追加する値は、次の3つのことによって複雑になります。

1. スーツを並べ替える必要があります（s、h、d、cからh、d、s、cへ）
2. ランクを（A、2、...、Kから2、...、K、A）に並べ替える必要があります
3. 興味のあるカードのない列を避ける必要があります。

one-indexingオプションを使用すると、負の整数除算を使用して[6,0,4,2][-n//13]*8+（実質的に[48,0,32,16][-n//13]）スーツの並べ替えのために行ごとのオフセットの配列にインデックスを付け、エースを正しい位置に配置してn%13+、列の騎士Cとn%13//11+（有効(n%13>10)+）。

Perl6 / Rakudo 70バイト

インデックス0

を使用しperl6 -pe、辞書圧縮なしで：

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

Unicodeでカードを検索し（Aceから開始）、名前を要求して使用します。これは似たようなルートです（当時は知りませんでした！） Jonathan AitkenのPythonの答えに -スペードのエースからの4つのオフセットではなく、4つのエースすべてからインデックスを作成し、1.091を掛けてインデックスを作成しますUnicodeのKnightエントリから離れて

すべての出力を見る（入力値0〜51について） https://glot.io/snippets/ez5v2gkx83

Unicodeのため、UnicodeデッキのKnightsに対処するように編集されました。

Perl6♥Unicode

05AB1E、54バイト

0インデックス付き

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

オンラインでお試しください！

説明

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

パイソン2、167の 148バイト

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]

ゼロインデックス。

オンラインでお試しください！

編集：バブラーは、スプリットメソッドを使用して（そして短い答えを提供して）素晴らしいポイントを作りました。split（）を使用する2番目のブロックでは、同じバイトカウントが生成されます。

R、154バイト

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

オンラインでお試しください！

STDINから入力（1-indexed）を取得し、with source(...,echo=T)を使用して結果をコンソールに出力します。

きれいではありませんが、私が使用できる最良のソリューションouter（以下に示す）よりも2バイト短いので、別のアプローチを検討することを思い出してください！

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バイト

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

オンラインでお試しください！

基本的に上記と同じです。ただし、outerリサイクルは適切に行われますが、これに合わせて設定sep=" of "するpaste必要があります。

絵文字コード、202バイト

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

0がインデックス付けされました。オンラインでお試しください！

説明：

🍇		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バイト

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

0〜51のカード。残念ながら、Excelには変換する機能がありません1のを"one"...

とを使用するTRIMと、顔の値にMID使用CHOOSEするよりも短くなりますがCHOOSE、スーツに使用するよりは長くなります。

Java 8、141バイト

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]

入力は0から始まります。

説明：

オンラインでお試しください。

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

コトリン、154 152 140バイト

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"

オンラインでお試しください！

ラムダ式のみを使用するように更新されました。

JavaScriptのES6、124 118バイト、0インデックス

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バージョン

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

Stax、58 57 56 バイト

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

実行してデバッグする

以下は、同じプログラムのコメントされた未作成の表現です。staxの圧縮されたリテラルを多用します。入力は0から始まります。それはエミグナの05AB1Eアルゴリズムです。

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

これを実行する

Bash、133バイト

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

指定されたオプションに従って0を使用することを選択し、0（ハートの2つ）から51（クラブのエース）をサポートします。

殻、52バイト

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

オンラインでお試しください！

Huskの文字列圧縮システムを見せびらかします：D

説明

プログラムの大部分（¨以降）は、明らかに圧縮された文字列です。圧縮解除すると、次のようになります。

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

プログラムは次のとおりです。

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

説明すべきことがいくつか残っています。

• デカルト積がどのように機能するかにより、値の前にスーツを使用してカードを作成します。Π逆の場合、カードのリストは値で並べ替えられます（つまり、ハート2つ、ダイヤモンド2つ、スペード2つ、クラブ、3つのハート...）。結果として、結果を逆にする必要があります。

• プログラムの結果は、文字列の2次元マトリックスです。これは、行列の行を改行で結合し、セルをスペースで結合して構築された単一の文字列として、Huskによって自動的に印刷されます。より単純なw（スペースで単語のリストを結合する）の代わりにこのマトリックスを作成する理由はw、型推論を使用すると、プログラムの別の解釈を推測し、異なる結果を生成するためです。

mIRCScript、157バイト

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)

エイリアスとしてロードし、次を使用します/c N。mIRCは1インデックスであるため、入力の負の値のフロア分割（//）は、必要に応じて-1〜-4を生成します。

C（gcc）、148バイト

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

オンラインでお試しください！

0ベース。

Haskell、132バイト

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

オンラインでお試しください！

リスト内包表記を使用してスーツと値のすべての組み合わせを構築し、入力を使用して結果リストにインデックスを付ける匿名関数。

F＃、174 168バイト

Manish Kunduが指摘した余分な空白を削除しました。ありがとう！

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]

オンラインでお試しください！

私は正直に言います-私はコードゴルフに慣れていないので、このような純粋な関数（パラメーターはあるがI / Oはありません）で答えるのが適切か、ユーザーと機能するコードブロックで答えるのが良いのかわかりませんI / O。

オクターブ、155 153 151 150バイト

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

オンラインでお試しください！

これにより、' of 'および's'で始まり、すべてのスーツに続いてすべてのランクが続く文字列が作成されます。この文字列は、コンマで個別の文字列に分割されます。インデックスの作成時にバイトを節約するため、スーツはランクの前にあります。この後、角括弧と次のインデックスを使用してインデックスを作成します。

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

これは、ランク、最初の要素' of '、スーツ、スーツ's'ます。

持つ's'（スーツの一環として、hearts,diamonds,spades,clubs）の代わりに、別の文字列では、正確に同じ長さのあまり楽しいです。

デフォルトの区切り文字で分割すると、strsplit-callで4バイト節約' of 'されますが、周囲のスペースは削除され、手動で追加する必要があり、より多くのバイトが必要になります。

V、154 147 144 142のバイト

DJMcMayhemのおかげで-7バイト

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

オンラインでお試しください！

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のバイト（0インデックス付き）

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

@Ciaran_McCarthyと@raznagulからの入力に感謝

int Iの入力を受け取り、1を減算して文字列配列の0インデックスに一致させ、I mod 13に基づいた数とi / 14 + 13に基づいたスーツを出力します。

私の2番目のコードゴルフでは、LINQなどを使用して短くすることができるかどうか疑問に思っています。

PowerShellの、207 192 182 174 165 163 161 157バイト

0インデックス付き

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

オンラインでお試しください！

コメントのAdmBorkBorkのおかげで4バイト節約

CJam、114バイト

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

オンラインでお試しください！

ゼロインデックス。おそらく辞書圧縮を備えた言語に負けてしまいますが、まあ...

ゼリー、61バイト

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

0インデックス。オンラインでお試しください！

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!