¿Qué tarjeta es?

30

Introducción

Hace mucho tiempo, cuando solía codificar juegos de cartas con naipes habituales, solía especificar un número para cada tarjeta y llamar a una función con algún número para obtener una tarjeta. Esto me inspiró un poco para hacer este desafío.

Entonces, para las personas que desconocen las cartas de juego, un mazo de cartas consta de 52 cartas (13 en cada uno de los cuatro palos, es decir, Corazones, Diamantes, Picas, Clubes). En cada palo, hay 13 cartas: primero las cartas numeradas del 2 al 10, luego la Jota (J), la Reina (Q), el Rey (K) y el As (A). Esta es la orden

Reto

El desafío es tomar un número entero entre 1-52 como entrada y mostrar la tarjeta en esa posición. Pero, su salida debe estar en palabras. Además, se debe mantener el orden, es decir, las primeras 13 cartas serán de Corazones, luego Diamantes, luego Picas y finalmente Clubes.

Por ejemplo, si alguien elige el número 30. La tarjeta pertenecería al tercer palo, es decir, las Picas. Además, sería la cuarta carta del palo, lo que significa el número 5. Por lo tanto, su salida en palabras debe ser: five of spadesy siempre debe seguir este formato , es decir, primero la carta, seguida de una ofy el nombre del palo en Al final, con los espacios requeridos en el medio.

Entrada y salida

La entrada será un número entero entre 1-52 (ambos incluidos). Tenga en cuenta que aquí el conteo comienza desde 1. Puede elegir comenzar desde 0 . Sin embargo, debe mantener el orden de las tarjetas que se menciona anteriormente. Su salida debe ser la tarjeta en esa posición escrita en palabras. No necesita manejar entradas inválidas. Además, su salida puede estar en minúsculas o en mayúsculas.

A continuación se muestra la lista de todas las entradas posibles y sus salidas:

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

Tanteo

Este es el , por lo que gana el código más corto.

Manish Kundu
fuente
1
No es el orden predeterminado de los trajes generalmente corazones, espacios, diamantes, tréboles (rojo, negro, rojo, negro). No es que sea importante para el desafío, solo me preguntaba por qué está en este orden.
Kevin Cruijssen
3
Varía de un juego a otro. Diferentes juegos siguen diferentes órdenes. También hablando de cartas, algunos juegos incluso tienen as como la carta más baja del palo.
Manish Kundu
¿Puedo mostrar two\s\s\sof\sheartsdónde se \sencuentra un espacio? (Tenga en cuenta que los dos espacio extra.)
totallyhuman
2
@totallyhuman lo siento pero debe haber exactamente 1 espacio en el medio
Manish Kundu

Respuestas:

31

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

Una función sin nombre que devuelve la cadena en mayúsculas.

Pruébalo en línea!

¿Cómo?

Los caracteres Unicode tienen nombres. Los nombres de algunos de estos son como "TARJETA DE JUEGO DOS ESPACIOS", por lo tanto, podemos obtener los caracteres del personaje Unicode que representa la tarjeta requerida y quitar los primeros 13 caracteres para obtener nuestra salida.

Los caracteres de interés Unicode están dentro de un bloque como este:

            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                           

Cuando xno hay personajes que buscamos (los cuatro en la Ccolumna son "caballeros"; tres en F"bromistas"; uno en 0genérico; el resto son caracteres reservados).

Como tal, podemos agregar algún valor a 0x1F0A1 = 127137 (As) para encontrar la tarjeta que queremos.

El valor para agregar solo se complica por tres cosas:

  1. Necesitamos reordenar los trajes (de s, h, d, c a h, d, s, c)
  2. Necesitamos reordenar los rangos de (A, 2, ..., K a 2, ..., K, A)
  3. Necesitamos evitar las columnas sin tarjetas de interés.

El uso de la opción de indexación única permite el uso de la división de enteros negativos para indexar en una matriz de compensaciones en filas para el reordenamiento del traje con [6,0,4,2][-n//13]*8+(efectivamente [48,0,32,16][-n//13]), también podemos colocar los ases en las ubicaciones correctas n%13+y luego evitar Caballeros en columna Ccon n%13//11+(efectivamente (n%13>10)+).

Jonathan Allan
fuente
Justo cuando estaba comenzando una respuesta como esta (estoy seguro de que la mía hubiera sido más larga) miré y vi tu respuesta. Buena esa.
mbomb007
... y otro byte estaba allí para jugar golf :)
Jonathan Allan
13

Perl6 / Rakudo 70 bytes

Índice 0

Usando perl6 -pe, y sin compresión de diccionario:

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

Simplemente busca la tarjeta en Unicode (a partir del As), pregunta el nombre y lo usa. Esta es una ruta similar (¡aunque no lo sabía en ese momento!) A la respuesta de Jonathan Aitken en Python : solo indico de los 4 ases en lugar de 4 compensaciones del Ace of Spades, y multiplico por 1.091 para hacer el índice alejarse de la entrada del Caballero en Unicode

Ver toda la salida (para los valores de entrada 0 a 51) https://glot.io/snippets/ez5v2gkx83

Editado para hacer frente a los Caballeros en el mazo Unicode, porque Unicode.

Perl6 ♥ Unicode

Phil H
fuente
@ JonathanAllan: Establece el orden usando las 4 cartas base (están en el orden de palo requerido), pero bien visto en los Caballeros, no me había dado cuenta. Se corrigió a costa de unos pocos caracteres más.
Phil H
@JonathanAllan: Hay algo de incorrecto en el conteo de otras respuestas: todos dicen 'bytes' cuando se refieren a caracteres. Los que tienen compresión son los delincuentes más atroces.
Phil H
3
Creo que los que tienen cadenas de compresión que contienen lo que se presenta como Unicode en realidad tienen sus propias páginas de códigos (esto es cierto para Jelly, Husk, Charcoal y 05AB1E).
Jonathan Allan
Gracias, no lo había apreciado en absoluto.
Phil H
@PhilH Si duda de que el recuento de bytes sea correcto, puede pedirles que proporcionen un volcado hexagonal.
user202729
9

05AB1E , 54 bytes

0 indexado

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

Pruébalo en línea!

Explicación

“»€Å‹¡Šdesž…“#                                          # push list of suits
              “‚•„í†ìˆÈŒšï¿Ÿ¯¥Š—¿—ÉŸÄ‹ŒÁà“#             # push list of ranks
                                           â            # cartesian product
                                            í           # reverse each
                                             " of "ý    # join on " of "
                                                    sè  # index into cardlist with input
Emigna
fuente
@PhilH 05AB1E usa una página de códigos , al igual que la mayoría de las respuestas en idiomas de golf aquí en PPCG
dzaima
Disculpas, no me había dado cuenta de que esto era tan común.
Phil H
@PhilH eh, muchos han hecho exactamente lo mismo al pensar que el Unicode que se muestra es en realidad el puntaje de las presentaciones. Sin embargo, me gustaría si fuera estándar aquí siempre hacer un hipervínculo de la página de códigos en el título (como en mi respuesta SOGL)
dzaima
@dzaima: Lo hice por un tiempo, pero todavía recibí comentarios, así que paré. Pero estoy de acuerdo, sería bueno si se incluyera en la plantilla TIO.
Emigna
LOL, no miré esta respuesta ... “»€Å‹ spadesž…“#"of "ì“‚•„í†ìˆÈŒšï¿Ÿ¯¥Š—¿—ÉŸÄ‹ŒÁà“#âí»- ¡ 54 bytes también!
Urna de pulpo mágico
6

Python 2 , 167148 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 cero.

¡Pruébelo en línea!

EDITAR: Bubbler hizo un gran punto usando el método de división (y proporcionando una respuesta más corta). En el segundo bloque, usar split () produce el mismo recuento de bytes.

PHC
fuente
¡Bienvenido! Por defecto, los envíos deben manejar entradas y salidas; vea el resumen de las reglas de Python .
xnor
Lo tengo, gracias por señalar!
PHC
1
141 bytes con lambda y split. Intenté entrelazar los caracteres por [n%13::13]algo, pero no tuve suerte.
Bubbler
Gracias por hacerme darme cuenta de que dividir ahorraría algunos bytes. Otro byte desaparece con la división entera predeterminada de Python2.
PHC
44
140 bytes usando notación porcentual para factorizar s; xnor lo señaló en el chat.
Bubbler
6

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

Pruébalo en línea!

Toma entrada (indexada 1) de STDIN y con source(...,echo=T) imprimirá el resultado en la consola.

No es bonito, PERO viene en 2 bytes más corto que la mejor solución que podría usar outer(presentado a continuación), ¡así que este es un recordatorio para examinar otro enfoque!

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

Pruébalo en línea!

Esencialmente lo mismo que arriba; sin embargo, outerva a hacer el reciclaje correctamente, pero tener que configurar sep=" of "para el pastehizo esto sólo un pelo más largo.

Giuseppe
fuente
6

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. Pruébalo en línea!

Explicacion :

🍇		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⌋
Betseg
fuente
10
De alguna manera parece correcto que "desreferenciar sin verificar" es una jarra de cerveza.
maxathousand
6

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

Tarjetas de 0-51. Desafortunadamente, Excel no presenta una función para convertir 1a "one"...

Usar TRIMy MIDes más corto que usar CHOOSEpara los valores faciales, pero más largo que usar CHOOSEpara el Traje.

Cronocidales
fuente
¡Listo con el MID()y combinando las palabras!
BruceWayne
5

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]

La entrada está indexada en 0.

Explicación:

Pruébalo en línea.

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
Kevin Cruijssen
fuente
4

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"

Pruébalo en línea!

Actualizado para usar solo la expresión lambda.

Makotosan
fuente
Eso está completamente bien.
Nissa
2
Bienvenido a PPCG! Los idiomas del golf me desanimaron al principio, pero luego, en algún lugar, alguien me dijo "Es realmente la mejor respuesta en cada idioma gana" y me di cuenta de que era una competencia contra otros golfistas (tu idioma aquí). Sigue así, y espero que disfrutes tu tiempo aquí.
Giuseppe
Las lambdas en Kotlin (a diferencia de Java) siempre tienen un {y un final} al principio. Entonces, ¿quizás debería incluirlos y contarlos en su solución?
Roland Schmitz
3

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

Versión Base64

eD0+KGg9YnRvYWBPCj9OGt578Wi6v8WK979KLH9J696f8SKCG382Kd79N6f8lpyT9C556f8qKeD8Bx7///+F5qu392Jqaid3+ylp179yW5tgLnNwbGl0YC9gKVt4JTEzXStgIG9mICR7aFt4LzEzfDE2XX1zYA==
l4m2
fuente
prueba en línea parece rota
l4m2
no funciona en cromo
Luis felipe De jesus Munoz
funciona en Firefox @Luis felipe De jesus Munoz
l4m2
Su versión de 118 bytes mide 107 caracteres 136 bytes aquí: mothereff.in/byte-counter
Phil H
1
@PhilH si decodifica la base64 dada del código en una lista de bytes (por ejemplo, usando esto ), verá que en realidad da como resultado los 118 bytes mencionados.
dzaima
3

Stax , 58 57 56 bytes

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

Ejecutar y depurarlo

Aquí está la representación no comentada comentada del mismo programa. Utiliza los literales comprimidos de stax en gran medida. La entrada está indexada en 0. Es el 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 "

Ejecute este

recursivo
fuente
3

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

Eligiendo usar 0 según la opción dada, apoyando 0 (dos de corazones) a 51 (as de clubes)

crystalgecko
fuente
Bienvenido a PPCG!
Martin Ender
3

Casco , 52 bytes

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

Pruébalo en línea!

Siempre estoy feliz de mostrar el sistema de compresión de cuerdas de Husk: D

Explicación

La mayoría del programa (en ¨adelante) es obviamente una cadena comprimida. Cuando se descomprime se convierte en:

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

El programa entonces es:

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

Hay un par de cosas que quedan por explicar:

  • Construimos las tarjetas con palos antes que valores debido a cómo el producto cartesiano Π : si lo hiciéramos al revés, la lista de tarjetas se ordenaría por valor (es decir, dos de corazones, dos de diamantes, dos de espadas, dos de clubes, tres de corazones ...). Como consecuencia, tenemos que revertir nuestro resultado.

  • El resultado del programa es una matriz bidimensional de cadenas. Husk lo imprime automáticamente como una cadena única creada al unir filas de la matriz con nuevas líneas y celdas con espacios. La razón por la que construimos esta matriz en lugar de usar la más sencilla w(unir una lista de palabras con espacios) es que si usa wel inferenciador de tipo adivina otra interpretación para el programa, produciendo un resultado diferente.

León
fuente
2

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 un alias, a continuación, utilizar: /c N. mIRC está indexado en 1, por lo que la división de piso (//) en el valor negativo de la entrada produce -1 a -4 según sea necesario.

jaytea
fuente
2

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

Pruébalo en línea!

Basado en 0.

gastropner
fuente
Debería poder guardar 10 bytes reemplazando el \0con bytes nulos literales.
caird coinheringaahing
2

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

Pruébalo en línea!

Una función anónima, que usa la comprensión de la lista para construir todas las combinaciones de palo y valor, e indexa en la lista resultante con la entrada.

León
fuente
2

F #, 174 bytes

Se eliminó un poco de espacio en blanco adicional como lo señaló Manish Kundu. ¡Gracias!

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]

Pruébalo en línea!

Seré honesto: soy nuevo en code golf, así que no sé si es más apropiado responder con una función pura como esta (con parámetros, pero sin E / S) o con un bloque de código que funcione con el usuario E / S

Ciaran_McCarthy
fuente
1
-4 bytes eliminando solo espacios
innecesarios
El espacio en blanco me superó por completo. ¡Bien descrito! ¡Muchas gracias!
Ciaran_McCarthy
2

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

Pruébalo en línea!

Esto crea una cadena que comienza con ' of 'y 's', luego, todos los trajes seguidos por todos los rangos. Esta cadena se divide en comas en cadenas separadas. Los trajes están antes de las filas, ya que eso ahorra un byte al crear los índices. Después de esto, lo indexamos usando corchetes con los siguientes índices:

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

cuál es el rango, seguido del primer elemento ' of ', seguido del palo, seguido de 's'.

Tener 's'como parte de los trajes (hearts,diamonds,spades,clubs ) en lugar de una cadena separada es exactamente la misma longitud pero menos divertido.

La división en el separador predeterminado ahorraría 4 bytes en la strsplitllamada, pero los espacios alrededor ' of 'se eliminarían y tendrían que agregarse manualmente, lo que costaría más bytes.

Stewie Griffin
fuente
2

V , 154 147 144 142 Bytes

-7 Bytes gracias 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

Pruébalo en línea!

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
oktupol
fuente
Aquí está el atajo de clasificación: ¡ Pruébelo en línea! Siempre feliz de ver a alguien nuevo usar V :)
DJMcMayhem
Aquí hay algunos consejos: 1) « == \+2)12dj == 13D
DJMcMayhem
¡Gracias! :) ¿Y cómo lo uso ò? Lo intenté en ò13j0Pòlugar de 4ñ13j0Pñ, pero eso no terminó
oktupol
De hecho, también lo intenté. No estoy seguro de por qué no termina. ¿Quizás es porque no toca el fondo porque Pagrega nuevas líneas? Además, ¿estás seguro de que necesitas 0esa parte? Me parece como que sería probable que funcione sin
DJMcMayhem
Oh, ese es el caso. Y tienes razón, 0es innecesario
oktupol
2

C # , 219 207 202 197 bytes (0 indexados)

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

gracias a los aportes de @Ciaran_McCarthy y @raznagul

Toma una entrada de int I, resta 1 para que coincida con la indexación 0 del conjunto de cadenas y genera el número basado en I mod 13 y el palo basado en i / 14 + 13.

funciona bastante bien para mi segundo código de golf, preguntándome si podría acortarlo usando LINQ u otra cosa.

James m
fuente
2
Hasta 200 quitando el i--; y haciendo --i en el primer índice de matriz en su lugar (i se decrementa antes del módulo, y se mantiene así para la siguiente división), eliminando, "de" en la matriz (¿no es necesario?), y eliminando los corchetes alrededor la declaración de devolución y agregar un espacio en blanco entre return y s [...
Ciaran_McCarthy
1
El desafío permite que la entrada se indexe en 0 para que i++se pueda eliminar por completo. Al convertir la función a una lambda, la reduje a 178 bytes .
raznagul
2
Inicialmente se me ocurrió una respuesta de 163 bytes (ver enlace arriba). Decidí no publicarlo, porque un puerto 1 a 1 de la respuesta Java de @KevinCruijssen todavía será más corto. Tal vez más tarde trate de encontrar una respuesta de Linq solo por tenerla. Pero dudo que sea más corto. Especialmente porque Linq comienza con un déficit de 18 bytes para la Declaración. De todos modos +1 de mi parte. using
raznagul
Gracias a ambos Ciaran_McCarthy, un raznagul por su aporte, lo redujo a 202 ahora, avíseme si ve algo más que pueda jugar golf adicionalmente
James m
1
Todavía tiene lo superfluo "of"en la matriz.
raznagul
2

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'\..*']}

Pruébalo en línea!

4 bytes guardados gracias a AdmBorkBork en los comentarios

Nik Weiss
fuente
Puede unario -spliten los espacios en blanco para ahorrar 6 bytes -split'two three four five six seven eight nine ten jack queen king ace'y otro de bytes mediante línea sustituir en lugar de suelo $_/13-replace'\..*'
AdmBorkBork
@AdmBorkBork ¡Gracias por los consejos! ¿Cómo obtiene 6 bytes al cambiar -split? Solo veo ahorros de 3 bytes. Parece que todavía necesita los paréntesis, por lo que solo estoy eliminando el ',' y reordenando el resto.
Nik Weiss
No estoy seguro de cómo se me ocurrió con 6, de hecho, es solo un ahorro de 3, jajaja.
AdmBorkBork
1

CJam , 114 bytes

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

Pruébalo en línea!

Indexado a cero. Probablemente será golpeado por idiomas con compresión de diccionario, pero bueno ...

Fruta Esolanging
fuente
1

Jalea , 61 bytes

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

0-indexación. Pruébalo en línea!

usuario202729
fuente
“...“...»Ḳ€¤Œpị@j“ of Es probablemente más corto.
Jonathan Allan
1

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

Pruébalo en línea!

-2 bytes gracias a @Stewie Griffin

niczky12
fuente
1

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)

Pruébalo en línea!

Esto golpea todo tipo de puntos de dolor de Haskell.

totalmente humano
fuente
1

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

Luis felipe De jesus Munoz
fuente
1
Ahorre 3 bytes al no dividir la segunda matriz e indexándola con [_/13|0]. Por ejemplo: ["hearts","diamonds","spades","clubs"][_/13|0]
Rick Hitchcock,
No creo que necesite el a=puesto ya que su función no es recursiva.
Oliver
1

Perl 5 -p , 119 bytes

Basado en 0

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

Pruébalo en línea!

Xcali
fuente
1

Japt , 91 86 bytes

0 indexado.

Utilicé una herramienta escrita por @Shaggy para generar las listas comprimidas.

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

Pruébalo en línea!

Explicación:

La primera cadena comprimida contiene los valores de tarjeta delimitados por d. La segunda cadena comprimida contiene los rangos de tarjetas delimitados por k.

Estos caracteres se seleccionaron con la herramienta de Shaggy, que genera una cadena delimitada por un carácter que se comprime de manera óptima usando shoco (la compresión que usa Japt). Esto nos permite crear una lista de valores y rangos de cartas.

Utilizamos backticks `para descomprimir estas cadenas, luego dividimos la cadena usandoq , seguido del carácter para dividir.

Una vez que tenemos las listas, asignamos los valores de la tarjeta, luego obtenemos el índice de la entrada. Es importante tener en cuenta que Japt ajusta sus índices, por lo que no tenemos que modularlo en 13.

En cada elemento, recorremos los rangos de cartas. Obtenemos el índice dividiendo la entrada por 13.

Una vez que tenemos ambos elementos, los concatenamos con " of ", lo que produce la cadena final.

Oliver
fuente
1

Gelatina , 58 55 bytes

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

Pruébalo en línea!

Erik el Outgolfer
fuente