Aquí hay una matriz que representa un mazo de cartas estándar, que incluye dos comodines.

[
  "AS", "2S", "3S", "4S", "5S", "6S", "7S", "8S", "9S", "10S", "JS", "QS", "KS", 
  "AD", "2D", "3D", "4D", "5D", "6D", "7D", "8D", "9D", "10D", "JD", "QD", "KD", 
  "AH", "2H", "3H", "4H", "5H", "6H", "7H", "8H", "9H", "10H", "JH", "QH", "KH", 
  "AC", "2C", "3C", "4C", "5C", "6C", "7C", "8C", "9C", "10C", "JC", "QC", "KC", 
  "J", "J"
]

Está compuesto de esta manera:

• Hay cuatro trajes; corazones, picas, diamantes y tréboles (H, S, D, C).
• Cada palo tiene una carta para los números del 2 al 10, más 4 cartas de 'imagen', As, Jack, Reina y Rey (A, J, Q, K).
• Para cada combinación de palo y valor, debe haber un elemento en la matriz, que es una cadena, y se compone del valor seguido por el palo (se permite un espacio en blanco entre estos).
• Además de eso, hay dos cartas Joker ('J').
• Escribe en cualquier idioma que quieras.
• ¡Golf arriba! Intente producir esta salida en el menor número de bytes.
• No importa en qué orden esté la salida.

JavaScript (ES6), 62 60 bytes

f=n=>n>51?'JJ':[('JQKA'[k=n>>2]||k-2)+'CDHS'[n&3],...f(-~n)]

Pruébalo en línea!

Bash 43 34 bytes

d=({A,J,Q,K,{2..10}}{H,S,D,C} J J)

Pruébalo en línea!

brainfuck , 200 197 bytes

+[[<+>->++<]>]+<++++<<+++[->+++>+++++>+>+<<<<]>+.<<.>>.--<<<[->>+++<<]>>+>[<<.>.-.+>.<<.<<[>>>+.>.<<.<+<-]>[-<+>>>+<<]>>.>.<<.>+++++++++.>.<<.>+.>.<<.>++++++.>.,++++[-<-------->]>[[-<+>]>]<<[<]>>>]

Pruébalo en línea!

Utiliza una celda negativa (+1 bytes para arreglar), envolviendo celdas (lotes de 'bytes para arreglar) y 0 en EOF (+2 bytes para eliminar la dependencia).

Salidas

J J 10H 2H 3H 4H 5H 6H 7H 8H 9H AH JH KH QH 10S 2S 3S 4S 5S 6S 7S 8S 9S AS JS KS QS 10D 2D 3D 4D 5D 6D 7D 8D 9D AD JD KD QD 10C 2C 3C 4C 5C 6C 7C 8C 9C AC JC KC QC

Explicación:

+[[<+>->++<]>]  Sets the tape to powers of 2 
          TAPE: 1 2 4 8 16 32 64 128 0 0'
+<++++<<+++[->+++>+++++>+>+<<<<]   Uses the 64 and the 128 to generate the suit letters
          TAPE: 1 2 4 8 16 32 0' 73 83 68 67
                                 I  S  D  C
>+.<<.>>.--<<     Prints the Jokers
<[->>+++<<]>>+>   Uses the 16 to create 49
          TAPE: 1 2 4 8 0 32 49 72' 83 68 67
                                 H   S  D  C
[  Loop over the suits
   <<.>.-.+>.<<.<<      Print the 10 card with a leading space
          TAPE: 1 2 4 8' 0 32 49 Suit
   [>>>+.>.<<.<+<-]  Use the 8 to print the other 8 number cards
          TAPE: 1 2 4 0' 8 32 57 Suit
   >[-<+>>>+<<]      Move the 8 back into place while also adding it to the 57
          TAPE: 1 2 4 8 0' 32 65 Suit

   >>.>.<<.         Print the Ace
   >+++++++++.>.<<. Print the Jack
   >+.>.<<.         Print the King
   >++++++.>.<<.    Print the Queen
          TAPE: 1 2 4 8 0 32 81' Suit
   >>,    Clear the current suit
   ++++[-<-------->]    Subtract 32 to get back to 49 (reusing the space is longer than just subtracting 32)
          TAPE: 1 2 4 8 0 32 49 0' MoreSuits?
   >[[-<+>]>]<<[<]>>>   Shift all the remaining suits over one
          TAPE: 1 2 4 8 0 32 49 Suit?'
] End on the character of the next suit and repeat

05AB1E , 28 27 25 24 23 bytes

2TŸ.•-Ÿ•S«.•ôì•âJ„jjS«u

Pruébalo en línea.

-1 byte gracias a @Emigna que elimina el Safter "HSDC", porque lo âhace implícitamente.

Explicación:

2TŸ           # Push list in the range [2,10]: [2,3,4,5,6,7,8,9,10]
   .•-Ÿ•      # Push compressed string "ajqk"
        S     # Convert it to a list of characters: ["a","j","q","k"]
         «    # Merge the two lists together: [2,3,4,5,6,7,8,9,10,"a","j","q","k"]
.•ôì•         # Push compressed string "cdhs"
â             # Cartesian product of each (pair each character of both lists):
              #  [[2,"a"],[2,"d"],[2,"h"],...,["k","d"],["k","h"],["k","s"]]
J             # Join each pair together to a single string:
              #  ["2a","2d","2h",...,"kd","kh","ks"]
„jjS          # Push string "jj", and convert it to a list of characters: ["j","j"]
    «         # Merge both lists together:
              #  ["2a","2d","2h",...,"kd","kh","ks","j","j"]
     u        # Convert everything to uppercase:
              #  ["2A","2D","2H",...,"KD","KH","KS","J","J"]
              # (and output the result implicitly)

Consulte este consejo mío de 05AB1E (sección ¿Cómo comprimir cadenas que no forman parte del diccionario? ) Para comprender por qué .•-Ÿ•es "ajqk"y .•ôì•es "cdhs".

brainfuck , 550 504 bytes

++++++++++[>+++>+++++>+++++++<<<-]>++>->[>+>+>+>+<<<<-]>----->++++.<<<<.>>>>.<<<<.>>>>>--->+++++++++++++<<<<<.-.+>>>>.<<<<<.>.-.+>>>>+.<<<<<.>.-.+>>>>++++.-----<<<<<.>.-.+>>>>>.<<<<<<.>>++++++++[-<+.>>>>.<<<<<.>.>>>>+.<<<<<.>.>>>>++++.-----<<<<<.>.>>>>>.<<<<<<.>>]>.>>.<<<<<.>>>>.>.<<<<<.>>>>+.>.<<<<<.>>>>++++++.>.<<<<<.>>>.>>+.<<<<<.>>>>.>.<<<<<.>>>>------.>.<<<<<.>>>>-.>.<<<<<.>>>.>>++++.<<<<<.>>>>.>.<<<<<.>>>>+.>.<<<<<.>>>>++++++.>.<<<<<.>>>.>>>.<<<<<<.>>>>.>>.<<<<<<.>>>>------.>>.<<<<<<.>>>>-.>>.

Pruébalo en línea!

Antigua respuesta, también en línea!

Java 10, 153 151 125 77 75 bytes

v->("AJQK2345678910".replaceAll("1?.","$0H,$0S,$0D,$0C,")+"J,J").split(",")

-28 bytes gracias a @ OlivierGrégoire .
-50 bytes gracias a @mazzy .

Pruébalo en línea.

Explicación:

v->                      // Method with empty unused parameter and String-array return-type
  "AJQK2345678910"
   .replaceAll("1?.",    //  Replace every loose character (or "10" as single char)
     "$0H,$0S,$0D,$0C,") //  with "cH,cS,cD,cC,", where c is the character
   +"J,J")               //  Append "J,J"
  .split(",")            //  And split everything by commas

APL (Dyalog Unicode) , 29 bytes

1 byte guardado gracias a Probie al usar en 1+⍳9lugar de1↓⍳10

'JJ',,'HCDS'∘.,⍨'AKJQ',⍕¨1+⍳9

Pruébalo en línea!

Este es un programa completo. En el enlace TIO, he habilitado el boxeo para que se puedan distinguir los elementos individuales de la matriz.

Aquí está la salida en caja.

┌─┬─┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬───┬───┬───┬───┐
│J│J│AH│AC│AD│AS│KH│KC│KD│KS│JH│JC│JD│JS│QH│QC│QD│QS│2H│2C│2D│2S│3H│3C│3D│3S│4H│4C│4D│4S│5H│5C│5D│5S│6H│6C│6D│6S│7H│7C│7D│7S│8H│8C│8D│8S│9H│9C│9D│9S│10H│10C│10D│10S│
└─┴─┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴───┴───┴───┴───┘

'JJ', 2 comodines concatenados a

, la forma desvencijada de

∘.,⍨ la matriz creada al concatenar cada combinación de

• 'HCDS' esta cadena contra

• 'AKJQ', esta cuerda con

  • ⍕¨ las formas en cadena de cada uno de

    • 1+⍳9 los números 2..10 (1 más el rango 1..9)

Befunge-98 (FBBI) , 75 bytes

j4d*1-2k:d%4+1g:'0-!#v_>,d/1g,' ,!#v_3
CHSDA234567890JQK@;1'< ^,;,k2"J J" <

Pruébalo en línea!

Estructura del programa

Al principio, la pila se llena con 0's, y jno salta sobre la inicialización. La inicialización empuja 4 * 13 = 52, que es el contador del programa. En las siguientes iteraciones, el seguimiento 3hace que el puntero salte sobre esta parte.

1-2k:d%4+1g,d/1g,' ,!#v_  Main loop

1-                        decrement counter
  2k:                     duplicate counter three times
     d%                   counter mod 13 ...
       4+                 ... + 4 is the position of the card in the Data section
         1g,              get the card from row 1 and print it
            d/            counter / 13 is the position of the suit in the Data section
              1g,         get the suit from row 1 and print it
                 ' ,      print a space as seperator
                    !     negate the counter (0 for non-zero, 1 for 0)
                       _  If the counter is 0, move West ...
                     #v   ... and move to the termination
                          otherwise, continue with the next iteration

Código que imprime 10:

'0-!#v_>    Checks if Card is '0'

'0-         subtract the '0' from the card
   !        negate (1 for '0', 0 for all other cards)
      _     If card was '0', move West
    #v        and go South to print '10'
            Else continue to go East

  ;1'< ^,;  Prints '10'

     <      Go West
   1'       Push '1'
  ;         Jump to ...
         ;  ... the next semicolon
        ,   Print '1'
       ^    Go back to the main loop
            The '0' will be printed by the main loop

Terminación:

@; ... ;,k2"J J" <

                 <  Go West
           "J J"    Push "J J"
        ,k2         Print it
       ;            Jump to ...
 ;                  ... the next semicolon
@                   terminate the program

R , 65 bytes

c(outer(c('A',2:10,J<-'J','Q','K'),c('S','D','H','C'),paste),J,J)

Pruébalo en línea!

-2 Bytes gracias a las sugerencias de @Giuseppe y @JayCe

Powershell, 63 61 59 56 bytes

-3 bytes: gracias ConnorLSW

2..10+'AJQK'[0..3]|%{"$_`H";"$_`S";"$_`D";"$_`C"};,'J'*2

Perl 5 , 41 bytes

sub{J,J,map<"$_"{S,D,H,C}>,A,2..10,J,Q,K}

Pruébalo en línea!

Python 3 , 67 64 bytes

print(*[a+b for a in['10',*'A23456789JQK']for b in'CHSD'],*'JJ')

Pruébalo en línea!

Python 2 , 78 76 74 68 bytes

print['1'*(a<'1')+a+b for a in'A234567890JQK'for b in'CHSD']+['J']*2

Pruébalo en línea!

Alt:

Python 2 , 68 bytes

print[a+b for a in['10']+list('A23456789JQK')for b in'CHSD']+['J']*2

print['1'[a>'0':]+a+b for a in'A234567890JQK'for b in'CHSD']+['J']*2

salvado

• -3 bytes, gracias a los ovs

K (ngn / k) , 30 bytes

"JJ",/("AKQJ",$2+!9),'/:"SHDC"

Pruébalo en línea!

!9 es la lista 0 1 ... 8

2+!9 es la lista 2 3 ... 10

$ Encadenar

, concatenar

,'/:concatenar cada uno con cada derecho, es decir, producto cartesiano; normalmente es ,/:\:o ,\:/:pero a la derecha solo tenemos escalares ( "SHDC"), por lo que podemos usar en 'lugar de\:

"JJ",/unirse (reducir concat) a la lista de la derecha utilizando "JJ"como valor inicial para la reducción

MS-SQL, 137 bytes

SELECT v.value+s.value
FROM STRING_SPLIT('A-2-3-4-5-6-7-8-9-10-J-Q-K','-')v,STRING_SPLIT('H-S-D-C--','-')s
WHERE s.value>''OR v.value='J'

Se devuelve una matriz de valores en SQL como filas de consulta separadas. Utiliza la STRING_SPLITfunción introducida en SQL 2016 .

Incluye los comodines al agregar dos trajes de "cadena en blanco" para aprovechar la "J" existente para Jack, y luego filtrar las filas que no queremos. Más corto que usar UNION ALLdeclaraciones para agregar los comodines.

Ruby , 61 bytes

->{[*0..52,52].map{|x|['JAKQ'[w=x%13]||w-2,'SDHC'[x/13]]*''}}

Pruébalo en línea!

C # .NET, 114 bytes

o=>(new System.Text.RegularExpressions.Regex("1?.").Replace("AJQK2345678910","$0H,$0S,$0D,$0C,")+"J,J").Split(',')

Puerto de mi respuesta Java (crédito a @mazzy ) .

Pruébalo en línea.

Alternativa interesante de 119 bytes por @Corak .

using System.Linq;o=>new[]{"J","J"}.Concat(from s in"SDCH"from n in"A234567890JQK"select(n=='0'?"10":n+"")+s).ToArray()

Pruébalo en línea.

Si un en System.Collections.Generic.IEnumerable<string>lugar de string[]es un resultado aceptable, el final .ToArray()puede descartarse para que se convierta en 109 bytes .

Explicación:

using System.Linq;       // Required import for the `from .. in ..` and `select` parts
o=>                      // Method with empty unused parameter and string-array return-type
  new[]{"J","J"}         //  Return a string-array containing two times "J"
   .Concat(              //  And add:
     from s in"SDCH"     //   Loop over the suits
       from n in"A234567890JQK"
                         //    Inner loop over the cards
         select(n=='0'?  //     If the current card item is '0'
                 "10"    //      Use 10 instead
                :        //     Else:
                 n+"")   //      Simply use the card item as is
                      +s)//     And append the suit
   .ToArray()            //  Convert the IEnumerable to an array

PHP, 108 99 97 Bytes

Pruébalo en línea!

Pruébalo en línea! (Editar 1)

Código

<?php $r=[J,J];foreach([A,J,Q,K,2,3,4,5,6,7,8,9,10]as$t)
$r=array_merge($r,[H.$t,S.$t,D.$t,C.$t]);

Intenté usar funciones puramente php, pero bytecount fue menor con un bucle :(

Salida (usando print_r)

Array
(
[0] => J
[1] => J
[2] => HA
[3] => SA
[4] => DA
[5] => CA
[6] => HJ
[7] => SJ
[8] => DJ
[9] => CJ
[10] => HQ
[11] => SQ
[12] => DQ
[13] => CQ
[14] => HK
[15] => SK
[16] => DK
[17] => CK
[18] => H2
[19] => S2
[20] => D2
[21] => C2
[22] => H3
[23] => S3
[24] => D3
[25] => C3
[26] => H4
[27] => S4
[28] => D4
[29] => C4
[30] => H5
[31] => S5
[32] => D5
[33] => C5
[34] => H6
[35] => S6
[36] => D6
[37] => C6
[38] => H7
[39] => S7
[40] => D7
[41] => C7
[42] => H8
[43] => S8
[44] => D8
[45] => C8
[46] => H9
[47] => S9
[48] => D9
[49] => C9
[50] => H10
[51] => S10
[52] => D10
[53] => C10
)

Editar

Gracias a @JoKing por sugerir cambios explode(" ","H$t S$t D$t C$t")para[H.$t,S.$t,D.$t,C.$t]

SMBF , 169 bytes

␀representa un byte NUL literal \x00.

<[.<]␀J J HA HK HQ HJ H01 H9 H8 H7 H6 H5 H4 H3 H2 SA SK SQ SJ S01 S9 S8 S7 S6 S5 S4 S3 S2 DA DK DQ DJ D01 D9 D8 D7 D6 D5 D4 D3 D2 CA CK CQ CJ C01 C9 C8 C7 C6 C5 C4 C3 C2

Esta es la solución ingenua.

Debido a que este programa contiene un byte NUL, no hay una manera fácil de usar TIO. Ejecute esto en el intérprete de Python usando

data = bytearray(b'<[.<]\x00J J HA HK HQ HJ H01 H9 H8 H7 H6 H5 H4 H3 H2 SA SK SQ SJ S01 S9 S8 S7 S6 S5 S4 S3 S2 DA DK DQ DJ D01 D9 D8 D7 D6 D5 D4 D3 D2 CA CK CQ CJ C01 C9 C8 C7 C6 C5 C4 C3 C2')

Japt, 32 30 26 bytes

'J²¬c"JQKA"¬c9õÄ)ï+"CHSD"q

Pruébalo

'J²¬c"JQKA"¬c9õÄ)ï+"CHSD"q
'J                             :Literal "J"
  ²                            :Repeat twice
   ¬                           :Split
    c                          :Concatenate
     "JQKA"¬                   :  Split "JQKA"
            c                  :  Concatenate
             9õ                :    Range [1,9]
               Ä               :    Add 1 to each
                )              :  End concatenation
                 ï             :  Cartesian Product
                   "CHSD"q     :    Split "CHSD"
                  +            :  Join each pair to a string

Lote, 118 bytes

@for %%s in (C D H S)do @(for /l %%r in (2,1,10)do @echo %%r%%s)&for %%r in (J Q K A)do @echo %%r%%s
@echo J
@echo J

J , 41 bytes

'J';^:2,'HCDS',&.>/~(":&.>2+i.9),;/'AJQK'

Pruébalo en línea!

R , 67 66 bytes

c(paste(rep(c('A',2:10,J<-'J','Q','K'),4),c('S','D','H','C')),J,J)

Pruébalo en línea!

Solo un byte más que la solución de golf de digEmAll . Inspirado por la solución de Giuseppe para este desafío relacionado , ¡el mismo Giuseppe que jugó un byte por respuesta!

Estoy publicando por separado, ya que es un enfoque ligeramente diferente aprovechando el hecho de que 4 no es un divisor de 13 y que la salida no necesita estar en ningún orden en particular.

C (gcc) , 126 137 133 bytes

#define S(X)"A"X,"2"X,"3"X,"4"X,"5"X,"6"X,"7"X,"8"X,"9"X,"10"X,"J"X,"Q"X,"K"X,
#define c (char*[54]){S("S")S("D")S("H")S("C")"J","J"}

Pruébalo en línea!

+11 bytes para estar más completo gracias a Jakob.

-4 bytes gracias a Zachary

Sobre todo abusar del preprocesador para comprimir los trajes. Probablemente podría ser superado, pero es bastante eficiente considerando todo.

Javascript (ES6) 77 74 72 bytes

Este es un programa completo.

`J,J,${[..."A23456789JQK",10].map(c=>[..."SDHC"].map(s=>c+s))}`.split`,`

C (gcc, clang), 138 bytes

#define p(c)putchar(c)
int main(){for(char*q,*r="CDHS";*r;r++)for(q="A234567890JQK";*q;q++)(48==*q)&&p(49),p(*q),p(*r),p(32);puts("J J");}

El enfoque es codificar las secuencias en matrices de caracteres.

Salida de muestra

AC AD AH AS 2C 2D 2H 2S 3C 3D 3H 3S 4C 4D 4H 4S 5C 5D 5H 5S 6C 6D 6H 6S 7C 7D 7H 7S 8C 8D 8H 8S 9C 9D 9H 9S 10C 10D 10H 10S JC JD JH JS QC QD QH QS KC KD KH KS J J

Pruébalo en línea!

Oracle SQL, 164 bytes

No es un lenguaje de golf pero ...

SELECT CASE WHEN LEVEL>52THEN'J'ELSE DECODE(MOD(LEVEL,13),1,'A',11,'J',12,'Q',0,'K',MOD(LEVEL,13))||SUBSTR('HDSC',CEIL(LEVEL/13),1)END FROM DUAL CONNECT BY LEVEL<55

Pruébelo en línea - SQL Fiddle

lua ,156 127 138 129 bytes

loadstring'r={"J","J"}for x=1,52 do p=x%4+1r[#r+1]=({"A",2,3,4,5,6,7,8,9,10,"J","Q","K"})[x%13+1]..("SDHC"):sub(p,p)end return r'

Pruébalo en línea!

Basado en el código de Jo King. Como sugirió en los comentarios, mi respuesta original no era válida (todavía estoy aprendiendo cómo funciona el golf de código 😬), y vinculó una respuesta mejor y válida. Luego lo hice más pequeño.

Solución original (156 bytes):

r = {} s = "SDHC" c = {"J", "Q", "K"} t = table.insert para x en s: gmatch "." do para y = 1,13 do t (r, (y == 1 y "A" o y> 10 y c [y-10] o y) .. x) fin final para _ = 1,2 do t (r, "J") final

r={} -- initializes the result table
s="SDHC" -- initializes the suits' string, it's better to be a string because we're just looping through it
c={"J","Q","K"} -- initializes some of the special cards

t=table.insert -- stores the table.insert call inside the 't' variable

for x in s:gmatch"."do -- loops through the suits, calling each one 'x'
  for y=1,13 do -- 'y' is the current card

    t(r,(y==1 and"A"or y>10 and c[y-10]or y)..x) -- adds the card accompanied by the suit to the result ('r') table
      -- y==1 and"A"or y>10 and c[y-10]or y  means if we're at the first card, it's an "A", else if we're past the 10th card, it's a special card, else, it's the number itself

  end
end
for _=1,2 do t(r, "J")end -- loop 2 times, adding a "J" to the result table

Solo quiero decir que soy nuevo en esto de Code Golf, así que si estoy haciendo algo mal, no dudes en decirme. Sé que esta respuesta no es una de las más pequeñas, solo quería desafiarme.

Si tiene sugerencias para reducir mi código, también puede decirlo. :)

Perl 6 ,  43  42 bytes

{|(|(2..10),|<A J Q K>X~ <S D H C>),|<J J>}

Intentalo

{|(|(^9+2),|<A J Q K>X~ <S D H C>),|<J J>}

Pruébalo ^{_{con Jo King}}

Expandido:

{  # bare block lambda

    |(  # flatten into outer list

        |(  # flatten into left-side list for X~
          ^9 + 2
          # 0+2 ..^ 9+2
          #   2 ..^ 11
          #   2 ..  10
        ),
        |   # flatten into left-side list for X~

          < A J Q K >

      X~    # cross using &infix:« ~ » (string concatenation)

        <S D H C>

    ),
    |< J J > # flatten two `J`s into outer list
}

QBasic 4.5, 114 142 127 bytes

dim r$(54)
FOR i=1TO 52
m=i MOD 13
r$(i)=MID$("JQKA2345678910",1+m,1-(m=12))+MID$("CDHS",(i-1)\13+1,1)
NEXT
r$(53)="J
r$(54)="J

Notas de lanzamiento:

• Implementación inicial de V1.0
• V1.1 leyó mal los requisitos de desafío, por lo que cambió a una matriz más costosa r$. Todo el resto del código es más o menos lo mismo.
• V1.2 Las sugerencias de @TaylorScott conducen a una reescritura completa que ahorra 15 bytes.

Salida de muestra

Si agregamos este fragmento a nuestro código, podemos ver lo que se incluye en r$:

for i = 1 to ubound(r$)
?r$(i)
next

QC
KC
AC
2C
3C
4C
5C
6C
7C
8C
9C
10C
JC
QD
KD
AD
[... snip ...]
6S
7S
8S
9S
10S
JS
J
J

¿Pero cómo? Bueno, déjame decirte:

dim r$(54)          ' create a 54-slot array for our results
FOR i=1TO 52        ' Loop through the numbers 1-52 in var i
m=i MOD 13          ' Take i mod 13 to select a value (saved as m)
                    ' , and (not saved) i intdiv 13 to get a suit
r$(i)=              ' assigns to slot i in the result array
  MID$("JQKA2345678910"  ' a substring from the string with all the values
  ,1+m                   ' from position 1-13 (13 % 13 = 0, but QBasic strings are 1-based.
                         ' Hence the + 1)
  ,1-(m=12))             ' taking 1 char by default, and 2 for the Ten
                         ' Note that m=12 evaluates to 0 for 0-11, and to -1 for 12
  + MID$("CDHS",(i-1)\13+1,1)  ' and take 1 char from the suits-string
NEXT
r$(53)="J           ' Then append 2 jokers
r$(54)="J           ' These strings are auto-closed by the QBasic compiler.

Pyth, 26 25 bytes

+ B\JsM*+tSTc"JQKA"1"CDHS

Guardado un byte gracias a hakr14.
Pruébalo aquí

Explicación

+ B\JsM*+tSTc"JQKA"1"CDHS
         tST                Get the range from 2 to 10...
        +   c"JQKA"1        ... plus the list ['J', 'Q', 'K', 'A'].
       *            "CDHS   Take the Cartesian product with the suits.
     sM                     Stick the ranks and suits together.
+ B\J                       Add the jokers.