[Question]
  [
Here's an array representing a standard deck of cards, including two Jokers.
```
[
  "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"
]
```
It's composed in this manner:
* There are four suits; hearts, spades, diamonds, and clubs (H, S, D, C).
* Each suit has one card for the numbers 2 to 10, plus 4 'picture' cards, Ace, Jack, Queen, and King (A, J, Q, K).
* For each combination of suit and value, there should be one item in the array, which is a string, and is made up of the value followed by the suit (Whitespace between these is permitted).
* On top of that, there are two Joker cards ('J').
* Write in any language you please.
* Golf it up! Try to produce this output in the smallest number of bytes.
* It does not matter what order the output is in.
  
[Answer]
# JavaScript (ES6), ~~62~~ 60 bytes
```
f=n=>n>51?'JJ':[('JQKA'[k=n>>2]||k-2)+'CDHS'[n&3],...f(-~n)]
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zTbP1i7PztTQXt3LS90qWkPdK9DbUT062zbPzs4otqYmW9dIU1vd2cUjWD06T804VkdPTy9NQ7cuTzP2f3J@XnF@TqpeTn66RpqGpuZ/AA "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
## [Bash](https://www.gnu.org/software/bash/) ~~43~~ 34 bytes
```
d=({A,J,Q,K,{2..10}}{H,S,D,C} J J)
```
[Try it online!](https://tio.run/##S0oszvj/P8VWo9pRx0snUMdbp9pIT8/QoLa22kMnWMdFx7lWwUvBS/N/anJGvoJKdUq0Q2ztfwA "Bash ‚Äì Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~200~~ 197 bytes
```
+[[<+>->++<]>]+<++++<<+++[->+++>+++++>+>+<<<<]>+.<<.>>.--<<<[->>+++<<]>>+>[<<.>.-.+>.<<.<<[>>>+.>.<<.<+<-]>[-<+>>>+<<]>>.>.<<.>+++++++++.>.<<.>+.>.<<.>++++++.>.,++++[-<-------->]>[[-<+>]>]<<[<]>>>]
```
[Try it online!](https://tio.run/##VU5bCsMwDDuQZp/A6CLGH2thUAr9GOz8mZxsHxXEQQ9kb@/ncb0@@zkGMgM0AlEsBIToma2hX09KDCXgEU66maginPHSz2zHzcHOyKVUXwRhxTRtIld@Gau@8ec3XeSBeUvYD1TPLNK12tFVrDG@ "brainfuck ‚Äì Try It Online")
Uses one negative cell (+1 bytes to fix), wrapping cells (lots o' bytes to fix) and 0 on EOF (+2 bytes to remove dependancy).
Outputs 
```
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
```
### Explanation:
```
+[[<+>->++<]>]  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
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~28~~ ~~27~~ ~~25~~ ~~24~~ 23 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
2T≈∏.‚Ä¢-≈∏‚Ä¢S¬´.‚Ä¢√¥√¨‚Ä¢√¢J‚ÄûjjS¬´u
```
[Try it online.](https://tio.run/##yy9OTMpM/f/fKOToDr1HDYt0j@4AksGHVoM4h7ccXgOiFnk9apiXlQUULf3/HwA)
-1 byte thanks to *@Emigna* removing the `S` after `"HSDC"`, because `√¢` does this implicitly.
**Explanation:**
```
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)
```
[See this 05AB1E tip of mine (section *How to compress strings not part of the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `.‚Ä¢-≈∏‚Ä¢` is `"ajqk"` and `.‚Ä¢√¥√¨‚Ä¢` is `"cdhs"`.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~550~~ 504 bytes
```
++++++++++[>+++>+++++>+++++++<<<-]>++>->[>+>+>+>+<<<<-]>----->++++.<<<<.>>>>.<<<<.>>>>>--->+++++++++++++<<<<<.-.+>>>>.<<<<<.>.-.+>>>>+.<<<<<.>.-.+>>>>++++.-----<<<<<.>.-.+>>>>>.<<<<<<.>>++++++++[-<+.>>>>.<<<<<.>.>>>>+.<<<<<.>.>>>>++++.-----<<<<<.>.>>>>>.<<<<<<.>>]>.>>.<<<<<.>>>>.>.<<<<<.>>>>+.>.<<<<<.>>>>++++++.>.<<<<<.>>>.>>+.<<<<<.>>>>.>.<<<<<.>>>>------.>.<<<<<.>>>>-.>.<<<<<.>>>.>>++++.<<<<<.>>>>.>.<<<<<.>>>>+.>.<<<<<.>>>>++++++.>.<<<<<.>>>.>>>.<<<<<<.>>>>.>>.<<<<<<.>>>>------.>>.<<<<<<.>>>>-.>>.
```
[Try it online!](https://tio.run/##nVBBCoAwDHtQaV9Q@hHxoIIgggfB98@2urlOT0aQJWkT57gPyzYf05oSFHSiL/Gj3BIzY69EUNS9Hr5ENPgcmUKieE6SzQJ2DwnKoE5mDi/Bcr2iMe5VaynfjQwUUmPkd14T1puSV8ypCUTmqCWq6tpdL8Uotbv5J/6rrm4hzy1iexSNp3QC "brainfuck ‚Äì Try It Online")
[Old answer, also online!](https://tio.run/##vVBbCsMwDDuQsU9gdJHSj7VQKIV9DHr@zHGehrGfwRQIlmSsONvrcT6Pe79Soo4FdsFLVElVeTUChrnlaBE5w/skKwLDqNDMDnWPhXpj7uzZrCTBWSETs3ImFJljSFzR0ujXuDouSF/i2p/8bcFqfMybPE@cOMYL4p5RzDylNw "brainfuck ‚Äì Try It Online")
[Answer]
# Java 10, ~~153~~ ~~151~~ ~~125~~ ~~77~~ 75 bytes
```
v->("AJQK2345678910".replaceAll("1?.","$0H,$0S,$0D,$0C,")+"J,J").split(",")
```
-28 bytes thanks to *@OlivierGr√©goire*.  
-50 bytes thanks to *@mazzy*.
[Try it online.](https://tio.run/##PY9PS8NAEMXv/RTD0sOupkvqfwkqQQ8SaUEKXsTDuo2ycbJZdieBIv3scUqDMO8wM495v2nMYBbN9md0begiQcO97smhPilmFk1KsDLO/84AnKc6fhlbw/rQAmwoOv/9/gFWvnVuC4MqeL5ncSUy5CyswcMdjMPiXoqyen05O7@4vLq@uV3mQsc6IJ8rEaVYPmiRiXn@nM3zDeuJ9ZgJdSqqrBJKp4COJFvUWBwDQv@JHDDlDAeAlknlP5VRE@YuUd3qricdeEXoZRmj2SVN3dEsvbbS94hKTS/sxz8)
**Explanation:**
```
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
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 29 bytes
*1 byte saved thanks to Probie by using `1+‚ç≥9` instead of `1‚Üì‚ç≥10`*
```
'JJ',,'HCDS'‚àò.,‚ç®'AKJQ',‚çï¬®1+‚ç≥9
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT/@v8ahvql/wo941mo96@9SBHOdIdfXixJwSdfVH3S1AfrCrXqizr4u6elJ@hUJ@noJumm1@HlCya3FqXmJSTmqwo0@IOtejjva0/@peXuo6Ouoezi7B6o86ZujpPOpdoe7o7RWoDmRNPbTCUPtR72bL/0C1/9MA "APL (Dyalog Unicode) ‚Äì Try It Online")
This is a full program. In the TIO link, I have enabled boxing so that the individual elements of the array can be distinguished.
Here is the boxed output.
```
‚îå‚îÄ‚î¨‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îê
‚îÇ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 jokers concatenated to
`,` the raveled form of
`‚àò.,‚ç®` the matrix created by concatenating every combination of
* `'HCDS'` this string against
* `'AKJQ',` this string with
	+ `‚çï¬®` the stringified forms of each of
	
	
		- `1+‚ç≥9` the numbers 2..10 (1 plus the range 1..9)
[Answer]
# [Befunge-98 (FBBI)](https://github.com/catseye/FBBI), 75 bytes
```
j4d*1-2k:d%4+1g:'0-!#v_>,d/1g,' ,!#v_3
CHSDA234567890JQK@;1'< ^,;,k2"J J" <
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/P8skRctQ1yjbKkXVRNsw3UrdQFdRuSzeTidF3zBdR11BB8Qz5nL2CHZxNDI2MTUzt7A08Ar0drA2VLdRiNOx1sk2UvJS8FJSsPn/HwA "Befunge-98 (FBBI) ‚Äì Try It Online")
## Program structure
[![enter image description here](https://i.stack.imgur.com/y4N8r.png)](https://i.stack.imgur.com/y4N8r.png)
At first, the stack is filled with `0`'s, and `j` does not jump over the initialisation. The initialisation pushes `4 * 13 = 52`, which is the program counter. In the following iterations the trailing `3` causes the pointer to jump over this part.
```
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
```
Code that prints 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
```
Termination:
```
@; ... ;,k2"J J" <
                 <  Go West
           "J J"    Push "J J"
        ,k2         Print it
       ;            Jump to ...
 ;                  ... the next semicolon
@                   terminate the program
```
[Answer]
# [R](https://www.r-project.org/), 65 bytes
```
c(outer(c('A',2:10,J<-'J','Q','K'),c('S','D','H','C'),paste),J,J)
```
[Try it online!](https://tio.run/##K/r/P1kjv7QktUgjWUPdUV3HyMrQQMfLRlfdS11HPRCIvdU1dYBSwUCmCxB7ALEzUKggsbgkVVPHS8dL8/9/AA "R ‚Äì Try It Online")
-2 Bytes thanks to @Giuseppe and @JayCe suggestions
[Answer]
# Powershell, ~~63~~ ~~61~~ ~~59~~ 56 bytes
-3 bytes: thanks [ConnorLSW](https://codegolf.stackexchange.com/users/59735/connorlsw)
```
2..10+'AJQK'[0..3]|%{"$_`H";"$_`S";"$_`D";"$_`C"};,'J'*2
```
[Answer]
## [Perl 5](https://www.perl.org/), 41 bytes
```
sub{J,J,map<"$_"{S,D,H,C}>,A,2..10,J,Q,K}
```
[Try it online!](https://tio.run/##K0gtyjH9r5Jm@7@4NKnaS8dLJzexwEZJJV6pOljHRcdDx7nWTsdRx0hPz9AAKBmo413735qrtDhVwSWxJNHKyqU0tyC1yJqroCgzr0QBwlOIVknTtdPQjLX@DwA "Perl 5 ‚Äì Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~67~~ 64 bytes
```
print(*[a+b for a in['10',*'A23456789JQK']for b in'CHSD'],*'JJ')
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EQys6UTtJIS2/SCFRITMvWt3QQF1HS93RyNjE1MzcwtIr0Fs9FiSbBJRVd/YIdlGPBcp7ealr/v8PAA "Python 3 ‚Äì Try It Online")
---
# [Python 2](https://docs.python.org/2/), ~~78~~ ~~76~~ ~~74~~ 68 bytes
```
print['1'*(a<'1')+a+b for a in'A234567890JQK'for b in'CHSD']+['J']*2
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM68kWt1QXUsj0QZIaWonaicppOUXKSQqZOapOxoZm5iamVtYGngFequDhJNAws4ewS7qsdrR6l7qsVpAUwA "Python 2 ‚Äì Try It Online")
Alt:
# [Python 2](https://docs.python.org/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
```
---
saved
* -3 bytes, thanks to ovs
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), 30 bytes
```
"JJ",/("AKQJ",$2+!9),'/:"SHDC"
```
[Try it online!](https://tio.run/##y9bNS8/7/1/Jy0tJR19DydE7EMhQMdJWtNTUUde3Ugr2cHFW@v8fAA "K (ngn/k) ‚Äì Try It Online")
`!9` is the list `0 1 ... 8`
`2+!9` is the list `2 3 ... 10`
`$` to string
`,` concatenate
`,'/:` concatenate each with each right, i.e. Cartesian product; normally it's `,/:\:` or `,\:/:` but on the right we have only scalars (`"SHDC"`), so we can use `'` instead of `\:`
`"JJ",/` join (concat reduce) the list on the right using `"JJ"` as initial value for the reduction
[Answer]
# 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'
```
An array of values in SQL is returned as separate query rows. Uses the `STRING_SPLIT` function [introduced in SQL 2016](https://docs.microsoft.com/en-us/sql/t-sql/functions/string-split-transact-sql).
It includes the jokers by adding two "blank string" suits to take advantage of the existing "J" for Jack, then filtering out rows we don't want. Shorter than using `UNION ALL` statements to add the jokers.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 61 bytes
```
->{[*0..52,52].map{|x|['JAKQ'[w=x%13]||w-2,'SDHC'[x/13]]*''}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1646WstAT8/USMfUKFYvN7GguqaiJlrdy9E7UD263LZC1dA4tqamXNdIRz3YxcNZPbpCHygSq6WuXlv7v0AhLTr2PwA "Ruby ‚Äì Try It Online")
[Answer]
# C# .NET, 114 bytes
```
o=>(new System.Text.RegularExpressions.Regex("1?.").Replace("AJQK2345678910","$0H,$0S,$0D,$0C,")+"J,J").Split(',')
```
Port of [my Java answer (credit to *@mazzy*)](https://codegolf.stackexchange.com/a/166628/52210).
[Try it online.](https://tio.run/##RY9PSwMxEMXv@ymGUGhCY9iq9Q@1FamKrPRQV/BQeohxWiIxWTZZXZF@9nWKLB7eYWbe4/3GxCMTauyM0zHC8icDiEkna6D8jgk/1H3jzVV4fUeTJJ1q63frzRy2sy7M5tzjV298xjapJ9w1Ttd3bVVjjDb4eFhhy9n4WjFBQ@W0Qc5uitXj8cnp5Oz84nKcM8kG@YMc5CXplrSQTIxYIQvKlJWziQ/lUHQA0@yf8DPYN1hq63nPBVocPoCeaUEAwaF6qW2i0jUb/TlVEShFrRK23DfOCWrbMDGl8D7bd78)
---
Interesting alternative of [**119 bytes** by *@Corak*](https://codegolf.stackexchange.com/questions/166623/generate-a-deck-of-cards?page=2&tab=votes#comment402916_166635).
```
using System.Linq;o=>new[]{"J","J"}.Concat(from s in"SDCH"from n in"A234567890JQK"select(n=='0'?"10":n+"")+s).ToArray()
```
[Try it online.](https://tio.run/##RY5LS8QwFIX3/RWXu5mE1lDfj9qRYUSkOgsZwUXpIsZUIp0bTFJlGPrba0YpLu7icM53@ZQ/UNbpsfeG3mG99UFvxKOhzyJRnfQeVrsEwAcZjJrqu57UtX390CpksXKRrJs5tFCOtpyT/q6bHVaYxRvE0pKSgbXObsCDIVzfLu/xN9I@Lo6OT07Pzi8u8@rpAb3u4ldGZTnLZzd4mOMVpYg89Vw824Vzcsv4CFAk/1Zf1rzBShpikwtIvreGSTg6eNtp8eJM0AxrTP@WorKRiqIZtIz6ruM8xQZ5EeEhGcYf)
If an `System.Collections.Generic.IEnumerable<string>` instead of `string[]` is an acceptable output, the trailing `.ToArray()` can be dropped so it becomes **109 bytes**.
**Explanation:**
```
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
```
[Answer]
## PHP, ~~108~~ ~~99~~ 97 Bytes
[Try it online!](https://tio.run/##Dcu7CgIxFEXRfr4ihBQJnML3gygiWkisxHIYhqDRCOpcrikU8dtjitXtTZFyXqwoklC8rB1cYy8dB3@Kul7D4YA9BhhihDEmmGKGOfq9xr9UMt@yeGb/aR@Br0ErRnjTvTsHLYWE3KkkjsW22KgkjbG/qqoy8e2ZWi69sfkP)
[Try it online! (Edit 1)](https://tio.run/##K8go@P/fxr4go0BBpcg22kvHK9Y6Lb8oNTE5QyPaUcdLJ1DHW8dIx1jHRMdUx0zHXMdCx1LH0CA2sVilRLMaqCWxqCixMj43tSg9VUOlSCfaQ0@lRCcYRLiACGcgEatpXfu/oCgzryS@CKhG0/o/AA)
**Code**
```
<?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]);
```
Tried to use purely php funcions, but bytecount was lower with a loop :(
**Output (using `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
)
```
**Edit**
Thanks to @JoKing by suggesting change `explode(" ","H$t S$t D$t C$t")` for `[H.$t,S.$t,D.$t,C.$t]`
[Answer]
# [SMBF](https://esolangs.org/wiki/Self-modifying_Brainfuck), 169 bytes
`‚êÄ` represents a literal NUL byte `\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
```
This is the naive solution.
Because this program contains a NUL byte, there's no easy way to use TIO. Run this in the [Python interpreter](https://ideone.com/L2byRe) using
```
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')
```
[Answer]
# Japt, ~~32~~ ~~30~~ 26 bytes
```
'J¬≤¬¨c"JQKA"¬¨c9√µ√Ñ)√Ø+"CHSD"q
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.6&code=J0qyrGMiSlFLQSKsYzn1xCnvIkNIU0QicSltcQ==&input=LVE=)
```
'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
```
[Answer]
## Batch, 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
```
[Answer]
# [J](http://jsoftware.com/), 41 bytes
```
'J';^:2,'HCDS',&.>/~(":&.>2+i.9),;/'AJQK'
```
[Try it online!](https://tio.run/##y/r/PzU5I1/dS906zspIR93D2SVYXUdNz06/TkPJCkgbaWfqWWrqWOurO3oFeqv//w8A "J ‚Äì Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~67~~ 66 bytes
```
c(paste(rep(c('A',2:10,J<-'J','Q','K'),4),c('S','D','H','C')),J,J)
```
[Try it online!](https://tio.run/##K/pfYfs/WaMgsbgkVaMotUAjWUPdUV3HyMrQQMfLRlfdS11HPRCIvdU1dUw0dYCywUCeCxB7ALGzuqamjpeOl@b/3MSSoswKjYpoQytTo1gdQ2NNropoU2MrU5PY/wA "R ‚Äì Try It Online")
Only one more byte than [digEmAll's golfier solution](https://codegolf.stackexchange.com/a/166648/80010). Inspired by[Giuseppe's solution](https://codegolf.stackexchange.com/a/158100/80010) to [this related challenge](https://codegolf.stackexchange.com/q/158060/80010) - the same Giuseppe who golfed one byte off by answer!
I'm posting separately since it's a slightly different approach taking advantage of the fact that 4 is not a divisor of 13 and that the output does not need to be in any particular order.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~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"}
```
[Try it online!](https://tio.run/##Rc5NS8NAEAbge37Fy5bCblpt1cQP0gpVD6InyaXQ9hA2iR1IN7JJBSn97XEmErw87MzOvIy9@LS2G5Gz1TEvsGjanOrL/WM3youSXIFUr41aqfVUXQs3QiTEwq1wJ9wLD8LVXHwTPoR3JhjiLLTdZz7cxNHOnFKtUmXYl97X3mdleFsSzh25FoeMnP6uKTc4BYC0KOFHWXtowhLzBIQF4ijBZEKGv4Avz3OlVuMGagq7oZ2RndkMDR2oynz1w6WcgjBccYhN/uunoR5Sto5HlpD@ON86Tvyr@0xftEfv@Irg3P0C "C (gcc) ‚Äì Try It Online")
+11 bytes to be more complete thanks to Jakob.
-4 bytes thanks to Zachary
Mostly abusing of preprocessor to compress the suits. Could probably be out-golfed, but is pretty efficient all things considered.
[Answer]
# Javascript (ES6) 77 74 72 bytes
This is a complete program.
```
`J,J,${[..."A23456789JQK",10].map(c=>[..."SDHC"].map(s=>c+s))}`.split`,`
```
[Answer]
# 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");}
```
Approach is to encode the sequences in character arrays.
**Sample Output**
```
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
```
[Try it online!](https://tio.run/##S9ZNT07@/185JTUtMy9VoUAjWbOgtCQ5I7EIyOLKzCtRyE3MzNPQrE7LB4oAhbUKdbSKbJWcXTyClay1iqyLtLU1QXKFtkqORsYmpmbmFpYGXoHeQMlC60KgpIaJha2tVqGmmlqBhomlpk6BBpADIotApLGRpjXQwmINJS8FLyVN69r//wE)
[Answer]
# Oracle SQL, 164 bytes
Not a golfing language but...
```
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
```
[Try it online - SQL Fiddle](http://sqlfiddle.com/#!4/ae2cc8/456)
[Answer]
# [Lua](https://www.lua.org), ~~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'
```
[Try it online!](https://tio.run/##HY3JCsIwFAB/JTwpTeijmC5ukIPoQfQkHouHdBOhJCFNoVD67TF4mNsMM0zS98IPWrajs1/1ia1Y4A4YWHttySw4lhlpNTFijoqE22pjE/4WdIEzYIY5FljiDvd4wCPyLf7rZ@ABK6vmiOdBT1MKr@vtAuw0TjU1aFinWmI7N1lFbOxNmDvqZD10aaNVIx3tKUNAAoz5Hw "Lua ‚Äì Try It Online")
Based on Jo King's code.
As he suggested in the comments, my original answer wasn't valid (I'm still learning how code golf works üò¨), and linked a better and valid answer. Then I made it smaller.
---
### Original solution (156 bytes):
```
r={}s="SDHC"c={"J","Q","K"}t=table.insert for x in s:gmatch"."do for y=1,13 do t(r,(y==1 and"A"or y>10 and c[y-10]or y)..x)end end for _=1,2 do t(r, "J")end
```
```
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
```
I just want to say that I'm new to this Code Golf stuff, so if I'm doing something wrong, feel free to tell me.
I know this answer isn't one of the smallest, I just wanted to challenge myself.
If you have suggestions for reducing my code you can say too. :)
[Answer]
# [Perl¬†6](https://github.com/nxadm/rakudo-pkg), ~~¬†43¬†~~ 42 bytes
```
{|(|(2..10),|<A J Q K>X~ <S D H C>),|<J J>}
```
[Try it](https://tio.run/##K0gtyjH7X1qcqlBmppdszcWVW6mglpyfkqpg@7@6RqNGw0hPz9BAU6fGxlHBSyFQwdsuok7BJljBRcFDwdkOJO6l4GVX@784sVIBpE1D8z8A "Perl 6 ‚Äì Try It Online")
```
{|(|(^9+2),|<A J Q K>X~ <S D H C>),|<J J>}
```
[Try it](https://tio.run/##K0gtyjH7X1qcqlBmppdszcWVW6mglpyfkqpg@7@6RqNGI85S20hTp8bGUcFLIVDB2y6iTsEmWMFFwUPB2Q4k7qXgZVf7vzixUgGkS0PzPwA "Perl 6 ‚Äì Try It Online") from [Jo King](https://codegolf.stackexchange.com/users/76162/jo-king)
## Expanded:
```
{  # 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
}
```
[Answer]
# 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
```
Release Notes:
* V1.0 Initial deploy
* V1.1 Misread the challenge requirements, so switched to a more expensive array `r$`. All the rest of the code is pretty much the same.
* V1.2 Suggestions from @TaylorScott lead to a complete rewrite saving 15 bytes!
**Sample output**
If we add this snippet to our code, we can see what is put into `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
```
**But how?** Well, let me tell you:
```
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.
```
[Answer]
# Pyth, ~~26~~ 25 bytes
```
+ B\JsM*+tSTc"JQKA"1"CDHS
```
Saved a byte thanks to hakr14.  
[Try it here](http://pyth.herokuapp.com/?code=%2B+B%5CJsM%2a%2BtSTc%22JQKA%221%22CDHS&debug=0)
### Explanation
```
+ 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.
```
]