[Question]
  [
Related: [Name the poker hand](https://codegolf.stackexchange.com/questions/6494/name-the-poker-hand)
> 
> A straight flush is a poker hand containing five cards of sequential rank, all of the same suit. As part of a straight flush, an ace can rank either above a king or below a two. An ace can rank either high (e.g. A♥ K♥ Q♥ J♥ 10♥ is an ace-high straight flush) or low (e.g. 5♦ 4♦ 3♦ 2♦ A♦ is a five-high straight flush), but cannot rank both high and low in the same hand (e.g. Q♣ K♣ A♣ 2♣ 3♣ is an ace-high flush, not a straight flush).
> 
> 
> 
**Challenge**
Given `N` cards (in any reasonable format) output a truthy value if a straight flush is contained in the poker hand.
**Input**
* `N` numbers of cards. (In any reasonable format)
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)`
*Note: You can take 10 as T*
**Output**
* `Truthy/Falsy` value
**Test case**
```
["AS", "2S", "3S", "4S", "5S"] => true
["3D", "9C", "4S", "KH", "AD", "AC"] => false
["5D", "6D", "7D", "8H", "9D", "10D", "JD"] => false
["JC", "7C", "5D", "8C", "AC", "10C", "9C", "5S"] =>true
[] => false
["AS", "2S", "3S"] => false
["JC", "QC", "KC", "AC", "2C"] => false
[ "2H", "3H", "4H", "5H", "6H", "7H"] => true
```
---
Standard [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") rules apply.
Winning criteria: Shortest code in each lang
  
[Answer]
# [Python 2](https://docs.python.org/2/), 95 bytes
```
lambda a:any(set('A234567891JQKA'[i/4:][:5])<={r['HCSD'[i%4]in r]for r in a}for i in range(40))
```
[Try it online!](https://tio.run/##bY9PC4IwGMbvfYoxCBWC1Gb@oQ4yD6En8Wg7LNISasnyEtFnX@5VKKPLbw97n@fZu/bRnW/CVfV2ry78ejhyxCMuHua96kwjdlfEW/tB6KR5FhtlsyQRKyOPWZvtU5bGjhZJfzsnrBFIsvomkUS95C8tGy0lF6fKJLZlqVY2okO1WeIixguECxe4AhKgh5k1@/gSmNHw49hlmgnkafzj9mC2BvrgDkBDPnFsONJpiKZQBfahgAZjueYQGjeYbjep@fnRvydyYPZV7vY@9QY "Python 2 – Try It Online")
There are 40 possible straight flushes, and this simply checks them all. Chas Brown saved 2 bytes; Jo King saved 4 more.
[Answer]
# [R](https://www.r-project.org/), ~~128 126~~ ~~94~~ 91 bytes
```
function(x,r=rle(outer(y<-chartr("J-X","A2-9TJQKAS",LETTERS),y,paste0)%in%x))any(r$l>4&r$v)
```
[Try it online!](https://tio.run/##dZBPa8JAFMTvfopl1bILGyj5YxRUCIkgSS82OfQaQoJCiOW5KebTp2TUbi3p5XfY9@bNzFJfsbXF@qptCn06N@KqaEN1Kc6tLkl0a6s45qRJ8Nj64IoHtrXK4kMSpFy97bJs955K1anP/KLLVzk/NfOrlHnTCZrVW/eFZl@yr0Qh@CBg3AYd0AW9lEvJpmyzZZracjLBthMNs1Vo9pL9wADvQfijqfL68hB5GC5AH1xClEWGcTQqjeHkg7czy/DuNEhDk8bkNXHHLv7p@7/pAUx@2dnj9WyUcUAX9MAF6O@f/rH/Bg "R – Try It Online")
Original logic shortened considerably by @J.Doe.
Makes a 26 by 26 matrix with mostly nonsense but all the cards (with the Aces repeated at the bottom) contained in rows 10 to 23 of columns 3,4,8 and 24. The matrix is created by concatenating all combinations of the upper case alphabet with letters J through X replaced by A,2-9,T,J,Q,K,A,S via `chartr`. We get C, D, H for free!
The `%in%` flattens the matrix column-wise into a vector. Then see if run-length encoding is greater than 4 for any run of `TRUE` matches.
[Answer]
# JavaScript (ES6), 116 bytes
```
a=>[...'CDHS'].some(s=>a.map(c=>m|=c.match(s)&&2<<"234567891JQKA".search(c[0]),m=0)|(g=k=>k&&1+g(k&k/2))(m|m>>13)>4)
```
[Try it online!](https://tio.run/##jZHJboMwEIbvfQrkA7HV1OybFFtCcEDkFHFEHCwKtAVChGlPvDtNpkuitEp7@Tyy5/9n8Yt4E7Icnw/Tw354rJaaLYLxnFK6iuIkWxVUDn2FJeOC9uKAS8b7mZXHeCqfsCSqam42yLRsx/X8wEh32xBRWYnx@FrmekHWPdPJjBvWMt6qqnHf4FZtNZMQ3M8954ZFuE2WctjLoatoNzS4xjkKM7RWkAm0gDbQyVBBiKJpyjS@VnfXMis@JQXRWbBNTgzhPoy@xLXo5E@1A1ku0AP6oA4gNnQ40vi2SQrFPeCHoR99FgeT6Nzh9zC/zXKzyNV6/tHQDri9aMX8YxsmzG4BbaADdIFecvkRyzs "JavaScript (Node.js) – Try It Online")
### How?
For each suit \$s\$, we convert all cards \$c\$ of suit \$s\$ into a 14-bit bitmask \$m\$, duplicate bit #13 (Ace) to bit #0 to handle the *steel wheel* (A,2,3,4,5) and count the number of consecutive bits. If it's greater than 4, we have a straight flush.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 31 bytes
```
tᵍkᵐ²cᵐ{ps₅~s"A23456789TJQKA"}ᵉ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/v@Th1t7sh1snHNqUDCSrC4ofNbXWFSs5GhmbmJqZW1iGeAV6OyrVPtza@f9/tJKXs5KOgpI5mDR1AZEWYLYjmAwBk5YQ2WCl2P8A "Brachylog – Try It Online")
```
 ᵍ                    Group input by
t                     each element's "tail" (i.e. suit)
kᵐ²                   Knife off the suit character from each element in each array
cᵐ                    Concatenate the elements of each suit array into a string
{               }ᵉ    There exists at least one string in that such that
 p                    it has a permutation
 s₅                   which has a substring of length 5
 ~s                   which is also a substring of
 "A23456789JQKA"
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 66 bytes
```
J
11
Q
12
K
13
A
1$%'¶14
\d+(.)
$1$&$*
O`
^
¶
((?(1)\1.|¶.+)){5}\b
```
[Try it online!](https://tio.run/##K0otycxL/P/fi8vQkCuQy9CIy5vL0JjLkctQRVX90DZDE66YFG0NPU0uFUMVNRUtLv8ErjiuQ9u4NDTsNQw1Ywz1ag5t09PW1Kw2rY1JAhrjzGXuzGXqwmXhzOXozGVo4MxlCeQHAwA "Retina 0.8.2 – Try It Online") Explanation:
```
J
11
Q
12
K
13
```
Convert the picture cards into their values.
```
A
1$%'¶14
```
`A` can be 1 or 14.
```
\d+(.)
$1$&$*
O`
```
Convert the value to unary, and suffix it so that the cards sort properly.
```
^
¶
((?(1)\1.|¶.+)){5}\b
```
Match 5 cards that increase by 1 each time, and ensure that the last increase was exactly 1.
[Answer]
# JavaScript (ES6), 106 bytes
```
h=>h.map(([r,s])=>[..."HSDCA23456789TJQKA"].map(c=>i+=c==s?i*15:c==r?d[i]=1:1,i=0),d=[])|/(,1){5}/.test(d)
```
Accepts an array of string representations of cards, replacing `10` with `T`.
[Try it online!](https://tio.run/##jZC9boMwFIX3PIXFErt1IfyFJJWJEEhFMKFkQwwISHFFIcIoS9tnp3DTQlp16PLZOj73@Oi@pJdUZC0/dw91kxf9ifUls0v5NT1jHLdUJITZsSzLkn/wXEfTDXNtbbbHIAodKQFbxmx@zzLGxJ7fqeZuuLX7POYJU3cq5WxFaM7ihLwrmKrkzfxQ5K4QHc5J3yGGSsRslDW1aKpCrppnfMIloWi5W1JUksfFQlHQE78UNRqnUJaKQiw6HEvOQaJI0oA60ACaBykZ5kaL7o3C1p0fQ3@kA7rjTkYThDXQAm7AuIW7uoIj8CZ/AJEW8Dq7cb8iBx7d@du5zffsr94/IyNgeBOmzS016KQDDaAJXAMtH4zjvpw85x1v6rT619KmCpAT@TeLunK2XIU/iwyW/hM "JavaScript (Node.js) – Try It Online")
# Explanation
Iterates over each card and sets a flag in an array of booleans using an index
computed from the unique combination of its rank and suit. This array is then
stringified to permit matching a pattern of 5 consecutive truthy values.
For example, a hand with a straight flush may produce the following as a
substring of the full string representation of the boolean array: `,,,,1,1,1,1,1,,,,`
Because the first rank value (i.e. A) is offset from the
start of the string, there will always be empty values
preceding all `1`'s in the array, ensuring the string
representation will begin with a `,`
```
h =>
    h.map(([r, s]) =>                         // destructure card value, e.g. "JH" => ["J", "H"]
        [..."HSDCA23456789TJQKA"].map(c =>    // mapping accounts for both positions of 'A'
            i +=                              // increment index value
            c == s                            // if found index of suit...
                ? i * 15                      // buffer so that cards from different suits cannot be confused
            : c == r                          // if found index of rank...
                ? d[i] = 1                    // set flag to denote card is in hand
            : 1,
            i = 0
        ),
        d = []
    ) |
    /(,1){5}/.test(d)                         // implicitly converts to string joined with a ,
```
[Answer]
# Java 10, ~~189~~ ~~167~~ ~~165~~ ~~164~~ ~~160~~ ~~157~~ 156 bytes
```
s->{int i=10;for(;i-->0;)i=s.matches("AKQJT98765432A".substring(i,i+5).replaceAll(".","(?=.*$0\\\\1)").replaceFirst(".1","([HSDC])")+".*")?-2:i;return-1>i;}
```
Takes the input as a single space-delimited String
(i.e. `"AS 2S 3S 4S 5S"`).
-22 bytes thanks to *@OlivierGrégoire*.  
-1 byte thanks to *@AlexRacer*.
[Try it online.](https://tio.run/##jZDdT8IwFMXf@StOGh82ZZWB48MFyNLGEIgkZHtTH8qcWh0dWTsSY/jbsXz5RmbTPtycc29/536KjfA@X792aS60xqOQ6qcBSGWy8k2kGeb7ElgWRZ4JhdSJTSnVO7QbWmFrn73aCCNTzKEwxE57ox87AHLot8K3onRC6XmjVujKoaYrYdKPTDskmi2myaDf6wZ3nXZEqK6W@jDakU15E7i0zNa5JYjy3CGUNIkzHtLrq9azPb5L/vQHWWpjHf7e8jSJOXux6g2h18Qde@17GZaZqUrl@SMZbnfhkXhdLXNLfALfFPIVK5v9lO7pBcI9Br@9RVJW5uP7/lDG39pkK1pUhq6t0@TKUTS1aWK0Y3Ri3MUIYuIetnPZPmXoMQQMfYaIIWEYsJq@k3KGehC5zmqgOnw/1hLNJoi4/aiWK@DocvQ4@hMMOBKOKa9tOmevNf5nLQuG2WEn7XraS/m2je3uFw)
Golfed version of [the code that I've used](https://projecteuler.net/thread=54;page=6#291807) for [Project Euler #54](https://projecteuler.net/problem=54), which I primarily did with regexes (for fun and to learn more about regexes). Without regexes it would probably have been better for performance and easier (probably also applies for golfing this answer; will take a look later on).
**Explanation:**
```
s->{                    // Method with String parameter and boolean return-type
  int i=10;for(;i-->0;) //  Loop `i` in the range (10,0]:
    i=s.matches(        //   If the input matches the following regex:
        "AKQJT98765432A".substring(i,i+5)
                        .replaceAll(".","(?=.*$0\\\\1)")
                        .replaceFirst(".1","([HSDC])")
                        //    Five adjacent cards
        +".*")?         //    With optionally zero or more other characters
         -2             //     Set `i` to -2, which also stops the loops at the same time
      :i;               //   Else: leave `i` unchanged to continue
  return-1>i;}          //  Return whether `i` is not -2 (so whether the loop has finished)
```
**Additional regex explanation:**
* `"AKQJT98765432A".substring(i,i+5)` takes five adjacent cards based on `i`
* `.replaceAll(".","(?=.*$0\\\\1)")` replaces each of those cards with `"(?=.*c\\1)"` (where `c` is the card-character)
* `.replaceFirst(".1","([HSDC])")` will then replace the first `\\1` with `([HSDC])`.
I.e. the total regex to check the Straight Flush for cards in the value-range `[9,5]` will become:  
`^(?=.*9([HSDC]))(?=.*8\\1)(?=.*7\\1)(?=.*6\\1)(?=.*5\\1).*$`  
```
^(?=.*9([HSDC]))(?=.*8\\1)(?=.*7\\1)(?=.*6\\1)(?=.*5\\1).*$
^                                                         $ Match the entire string
 (?=           )(?=      )(?=      )(?=      )(?=      )    Do positive lookaheads to check
                                                            each card
    .*             .*        .*        .*        .*         With optional leading characters
                                                            in front of every card
                                                        .*  And any trailing characters at
                                                            the end of the entire hand
      9              8         7         6         5        The five adjacent values
        [HSDC]                                              With a suit
       (      )       \\1       \\1       \\1       \\1     which is the same for all cards
```
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), ~~145~~ 135 bytes
```
import StdEnv,Data.List
?l=or[isInfixOf(map hd h)['A234567891JQKA']\\a<-l,b<-l,c<-l,d<-l,e<-l,h<-[[a,b,c,d,e]]|tl(nub(map last h))==[]]
```
[Try it online!](https://tio.run/##LY5PC4IwHIbvfYrdTJhBmv2BRII6VEKFx7nDz01zsM3QFQV99paWl@fhvbzvy2QB2qqa32WBFAhthbrVjUGp4Tv9wFswMElEa0axjOqGiHavS/E8lWMFN1RxVLnE2fjBLJwvlqvp4XLcODTLYO1JnPdgPXiPoke19ggBnGOGOS4ofRs51vf81yahNV2fG0WEUpsa6G5EKEakW0gdihFx/MHB4NngsDO1H1ZKuLbW2yd2@9KgBPuHswRT1o36Ag "Clean – Try It Online")
Simplified:
```
? l                                             // function ? taking argument l
  = or [                                        // is at least one of these true
        isInfixOf (map hd h) ['A234567891JQKA'] // do the first characters of a hand appear in this string, in order
        \\ a <- l                               // loop level 1, assigns `a`
           , b <- l                             // loop level 2, assigns `b`
             , c <- l                           // loop level 3, assigns `c`
               , d <- l                         // loop level 4, assigns `d`
                 , e <- l                       // loop level 5, assigns `e`
                   , h <- [[a,b,c,d,e]]         // trick to assign `h`, because it's cheaper than let .. in ..
        | tl (nub (map last h)) == []           // only take the loop iterations where all the suits are the same
       ]
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 37 bytes
Takes input as a 2D array.
```
"AJQKA"i1Aò2 q)øUñÌòÏÌ¦XÌÃËmÎ¬ú5 á5Ãc
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=IkFKUUtBImkxQfIyIHEp+FXxzPLPzKZYzMPLbc6s+jUg4TXDYw==&input=W1siQSIsIlMiXSxbIjIiLCJTIl0sWyIzIiwiUyJdLFsiNCIsIlMiXSxbIjUiLCJTIl1d)
---
## Explanation
```
"AJQKA"                                   :String literal
       i1                                 :Insert at (0-based) index 1
         Aò2                              :  Range [2,10]
             q                            :  Join
              )                           :End insert
               ø                          :Does that string contain any element in the following array?
                U                         :Input
                 ñ                        :Sort
                  Ì                       : By last element (grouping suits together)
                   òÏ                     :Partition between X & Y where
                     Ì                    :  Last element of Y
                      ¦                   :  Does not equal
                       XÌ                 :  Last element of X
                         Ã                :End partition
                          Ë               :Map
                           m              :  Map
                            Î             :   First elements (card values)
                             ¬            :  Join
                              ú5          :  Right pad with spaces to length 5
                                 á5       :  Permutations of length 5
                                   Ã      :End map
                                    c     :Flatten
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 18 bytes
```
Ṣœc5Uµ13R;1wṪ€ȧEµƇ
```
[Try it online!](https://tio.run/##y0rNyan8///hzkVHJyebhh7aamgcZG1Y/nDnqkdNa04sdz209Vg7UHY1kKf7qGGOo5GxiamZuYWlgVegN5Dv7OIR/KhhbqbSo43rDrcfnfRw54z//6OVvJyVdBSUzMGkqQuItACzHcGkoQGYsoRIByvFAgA "Jelly – Try It Online")
Actual input format: list (`[..., ...]`) of lists of 2 integers each; the first is an integer in \$[1,13]\$, for \$A23456789TJQK\$ respectively, and the second is in \$[1,4]\$, for \$CDHS\$ respectively. The TIO link accepts input in the format of the test cases.
Output format: empty list as falsy, non-empty list as truthy.
[Answer]
# [PHP](https://php.net/), 264 bytes
It echos `1` if it is a straight flush and `0` or `null` if not.
If you name the file `1X` then you can save `11 bytes` as you don't need to change `$argv[0]`. Not sure at the moment why the filename can break it.
For some reason the strings `:;<=>` get sorted before the strings `0123456789` by `asort` in TIO even though `:;<=>` have ASCII values 58-62 and `0123456789` have ASCII values 48-57. So if you take the code from the TIO link or below and use [PHPTester](https://phptester.net/) with the following test suite it works.
```
$argb[0] = [".code.tio", "AS", "2S", "3S", "4S", "5S"]; // => true
$argb[1] = [".code.tio", "3D", "9C", "4S", "KH", "AD", "AC"]; // => false
$argb[2] = [".code.tio", "5D", "6D", "7D", "8H", "9D", "TD", "JD"]; // => false
$argb[3] = [".code.tio", "JC", "7C", "5D", "8C", "AC", "TC", "9C", "5S"]; // => true
$argb[4] = [".code.tio", ]; // => false
$argb[5] = [".code.tio", "AS", "2S", "3S"]; // => false
$argb[6] = [".code.tio", "JC", "QC", "KC", "AC", "2C"]; // => false
$argb[7] = [".code.tio", "TC", "JC", "QC", "KC", "AC", "2C"]; // => true
$argb[8] = [".code.tio", "2H", "3H", "4H", "5H", "6H", "7H"]; // => true
for ($z=0; $z<9;$z++){
    $argv=$argb[$z];
    array_shift($argv);
    unset($a,$b,$c,$d,$e,$f,$g,$h,$i);
    $f=false; // not needed, just removes several notices
    // TIO code here
    echo "<br>";
```
TIO Code
```
for($b=count($a=$argv);$b;){$a[0]='1X';$a[--$b]=strtr($a[$b],'ATJQK','1:;<=');$a[]=($a[$b][0]==1?">".$a[$b][1]:1);}asort($a);foreach($a as$c){$d[$c[1]][]=$c[0];}foreach($d as$e){if(4<$g=count($e)){for($h=0;$g>$i=4+$h;){$f|=(ord($e[$i])-ord($e[$h++])==4);}}}echo$f;
```
[Try it online!](https://tio.run/##PY9Pa8MwDMW/yigCx6QZCWRsq6OW4p2601gPg@CD89e51MFJd8ny2T15tLuIJ@snvefRjL44jFQ76yKosLbXyxyBRtCu/@YCKsEX0GWqkGVfTJBMEqgUTrObaUOX1GzZ8Xz6eGdblu1EgYwHTOFtGnYxO2z2m8fbQ6Z2GRernqwLXlyQeatrQ/pBT1CTY1NCTZyiMyRSJdZ/pglMy5ehi/IC@nvklvPl7xMGUwH9HgbMYzAhfveDkXUNMSUMiid3beJYccScsqxrWxsLnfDen6R/lv7pzb9If5T@LP0rtZ@/ "PHP – Try It Online")
[Answer]
# [Kotlin](https://kotlinlang.org), 226 bytes
Used T for 10 so all cards are 2 characters in length.
```
{h:List<String>->val m=List(4){mutableSetOf<Int>()}
for(c in h)m["CDHS".indexOf(c[1])].add("A23456789TJQK".indexOf(c[0]))
var r=0>1
for(b in m){if(b.contains(0))b.add(13)
for(i in 0..9)r=b.containsAll((i..i+4).toList())||r}
r}
```
[Try it online!](https://tio.run/##fVbbbttGEH3XVwyEACERhrr6pkYuBLmpbaUOXBkoCsMPS2llEaZIdnfp2LD1IXk22g/Lj7gzs7xIshQ/jEnunLmemdVdYqIwfm00YKikMHIKs0SBmYcaJslUwm0SzWAyF1Ek41vZq6Hi3JhU9xoNOqdjXxsxuZMPqIUq/iRZNP7JpDZhEutGa/@o0zwk2Jm2ZgVoo0R4OzcwizI9/xUP6fxPGZH/HlyIhURVCWlyJxWg1WmuMtiAApur1DDk2IgwDuNbmIX3kjAToaYakhloiVHFJhQRKBHfeYA50XfypMmlzkLjsxsNqVCGDjeDRVQMYiLRbMxmSF@GaEOBCJJ7iYg7co9FDGSUfMN38y3xYVDCCEHIAjZH6@BI/xaVfnz/F0YkLkmck2g1SVKijEQjHxmxHpdLDsmdNbT34/t/0CXRQUG4Nr0MSHDNqDpb7XgQZIbCjBNTRhokZm7jpCKTmzCu6saVt34x7BdCYQ4v5O2F/L5QEC82hSr@vJzoZqXIhLVx@HnLhwX18vffMfAYLvK2OhiHiB8BqauTWASRJPouhMF6ZCbFTASBjMrM/BHuRZRJCN92FZjtTB0cgJALvU7AIpyzGI3mzxcQZ4tAKmYXx@ODc7YroBx0hS1Hkij6ninmnP4F5hL5pj3QqZhK/D8NxSKJp9rjlhOxoyzAdE89GHtw4sGwLNBvYjJnMxgnRhJLDiWfYlmG2AaTIJfYYIo5Qxfep@HEZEq@t8F7MJhID85xlj24zKSMPXY9QjoTyhngIZ54MCqSuUiM7MHfScbjYMSdRBeAYVzlCl@5CUXq3IXGZxHpvBfFAS4LtKCL9@v6YFz3oN5m2WHZZbk3rt9A/5gaWil3TujoaFipjU5JDvj7YGghM3RbYfb4bJ/lActDxhzxc6vJ/85P6jekDm/x5@ztgKW1dTjMvTF@WIVEMZdWVgPfEtZG3je7HF@yHK24bG9LEz9zVh2WXZZ7LPdZHpy@KefYYM@JQLTdP/L2V1kkcXbTNHosSPdXGPOSnajQSBWKHozniTLcR7o1cCwl8TLCG6HGLH1I0S4O1z2SES8GGplILIIprqIsntBd4dfwCVKVTKTWDg1dD76E2nwaG4W@jl3ow1OtBoDmTuQMRxXneJEZHjItDVNeltNA1M2HwGLsxsgXF5lHek@n/MYTg/PBK00a7SMCCQo4typ8QL8Uh9N14alwOJbm6@zTWWyOHReWqE6uHLaDHsi6ix8ht3BdH56cjut@iCV4@DpjvevWjXvjYwQOK9JffdDudPf2Dw6Prs4vRxvqzRvXrbIXWWQo4jjZXGVF3mUltAVRhYo95dESpGQHtPmKXS6NrUhIli2Ivks0iKTCO@xzYTZNtA657Ab3FhOBMk9mFlWtVw@YExioltI6FaaKmJ1XnuyipdIrXKCaUuxDE46hVRQ4CA1WniK2hcWOcPXQcn7m53tcO03XzSubn1CtWx37ka1xfclY0/ePCuXS8Ya9QRQ5FuHbxnzolo0DcH2TMElcF56fcyN4vqTc0FmtMFxbImFoB1ue83D8IagFVKipwutNlcu7/N1lZ2OBeo5Qt7oHA6XEYzUZxVx8WR@pbYYss1PoW0S7vQ/BIzp/fZr3Vsft4zFPQD@n/tMW4i9raN@ZMOPdxRuSVwzfSWzLau53v3ncYnsBt9d9CmdOsNbNoOwgqYVl41Q/2OgSduhDd6Ulz89qWVPLV854bAeB6q13F8ge9/GmxkJjqBFawn87bqacCbTr8RdUofuzi6lA4PZeQfzsWioQV8XdtILbfh2t@MAvV@t3UoWunkrAepJvHFXXz7qL9loy2@@eAlHeQDus2zRGO9KgBIp1WK4l6hn9dtJpJB65rWS43Hq8GsvrwI6jX2wWHr98DHWxVlKcBOPUr@srS6PY8aRY7Ixc7x2dYXBuBY5ix16x755S9uEu@bjcC/xAg/36Pw "Kotlin – Try It Online")
[Answer]
# [Pascal (FPC)](https://www.freepascal.org/), ~~223~~ ~~216~~ ~~210~~ 209 bytes
```
var a,b:char;c:set of byte;i:byte;begin repeat readln(a,b);i:=pos(b,'HDC')*14+pos(a,'23456789TJQK');c:=c+[i];if a='A'then c:=c+[i+13]until eof;i:=0;while not([i..i+4]<=c)or(i mod 14>9)do i:=i+1;write(i<52)end.
```
[Try it online!](https://tio.run/##LYw7b4MwFIV3/4q72S4UlVfbQKiE3CFKpohsEYMxplyJ2gjcRv311Kk6HZ3Hd2a5Kjk9DrPatm@5gAy7Qo1yKVWxagd2gO7H6RKLP@n0BxpY9Kyl8yL7yTBPcN9Xs11ZF9LDu6D8Ic6Cu5chTdIsf3553V2O5xPl/rZSwRXbEgeQFa2pG7WB/zSI0/bLOJxA2@H@@VTeRpw0GOvYFaMIg6zdV4rbhSF82h7i7G3Hewt@6@nytqDTDPd5wrXpo21LGpI2JGtI3pD6QGpBLoIcBTkLchK/ "Pascal (FPC) – Try It Online")
Uses `T` for 10. Input contains 1 card per line.
Now I golfed it so much that I don't know how it works anymore...
## Explanation:
```
var a,b:char; //for reading cards
    c:set of byte; //this set is for remembering which cards are present in the input
                   //14 numbers used for each suit
    i:byte;
begin
  repeat
    readln(a,b);             //read rank into a, suit into b and a newline
    i:=pos(b,'HDC')*14+pos(a,'23456789TJQK');
        //temporary use i to calculate corresponding number for the card
        //pos() gives 0 if b is not found
        //1st pos() is for the group of numbers for that suit, 2nd pos() is for offset
    c:=c+[i];                //include i into set
    if a='A'then c:=c+[i+13] //if rank is A, include the number at the end of group as well
  until eof;
  i:=0;
  while not(
    ([i..i+4]<=c) //if NOT 5 cards in a row are present...
    and           //while the check is started from 10 (T)...
    (i mod 14<10) //(otherwise, it is checking across 2 different suits)
  )do i:=i+1;     //increment i, otherwise stop
  write(i<52) //if i<=51, there is a straight flush starting at the card corresponding to i
              //(if there isn't a straight flush, i stops at 252 due to i..i+4, I don't know why)
end.
```
]