Probability 2 player card game with multiple patterns to win, who has the advantage? $2$ people (C and D) decide to play a computer assisted game.  The computer is programmed to quickly play as many fair hands (using the equivalent of a fair $52$ card deck), until someone wins the hand so the win will appear instantly when they press a button on the keyboard and then it waits for the next keypress for the next game. The computer is necessary because of how infrequent wins are, thus a real deck of cards would take way too long between wins.
The rules are player C can win if he gets $3$ "gapped" $3$ card straights dealt in order.  An A (ace) will be considered the highest rank for both C and D so $A23~567~9TJ$ (T = ten rank) would NOT be a win for C but $234~QKA~789$ would be. There has to be at least a gap of $1$ rank between the $3$ card straights but can be wider as shown in the 2nd example. Note that the individual straights of length $3$ have to be dealt in order but the actual $3$ length $3$ straights don't need to be in relative order (as shown by $234QKA789$).  That is still a win for C and need not be $234789QKA$ (although that would also be a win for C).  The simplest example of a win for C would be something like $234678TJQ$.  This is also the lowest ranked win for C.  The highest rank win for C would be $45689TQKA$.  Remember permutations are allowed such as $89TQKA456$ is also a win but $243678TJQ$ is not.  If you think of each gapped $3$ card straight as a letter.  Such as with $234678TJQ$, X=$234$, Y=$678$, Z=$TJQ$, then valid permutations are XYZ, XZY, YXZ, YZX, ZXY, and ZYX.
For player D to win, $2$ pattern classes are allowed.  Either any $6$ card straight (such as $345678$) or this pattern: $223344$, $334455$, $556677$... $QQKKAA$.
The computer will keep dealing community (shared) cards until either there is a winner of the hand (not likely) or all $52$ cards are depleted (very likely). The cards are reshuffled after each win and after each nonwin (all $52$ cards are depleted).  Permutations are NOT allowed.  The straights and patterns MUST be dealt in order.  For example, $345678$ is a win for D but $357468$ is not, even though they could be the same exact cards.  Suits are irrelevant for the straights and other winning patterns.  Any suits are allowed.
So it is a rainy day and they play many hundreds of winning hands to see who gets more wins.  The question is who has the mathematical advantage and by how much? A hand that ties can be ignored as they will not count that hand and will continue play.  Neither player has any knowledge of the expected probability and both just play on a "hunch" based on the observed patterns to win which they are told about.
The $300$ bounty ends Monday night (Aug 22nd) around 11:59PM (Eastern time) already including the $24$ hour grace period.  Other simulations are encouraged but also math solutions or partial math solutions (like how to set it up properly).
Sample data of $3$ million random shuffles can be downloaded here for test purposes and/or analysis for mathematical solutions.:
https://drive.google.com/file/d/0BweDAVsuCEM1amhsNmFITnEwd2s/view
Format is $52$ bytes of data per line and $2$ more bytes for the end of line so $54$ bytes total per line, $3$ million lines.  "$2$" = rank $2$, "$3$" = rank $3$... "T" = rank $10$....   All cards are represented by this set of ranks: "$23456789TJQKA$".  There are $4$ of each rank in each shuffle (suits are irrelevant in this card game).
Where are the mathematical attempts at solving the probabilities of this card game?  How about even some partial solutions like take the winning D patterns and compute the probability of a D win if D was the only player, subtracting out the overcounting cases where $2$ (or more) of those patterns can appear in the same shuffled deck.  For example, if we get something like $234567223344$
 A: This is a 2nd answer for those of you that are considering using computer simulation or a combination of that and math.  If you use a computer language that has good string functions like I did, a simple algorithm is to put the patterns "$234$", "$345$", "$456$"... "$QKA$" in an array.  I indexed them from $2$ to $12$ to keep is simple cuz the index matches the lowest ranked card in the $3$ card straight.  Then just run $3$ nested loops, call them i, j and k. The outermost loop index i goes from $2$ to $4$ since one of those patterns MUST appear for a C win.  That is, either $234$, $345$, or $456$ MUST appear for C to win.  The middle loop (j) iterates from (i+$4$) to $8$. Notice this middle loop never goes higher than $8$ cuz we need room for the gap and then the final $3$ card straight.  The innermost loop (k) iterates from (j+$4$) to $12$.  If a $3$ card straight is found from each of the $3$ groups (thus indicating they are all gapped by at least $1$ rank), then that is a win for player C unless a $6$ card straight is also found in the deck, in which case I just compare final card positions of both to determine who really won the hand.  Most of the time this is not necessary cuz there is only $1$ candidate winner which is the actual winner.
D wins are also put in an array and the entire shuffled deck is scanned for them.  Examples would be DW[$1$] = "$234567$"  DW[$2$] = "$345678$"....  Of course since multiple D winning patterns may appear in the same shuffled deck, I ultimately choose the one with the lowest finishing card position.  For example, $345678A234567$ is a "double" candidate win for D but the winning sequence is $345678$ and NOT $234567$ although my simulation is programmed to search for $234567$ first.
So to be clear, using strings is a very good way to simulate this card game cuz many languages have good fast string searching functions built in and it makes the coding much simpler in my opinion as an "old school" programmer.
Just to be clear, my sim prog shuffles and scans the entire deck but when a candidate win is found, if it is a solo candidate win (such as player C only), then the win is awarded and the card position is recorded for averaging later.  An interesting scenario happens when there are $2$ candidate wins in the same $52$ card deck.  A very simple example would be $234678TJQ234567...$ Here, my program will detect possible (candidate) wins for both C and D but will see that the C win happened first and award the win only to C.  Reason I scan the entire deck is cuz it is simpler and it also allows me to track additional interesting info like dual candidate winners in the same hand which is rare, and of those few, some ties appear which are even more rare.
Someone asked about my shuffle routine so I will describe it here.  I start with the deck initialized to rank order.  The array (call it A here) is such that A[$1$] = '$2$', A[$2$] = '$2$', A[$3$] =  '$2$', A[$4$] = '$2$', A[$5$] = $3$... A[$52$] = 'A'.
The goal is to choose a random card from the deck and place it at the "tail end" of the deck.  This is a variation of the Fisher-Yates shuffle. So 1st iteration of shuffle will grab a random number from $1$ to $52$ (inclusive).  That number will be the position of the card in array A we want to place at the "end" of the deck.  So for example, if the random number is $5$, we already know that A[$5$] = '$3$' (a rank 3 card is there) so we do the swap.  Next we only concentrate on the first $51$ cards in the deck so we grab a random number from $1$ to $51$ and do another swap, but this time with the 2nd to last card in the deck which is our new "tail end" of the deck.  This process continues until the deck size we are concentrating on is only size $1$.  In that case we can just exit the shuffle cuz now all $52$ cards will have had an equal opportunity to be in any of the $52$ card positions.  The Rand() function I call is a library function  so I have little control over it but I have been using it in many card and dice simulation programs and it has agreed with others results so it seems very reliable, accurate, and fast.  I am not sure how it works internally but it seems to work very well, showing no bias.
