introduzione

Molto tempo fa, quando ero solito codificare i giochi di carte con le solite carte da gioco, ero solito specificare un numero per ogni carta e chiamare una funzione con un numero per ottenere una carta. Questo mi ha in qualche modo ispirato a fare questa sfida.

Quindi, per le persone ignare delle carte da gioco, un mazzo di carte è composto da 52 carte (13 in ciascuno dei quattro semi, ovvero Hearts, Diamonds, Spades, Clubs). In ogni seme, ci sono 13 carte - prima le carte numerate da 2 a 10, quindi il Jack (J), la Regina (Q), il Re (K) e l'asso (A). Questo è l'ordine

Sfida

La sfida è prendere un numero intero compreso tra 1 e 52 come input e visualizzare la carta in quella posizione. Ma il tuo output deve essere in parole. Inoltre, l'ordine deve essere mantenuto, ovvero le prime 13 carte saranno di Cuori, poi Diamanti, poi Picche e infine Club.

Ad esempio, se qualcuno sceglie il numero 30. La carta apparterrebbe quindi al terzo seme, ovvero Spades. Inoltre, sarebbe la quarta carta nel seme, che significa il numero 5. Quindi il tuo output in parole deve essere: five of spadese dovrebbe sempre seguire questo formato , cioè prima la carta, seguita da un ofe il nome del seme in la fine, con gli spazi richiesti tra.

Ingresso e uscita

L'input sarà un numero intero compreso tra 1 e 52 (entrambi inclusi). Nota che qui il conteggio inizia da 1. Puoi scegliere di iniziare da 0 . Tuttavia, è necessario mantenere l'ordine delle carte di cui sopra. Il tuo output dovrebbe essere la carta in quella posizione scritta a parole. Non è necessario gestire input non validi. Inoltre, l'output potrebbe essere in minuscolo o maiuscolo.

Di seguito è riportato l'elenco di tutti i possibili ingressi e dei relativi output:

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

punteggio

Questo è code-golf , quindi vince il codice più corto.

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

Una funzione senza nome che restituisce la stringa in maiuscolo.

Provalo online!

Come?

I personaggi Unicode hanno nomi. I nomi di alcuni di questi sono come "CARTA DA GIOCO DUE DI SPADES", quindi possiamo ottenere i personaggi del personaggio Unicode che rappresentano la carta richiesta e rimuovere i primi 13 caratteri per ottenere il nostro output.

I personaggi Unicode di interesse si trovano all'interno di un blocco in questo modo:

            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                           

Dove xnon siamo i personaggi che stiamo cercando (i quattro nella Ccolonna sono "cavalieri"; tre in Fsono "jolly"; uno in 0è generico; il resto sono caratteri riservati).

Come tale possiamo aggiungere un valore a 0x1F0A1 = 127137 (As) per trovare la carta che vogliamo.

Il valore da aggiungere è complicato solo da tre cose:

1. Dobbiamo riordinare i semi (da s, h, d, c a h, d, s, c)
2. Dobbiamo riordinare i gradi da (A, 2, ..., K a 2, ..., K, A)
3. Dobbiamo evitare le colonne senza carte di interesse.

L'uso dell'opzione di indicizzazione singola consente l'uso della divisione di numeri interi negativi per indicizzare in una matrice di offset a riga per il riordino della tuta con [6,0,4,2][-n//13]*8+(efficacemente [48,0,32,16][-n//13]), quindi possiamo anche posizionare gli assi nelle posizioni corrette con n%13+e quindi evitare il cavalieri in colonna Ccon n%13//11+(effettivamente (n%13>10)+).

Perl6 / Rakudo 70 byte

Indice 0

Utilizzo perl6 -pee senza compressione del dizionario:

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

Cerca semplicemente la carta in Unicode (a partire dall'asso), chiede il nome e lo usa. Questo è un percorso simile (anche se non lo sapevo al momento!) Alla risposta Python di Jonathan Aitken - solo io indicizzo da tutti e 4 gli assi invece di 4 offset dall'asso di picche e moltiplico per 1,091 per creare l'indice arrotondato dall'ingresso Knight in Unicode.

Vedi tutto l'output (per valori di input da 0 a 51) https://glot.io/snippets/ez5v2gkx83

Modificato per far fronte ai cavalieri nel mazzo Unicode, perché Unicode.

Perl6 ♥ Unicode

05AB1E , 54 byte

0-indicizzato

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

Provalo online!

Spiegazione

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

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 indicizzati.

Provalo online!

EDIT: Bubbler ha fatto un grande punto usando il metodo split (e fornendo una risposta più breve). Nel secondo blocco usando split () si ottiene lo stesso conteggio byte.

R , 154 byte

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

Provalo online!

Riceve input (1-indicizzato) da STDIN e con source(...,echo=T)stamperà il risultato sulla console.

Non è carino, MA arriva in 2 byte in meno rispetto alla migliore soluzione che potrei usare outer(presentata di seguito), quindi lascia che questo sia un promemoria per esaminare un altro approccio!

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 byte

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

Provalo online!

Sostanzialmente lo stesso di cui sopra; tuttavia, outereseguirà il riciclaggio correttamente, ma dovendo impostare sep=" of "per pastequesto fatto solo un capello più lungo.

Emojicode , 202 byte

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

0 indicizzato. Provalo online!

Spiegazione :

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

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

Carte da 0 a 51. Sfortunatamente, Excel non ha una funzione da convertire 1in "one"...

Usare TRIMe MIDè più breve dell'uso CHOOSEper i valori facciali, ma più lungo dell'uso CHOOSEper il seme.

Java 8, 141 byte

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'input è indicizzato 0.

Spiegazione:

Provalo 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 byte

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"

Provalo online!

Aggiornato per usare solo l'espressione lambda.

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

Versione Base64

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

Stax , 58 57 56 byte

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

Esegui ed esegui il debug

Ecco la rappresentazione ungolfed commentata dello stesso programma. Usa i letterali compressi di Stax pesantemente. L'input è indicizzato 0. È l'algoritmo 05AB1E di 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 "

Esegui questo

Bash, 133 byte

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

Scegliendo di usare 0 in base all'opzione data, supportando da 0 (due di cuori) a 51 (asso di fiori)

Buccia , 52 byte

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

Provalo online!

Sono sempre felice di mostrare il sistema di compressione delle stringhe di Husk: D

Spiegazione

La maggior parte del programma (da quel momento in ¨poi) è ovviamente una stringa compressa. Quando non compresso si trasforma in:

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

Il programma quindi è:

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

Rimangono un paio di cose da spiegare:

• Costruiamo le carte con semi prima dei valori a causa di come il prodotto cartesiano Π : se lo facessimo viceversa, l'elenco delle carte verrebbe ordinato in base al valore (cioè due di cuori, due di quadri, due di picche, due di fiori, tre di cuori ...). Di conseguenza, dobbiamo invertire il nostro risultato.

• Il risultato del programma è una matrice bidimensionale di stringhe. Questo viene automaticamente stampato da Husk come una singola stringa creata unendo le righe della matrice con nuove linee e celle con spazi. Il motivo per cui costruiamo questa matrice invece di usare il più semplicew (unisci un elenco di parole con spazi) è che se usando wl'inferenziatore di tipo indovina un'altra interpretazione per il programma, producendo un risultato diverso.

mIRCScript , 157 byte

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)

Carico come alias, quindi utilizzare: /c N. mIRC è 1-indicizzato, quindi la divisione del piano (//) sul valore negativo dell'ingresso produce da -1 a -4 come richiesto.

C (gcc) , 148 byte

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

Provalo online!

0-based.

Haskell , 132 byte

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

Provalo online!

Una funzione anonima, che utilizza la comprensione dell'elenco per creare tutte le combinazioni di seme e valore e l'indicizzazione nell'elenco risultante con l'input.

F #, 174 168 byte

Rimosso un po 'di spazio extra come notato da Manish Kundu. Grazie!

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]

Provalo online!

Sarò onesto: sono nuovo nel code golf, quindi non so se è più appropriato rispondere con una funzione pura come questa (con parametri, ma senza I / O) o con un blocco di codice funzionante con l'utente I / O.

Ottava , 155 153 151 150 byte

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

Provalo online!

Questo crea una stringa che inizia con ' of 'e 's', quindi, tutti i semi seguiti da tutti i gradi. Questa stringa è divisa in virgole in stringhe separate. I semi sono prima dei ranghi, perché da allora si risparmia un byte durante la creazione degli indici. Successivamente, lo indicizziamo utilizzando parentesi quadre con i seguenti indici:

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

che è il grado, seguito dal primo elemento ' of ', seguito dal seme, seguito da's' .

Avere 's'come parte dei semi (hearts,diamonds,spades,clubs ) invece di una stringa separata è esattamente la stessa lunghezza ma meno divertente.

La suddivisione sul separatore predefinito salverebbe 4 byte nella strsplitchiamata, ma gli spazi intorno ' of 'verrebbero rimossi e dovrebbero essere aggiunti manualmente, costando più byte.

V , 154 147 144 142 Byte

-7 byte grazie 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

Provalo 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 byte (0 indicizzato)

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

grazie al contributo di @Ciaran_McCarthy e @raznagul

Prende un input di int I, sottrae 1 per abbinare l'indicizzazione 0 dell'array di stringhe e genera il numero basato su I mod 13 e il seme basato su i / 14 + 13.

funziona abbastanza bene per il mio secondo codice golf, chiedendomi solo se potrei accorciarlo usando LINQ o qualcos'altro.

PowerShell , 207 192 182 174 165 163 161 157 byte

0-indicizzato

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

Provalo online!

4 byte salvati grazie ad AdmBorkBork nei commenti

CJam , 114 byte

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

Provalo online!

Zero indicizzati. Probabilmente sarà battuto dalle lingue con la compressione del dizionario, ma vabbè ...

Gelatina , 61 byte

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

0-indicizzazione. Provalo 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!