Introdução

Há muito tempo, quando eu codificava jogos de cartas com cartas de baralho comuns, costumava especificar um número para cada carta e chamar uma função com algum número para obter uma carta. Isso me inspirou um pouco a fazer esse desafio.

Portanto, para as pessoas que desconhecem as cartas de baralho, um baralho de cartas consiste em 52 cartas (13 em cada um dos quatro naipes, ou seja, Copas, Diamantes, Espadas, Paus). Em cada naipe, há 13 cartas - primeiro as cartas numeradas de 2 a 10, depois o Valete (J), a Rainha (Q), o Rei (K) e o Ás (A). Esta é a ordem

Desafio

O desafio é pegar um número inteiro entre 1 e 52 como entrada e exibir o cartão nessa posição. Mas, sua saída deve estar em palavras. Além disso, a ordem deve ser mantida, ou seja, as 13 primeiras cartas serão de Copas, depois Diamantes, depois Espadas e, finalmente, Clubes.

Por exemplo, se alguém escolher o número 30. A carta pertenceria ao terceiro naipe, ou seja, as Espadas. Além disso, seria a quarta carta do naipe, o que significa o número 5. Portanto, sua saída em palavras deve ser: five of spadese deve sempre seguir este formato , isto é, primeiro a carta, seguida por um ofe o nome do naipe em final, com espaços necessários no meio.

Entrada e saída

A entrada será um número inteiro entre 1 e 52 (ambos inclusive). Observe que a contagem começa aqui a partir de 1. Você pode optar por começar a partir de 0 . No entanto, você deve manter a ordem dos cartões mencionados acima. Sua saída deve ser o cartão nessa posição, escrito em palavras. Você não precisa manipular entradas inválidas. Além disso, sua saída pode estar em letras minúsculas ou maiúsculas.

Dada a seguir, é apresentada a lista de todas as entradas possíveis e suas saídas:

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

Pontuação

Isso é código-golfe , então o código mais curto vence.

Python 3 ,  115  90 bytes

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

Uma função sem nome retornando a string em maiúsculas.

Experimente online!

Quão?

Caracteres Unicode têm nomes. Os nomes de alguns deles são como "PLAYING CARD DOIS OF SPADES"; portanto, podemos obter os caracteres do caractere Unicode que representam o cartão necessário e retirar os 13 primeiros caracteres para obter nossa saída.

Os caracteres Unicode de interesse estão dentro de um bloco da seguinte maneira:

            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                           

Onde xnão são os caracteres que buscamos (os quatro na Ccoluna são "cavaleiros"; três Fsão "palhaços"; um 0é genérico; o restante são caracteres reservados).

Como tal, podemos adicionar algum valor a 0x1F0A1 = 127137 (As) para encontrar a placa que queremos.

O valor a acrescentar é complicado apenas por três coisas:

1. Precisamos reordenar os fatos (de s, h, d, c para h, d, s, c)
2. Precisamos reordenar as fileiras de (A, 2, ..., K para 2, ..., K, A)
3. Precisamos evitar as colunas sem cartões de interesse.

O uso da opção de indexação única permite que o uso da divisão inteira negativa seja indexada em uma matriz de deslocamentos em linha para o processo de reordenação com [6,0,4,2][-n//13]*8+(efetivamente [48,0,32,16][-n//13]), também podemos colocar os ases nos locais corretos n%13+e evitar o cavaleiros em coluna Ccom n%13//11+(efetivamente (n%13>10)+).

Perl6 / Rakudo 70 bytes

Índice 0

Usando perl6 -pee sem compactação de dicionário:

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

Ele apenas procura o cartão em Unicode (a partir do Ace), pede o nome e o usa. Esta é uma rota semelhante (embora eu não soubesse na época!) À resposta em Python de Jonathan Aitken - apenas eu indexo de todos os 4 ases em vez de 4 desvios do Ás de Espadas e multiplico por 1,091 para fazer o índice arredondar para fora da entrada Knight em Unicode.

Veja toda a saída (para os valores de entrada de 0 a 51) https://glot.io/snippets/ez5v2gkx83

Editado para lidar com os Knights no deck Unicode, porque Unicode.

Perl6 ♥ Unicode

05AB1E , 54 bytes

Indexado a 0

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

Experimente online!

Explicação

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

Indexado a zero.

Experimente Online!

Edição: Bubbler fez um grande ponto usando o método de divisão (e fornecendo uma resposta mais curta). No segundo bloco, usar split () gera a mesma contagem de bytes.

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

Experimente online!

Recebe entrada (indexada 1) do STDIN e com source(...,echo=T) imprime o resultado no console.

Não é bonito, mas ele vem em 2 bytes mais curto que a melhor solução que eu poderia usar outer(apresentada abaixo), então deixe isso ser um lembrete para examinar outra abordagem!

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

Experimente online!

Essencialmente o mesmo que acima; no entanto, outerfará a reciclagem corretamente, mas ter que definir sep=" of "para que pasteisso seja feito apenas um pouco mais.

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 indexado. Experimente online!

Explicação :

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

Cartões de 0 a 51. Infelizmente, o Excel não possui uma função para converter 1para"one" ...

Usar TRIMe MIDé mais curto que usar CHOOSEpara os valores de face, mas maior que usar CHOOSEpara o naipe.

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]

A entrada é indexada em 0.

Explicação:

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

Experimente online!

Atualizado para usar apenas a expressão lambda.

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

Versão Base64

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

Stax , 58 57 56 bytes

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

Execute e depure

Aqui está a representação não-comentada do mesmo programa. Ele usa literais compactados da stax fortemente. A entrada é indexada em 0. É o algoritmo 05AB1E de 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 "

Execute este

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

Escolhendo usar 0 com base na opção dada, suportando 0 (dois de copas) a 51 (ás de paus)

Casca , 52 bytes

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

Experimente online!

Sempre fico feliz em mostrar o sistema de compressão de cordas da Husk: D

Explicação

A maioria do programa (a partir ¨de então) é obviamente uma string compactada. Quando não compactado, ele se transforma em:

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

O programa é então:

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

Há algumas coisas a serem explicadas:

• Construímos as cartas com naipes antes dos valores devido à forma como o produto cartesiano Πfunciona: se o fizéssemos o contrário, a lista de cartas seria ordenada por valor (ou seja, duas de copas, duas de ouros, duas de espadas, duas de clubes, três de copas ...). Como conseqüência, temos que reverter nosso resultado.

• O resultado do programa é uma matriz bidimensional de seqüências de caracteres. Isso é impresso automaticamente pelo Husk como uma única sequência criada ao unir linhas da matriz com novas linhas e células com espaços. A razão pela qual construímos essa matriz em vez de usar a mais diretaw (juntar uma lista de palavras com espaços) é que, se o uso wdo inferenciador de tipos adivinha outra interpretação para o programa, produzindo um resultado diferente.

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)

Carga como um alias, então use: /c N. O mIRC é indexado em 1, portanto, a divisão do piso (//) no valor negativo da entrada produz -1 a -4 conforme necessário.

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

Experimente online!

Baseado em 0.

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

Experimente online!

Uma função anônima, usando a compreensão da lista para criar todas as combinações de naipe e valor e indexando na lista resultante com a entrada.

F #, 174 168 bytes

Removido um espaço em branco extra, como observado por Manish Kundu. Obrigado!

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]

Experimente online!

Serei honesto - sou novo no código golf, por isso não sei se é mais apropriado responder com uma função pura como esta (com parâmetros, mas sem E / S) ou com um bloco de código funcional com o usuário E / S.

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

Experimente online!

Isso cria uma string iniciada por ' of 'e 's', em seguida, todos os naipes seguidos por todas as classificações. Essa cadeia é dividida em vírgulas em cadeias separadas. As ações estão na frente das fileiras, porque, como isso economiza um byte ao criar os índices. Depois disso, o indexamos usando colchetes com os seguintes índices:

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

qual é o ranking, seguido pelo primeiro elemento ' of ', seguido pelo naipe, seguido por's' .

Tendo 's'como parte dos fatos (hearts,diamonds,spades,clubs ) em vez de uma sequência separada é exatamente do mesmo comprimento, mas menos divertido.

A divisão no separador padrão salvaria 4 bytes na strsplitchamada-, mas os espaços ao redor ' of 'seriam removidos e precisariam ser adicionados manualmente, custando mais bytes.

V , 154 147 144 142 Bytes

-7 bytes graças a DJMcMayhem

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

Experimente 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 indexada)

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

graças à contribuição de @Ciaran_McCarthy e @raznagul

Pega uma entrada de int I, subtrai 1 para corresponder à indexação 0 da matriz de strings e gera o número com base em I mod 13 e o naipe com base em i / 14 + 13.

funciona muito bem para o meu segundo código de golfe, apenas querendo saber se eu poderia obtê-lo mais curto usando LINQ ou outra coisa.

PowerShell , 207 192 182 174 165 163 161 157 bytes

0-Indexado

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

Experimente online!

4 bytes salvos graças ao AdmBorkBork nos comentários

CJam , 114 bytes

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

Experimente online!

Indexado a zero. Provavelmente será derrotado por idiomas com compressão de dicionário, mas tudo bem ...

Geléia , 61 bytes

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

Indexação 0. Experimente 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]]...)

Experimente online!

-2 bytes graças a @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)

Experimente online!

Isso atinge todos os tipos de pontos problemáticos de Haskell.

SOGL V0.12 , 53 bytes

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

Experimente aqui!

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 graças a @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

Baseado em 0

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

Experimente online!

Japt , 91 86 bytes

Indexado a 0.

Eu usei uma ferramenta escrita por @Shaggy para gerar as listas compactadas.

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

Experimente online!

Explicação:

A primeira sequência compactada contém os valores do cartão delimitados por d . A segunda sequência compactada contém as classificações do cartão delimitadas pork .

Esses caracteres foram escolhidos usando a ferramenta Shaggy, que gera uma string delimitada por um caractere que é compactado de maneira ideal usando shoco (a compressão que Japt usa). Isso nos permite criar uma lista de valores e classificações de cartas.

Usamos backticks `para descomprimir essas strings, depois dividimos a string usandoq , seguido pelo char para dividir.

Depois de termos as listas, mapeamos os valores dos cartões e obtemos o índice da entrada. É importante observar que o Japt agrupa seus índices, para que não tenhamos o módulo em 13.

Em cada item, percorremos as classificações do cartão. Obtemos o índice dividindo a entrada por 13.

Depois de termos os dois itens, concatenamos-os com " of ", o que produz a sequência final.

Geléia , 58 55 bytes

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

Experimente online!