下面的算法有三个部分：
1.使用递归cte，将引脚命中标准化，添加standing引脚，并找到standing和hit引脚运行之间的间隙。
1.然后，在frame_results中，将差距id s分组，并记录间隙的大小和间隙的类型（直立或撞击销）。
1.最后，在主查询中，有一个检查，以确保击中头部引脚，并且在长度为2或更长的站立引脚运行之后直接存在命中引脚，或者在两个或更多个站立引脚之间存在命中引脚。

with recursive cte(gameid, thrownum, frame, pinsHit, ps, ct, rid, f) as (
   select r.*, case when cast(regexp_substr(r.pinsHit, '^\\d+') as float) = 1 then regexp_replace(r.pinsHit, '^\\d+,*', '') else r.pinsHit end, 1, 
     cast(regexp_substr(r.pinsHit, '^\\d+') as float) = 1, cast(regexp_substr(r.pinsHit, '^\\d+') as float) = 1
   from rounds r
   union all
   select c.gameid, c.thrownum, c.frame, c.pinsHit, 
      case when cast(regexp_substr(c.ps, '^\\d+') as float) = c.ct + 1 then regexp_replace(c.ps, '^\\d+,*', '') else c.ps end, c.ct + 1, 
      c.rid + (case when cast(regexp_substr(c.ps, '^\\d+') as float) = c.ct + 1 then c.f != 1 else c.f != 0 end), 
     coalesce(cast(regexp_substr(c.ps, '^\\d+') as float) = c.ct + 1, 0)
   from cte c where c.ct + 1 < 11
),
frame_results as (
   select c.gameid, c.thrownum, c.frame, c.rid, count(*) c1, max(c.f) m1, max(c.ct) m2 
   from cte c group by c.gameid, c.thrownum, c.frame, c.rid
)
select r.*, cast(regexp_substr(r.pinsHit, '^\\d+') as float) = 1 and 
   exists (select 1 from frame_results r1 where r1.gameid = r.gameid and 
     r1.thrownum = r.thrownum and r1.frame = r.frame and 
     ((r1.c1 > 1 and r1.m1 = 0 and r1.m2 + 1 < 11) or r1.rid >= 4)) is_split
from rounds r

字符串
See fiddle（包括其他测试用例）

我想提出一个解决方案，可以简单地应用于确定固定引脚组合是否为Split。
有1024种可能的组合瓶在保龄球场。
这些组合中的一些被称为Split。根据术语的含义，很明显，剩余的数字应该被分成2个或更多的组。但是，还有一些附加条件，如必须将Pin 1 hited。在玩家使用的术语中，有一些组合形式上不符合条件，但也被称为Split。一些最常见的，以及继续游戏的最难的组合，都有自己的名字。
因此，我建议创建一个可能的组合表，并在其中确定此组合是否为拆分。有这样一个表，解决问题相当简单。

select r.*,isSplit
  ,pinsStand,vHit,vStand,SplitName,Id
from rounds r
left join Splits s on r.pinsHit=s.pinsHit
order by gameid,thrownum,frame;

字符串
例如
| 配子体|掷出号码|帧|pins点击次数|是拆分|引脚支架|vHit| vStand|分割Name| ID|
| --|--|--|--|--|--|--|--|--|--|
| 1 | 1 | 1 |一、二、三、六、七、九、十| 0 |四、五、八| 871 | 152 || 871 |
| 1 | 1 | 2 |一、二、四、五、六、七、八、九| 1 |三、十| 507 | 516 |婴儿裂开| 507 |
| 1 | 1 | 3 |一、二、三、五、八、九| 1 |四、六、七、十| 407 | 616 || 407 |
| 1 | 1 | 4 |1、4、5、6、7、8、9、10位| 0 |二、三| 1017 | 6 || 1017 |
| 1 | 1 | 5 |一、二、三、四、五、八、十| 1 |六、七、九| 671 | 352 || 671 |
| 1 | 1 | 6 |1、2、3、4、5、6、7、8、9、10位| 0 || 1023 | 0 || 1023 |
| 1 | 1 | 7 |1、2、3、4、5、6、8、9、10位| 0 | 7 | 959 | 64 || 959 |
| 1 | 1 | 8 |一、二、三、八、十| 0 |四、五、六、七、九| 647 | 376 || 647 |
| 1 | 1 | 9 |一、二、五、八| 1 |三、四、六、七、九、十| 147 | 876 |希腊主教座堂| 147 |
这样一个表Splits可以这样创建和填充：
1.定义引脚和引脚邻域。这是我们将放置standPins集合元素的字段

create table pins(pin int);
insert into pins values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10);
create table PinLink (pin1 int,pin2 int);
insert into PinLink values
 (1,2),(1,3)
,(2,1),(2,3),(2,4),(2,5)
,(3,1),(3,2),(3,5),(3,6)
,(4,2),(4,5),(4,7),(4,8)
,(5,2),(5,3),(5,4),(5,6),(5,8),(5,9)
,(6,3),(6,5),(6,9),(6,10)
,(7,4),(7,8)
,(8,4),(8,5),(8,7),(8,9)
,(9,5),(9,6),(9,8),(9,10)
,(10,6),(10,9)
;

型
2.并检查这个无向图上集合的完全连通性。
也许这才是任务中最有趣的部分。

create table Splits(id int,vHit int,pinsHit varchar(30),vStand int
  ,pinsStand varchar(30),standCount int,isSplit int,SplitName varchar(30));

 SET SESSION cte_max_recursion_depth = 1024;

insert into Splits (id,vHit,vStand,pinsHit,pinsStand,standCount,isSplit,SplitName) 
with recursive  r as(
  select 0 
  union all
  select v+1
  from r where v< 1023
)
select id,vHit,vStand
  ,case when standCount<10 then left(pinsHit,char_length(pinshit)-0) 
   else pinsHit
   end pinsHit
  ,case when standCount>0 then left(pinsStand,char_length(pinsStand)-0) 
   else pinsStand
   end pinsStand
  ,standCount
  ,0 isSplit
  ,'' SplitName
from(
select
  v id,v vHit, ~v&1023 vStand 
  ,concat_ws(','
   ,case when (v&1)>0 then '1' end 
  ,case when (v&2)>0 then '2' end  
  ,case when v&4>0 then '3' end  
  ,case when v&8>0 then '4' end  
  ,case when v&16>0 then '5' end  
  ,case when v&32>0 then '6' end  
  ,case when v&64>0 then '7' end  
  ,case when v&128>0 then '8' end  
  ,case when v&256>0 then '9' end  
  ,case when (v&512)>0 then '10' end  
  ) pinsHit
  ,concat_ws(','
   ,case when v&1=0 then '1' end 
   ,case when v&2=0 then '2'end  
   ,case when v&4=0 then '3'end  
   ,case when v&8=0 then '4' end  
   ,case when v&16=0 then '5' end  
   ,case when v&32=0 then '6' end  
   ,case when v&64=0 then '7' end  
   ,case when v&128=0 then '8' end  
   ,case when v&256=0 then '9' end  
   ,case when v&512=0 then '10' end  
   )  pinsStand
  ,10 - bit_count(v) standCount
from r
) tmp
;
-- some examples 
select * from Splits  
where vHit in(871,507,407,1017,671,1023,959,647,147,576)  
order by id;

型
1.彻底检查连通性。
我们取集合中的第一个元素，然后用递归查询遍历树。如果结果是遍历了集合中的所有元素，则集合在此图上是完全连通的，并且组合不是Split。否则，它们被称为disconnected- Split。

with recursive rG as(
select 0 lvl 
   ,left(pinsStand,locate(',',concat(pinsStand,','))-1) head
   ,cast(left(pinsStand,locate(',',concat(pinsStand,','))-1) as char) St1
  ,id,pinsHit,pinsStand,vStand
--  ,cast(left(pinsStand,locate(',',concat(pinsStand,','))-1) as signed) p1
  ,cast(left(pinsStand,locate(',',concat(pinsStand,','))-1) as signed) p2
  ,concat(left(pinsStand,locate(',',concat(pinsStand,','))-1),',') sPath
from Splits  where standCount>1
 union all
select lvl+1 lvl , head
  ,cast(pl.pin2 as char) St1
  ,id,pinsHit,pinsStand,vStand
  -- ,pl.pin1
  ,pl.pin2
  ,cast(concat(sPath,cast(pl.pin2 as char),',') as char) sPath
from rG  inner join PinLink pl on  pl.pin1= St1
  and locate(concat(pl.pin2,','),concat(pinsStand,','))>0
  and locate(concat(pl.pin2,','),spath)=0
  where lvl<11
)

update Splits 
join (
  select id,pinsHit,pinsStand
    ,group_concat(p2 order by p2 separator ',') gap
    ,case   -- update 2 - check pin1 is stand 
         when locate('1,',concat(pinsStand,','))>0 then 0 
         when pinsStand<>group_concat(p2 order by p2 separator ',') then 1
     else 0
     end fSplit
  from (
    select distinct head,id,pinsHit
       ,pinsStand
       ,vStand,p2 
    from rG 
    )rG
   group by id,pinsHit,pinsStand
)y on y.id=Splits.id
  set isSplit=case when standCount>1 then fsplit else 0 end
;
update Splits
  set SplitName=
    case when pinsStand='7,10' then 'goal posts, bedposts, or snake eyes'
         when pinsStand in('7,9','8,10') then 'Cincinnati'
         when pinsStand in('5,7','5,10') then 'Woolworth/Kresge/Dime store'
         when pinsStand in('5,7,10') then 'Sour apple, Lily, Full Murray, or Three wise men'
         when pinsStand in('2,7','3,10') then 'Baby split or Murphy'
    else SplitName
  end
;

型
表已准备好。可以创建一次表并将其存储在数据库中。

select * from Splits  
where vHit in(0,871,507,407,1017,671,1023,959,647,147,576)  
order by id;

型
| ID| vHit| pins点击次数|vStand|引脚支架|站计数|是拆分|分割Name|
| --|--|--|--|--|--|--|--|
| 0 | 0 || 1023 |1、2、3、4、5、6、7、8、9、10位| 10 | 0 ||
| 147 | 147 |一、二、五、八| 876 |三、四、六、七、九、十| 6 | 1 ||
| 407 | 407 |一、二、三、五、八、九| 616 |四、六、七、十| 4 | 1 ||
| 507 | 507 |一、二、四、五、六、七、八、九| 516 |三、十| 2 | 1 ||
| 576 | 576 |七、十| 447 |一、二、三、四、五、六、八、九| 8 | 0 ||
| 647 | 647 |一、二、三、八、十| 376 |四、五、六、七、九| 5 | 0 ||
| 671 | 671 |一、二、三、四、五、八、十| 352 |六、七、九| 3 | 1 ||
| 871 | 871 |一、二、三、六、七、九、十| 152 |4、5、8个| 3 | 0 ||
| 959 | 959 |1、2、3、4、5、6、8、9、10位| 64 | 7 | 1 | 0 ||
| 1017 | 1017 |1、4、5、6、7、8、9、10位| 6 |二、三个| 2 | 0 ||
| 1023 | 1023 |1、2、3、4、5、6、7、8、9、10位| 0 || 0 | 0 ||
Fiddle here和updated
备注1.我考虑的是Split = disconnected
更新2。关于vHit和vStand。我使用数字来方便，简洁地指定组合。
我们可以用从0到1023的数字或10位的二进制数来表示10个管脚的任意组合，管脚{1，3，5，7}的集合用二进制记数法表示为数字0001010101，其中1 - standPin，0 - hitPin。
另一示例

standPins      ({7,5,4,2})
   --bit number 987654321    
{2,4,5,7}     =0001011010 =hex 0x05A=0+2+0+8+16+0+64+0+0=90=vStand.  
And on the contrary, if hitPins 
{1,3,6,8,9,10)=1110100101 =hex 0x3A5=1+0+4+0+0+32+0+128+256+512=933=vHit.

All pins{1,2,3,4,5,6,7,8,9,10}=1111111111=0x3FF=1023
Empty{}=0000000000=0x000=0
``
hitPins=1023^standPins (XOR operation), hitPins+standPins=1023
Numbers from 0 to 1023 describe all possible combinations of 10 pins

型

我有一个解决方案，它使用管脚集拓扑结构（10行种子数据）来构建构成分割的上/下管脚组合（24行）的短列表。然后，可以将这些短列表与任何可能的管脚组合（2^10 = 1024种可能性）进行比较，以确定该组合是否构成分割。

• • 策略：**逻辑采用了与已发布的定义不同的方法。它将图钉视为多米诺骨牌，只会向后直落，并击中紧随其后的两个，也许还有第三个向后直落（双木）。如果在前面的多米诺骨牌组附近存在一个可以击倒所有剩余多米诺骨牌的多米诺骨牌，我们就没有分裂。2 - 4 - 5 - 7 - 9和3 - 5 - 6 - 8 - 10（5个图钉的V形图案）组合是例外。根据规则1，这些组合被视为分裂，因此我们也有测试同一行中缺失的图钉的逻辑。我们还包括一个覆盖所有其他组合的头图钉检查。

某些参考情况可能与参考情况本身不构成分割的管脚组合匹配，但这仅发生在至少一个其它规则可能适用于其它管脚的布局中。例如，对于4 - 5 - 7 - 8 - 9管脚集，"7 - 9，缺少2"参考分割将匹配。即使引脚7和9被完全覆盖，并且是集群的一部分。但是，"4 - 5缺失2"参考案例也匹配，所以这仍然是一个分裂。
其逻辑概括如下：
1.定义一组10个管脚，以及相关的位掩码位置和表示管脚位置的3轴坐标值-从前到后、对角线从左到右和对角线从右到左。
1.对于每个引脚组合（不包括头引脚），使用坐标来找到公共前导/覆盖引脚，以及到该公共前导引脚和从该公共前导引脚开始的所有中间引脚。如果两个当前引脚在同一行上，也包括在同一行中的任何管脚。所选的管脚成为"上管脚"，而所有其他的（不包括上引脚）成为"下引脚"。如果下引脚集为空，则此引脚组合不能为拆分，并且可以跳过。所产生的24个参考案例存储在表中。
1.要测试某个特定的引脚组合是否为拆分，请检查参考表中所有（两个）上引脚都存在且至少有一个下引脚不存在的匹配项。如果有匹配项，则正在检查的组合为拆分。还要检查头引脚（引脚1）是否存在，如果存在，则结果始终为不拆分，从而覆盖匹配逻辑。
1.还生成了所有1024个管脚组合的查找表，并为每个管脚组合设置了"已拆分"指示符。
1.一旦定义了上述内容，对任意引脚组合的测试就只是一个简单的表格查找。
管脚组合以整数位的形式存储，并使用按位运算执行比较。
如需演示，请参阅**this MySql fiddle或等效的this SQL-Server fiddle**。
研究结果包括样本案例、以及所有1024种引脚组合的详尽列表（从没有管脚到所有10个管脚都朝上）。结果还包含额外的列，显示上/下管脚列表和剩余管脚组合的可视化。最后一个查询仅是可用于测试其他答案的数据生成器。游戏111包含所有拆分，而游戏222包含所有非拆分。分裂（至少根据我对规则的解释）。
代码并不是最少的。它包含了一些可以做成函数的重复逻辑。它还计算了几个文本结果，这些结果只供参考和调试之用。
定义管脚号/名称/掩码/坐标查找表：

-- Define pins, bit mask value, and 3-axis coordinates
CREATE TABLE Pins (
    PinNumber INT,
    PinName   VARCHAR(100),
    BitMask   INT,  --  Pin 1 = 1, Pin 2 = 2, Pin 3 = 4,... , Pin 10 = 512
    RowNum    INT, -- Row number counting from front
    XCoord    INT, -- Row number counting from left
    YCoord    INT  -- Row number counting from right
);

INSERT INTO Pins
VALUES
    ( 1, '1',    1, 1, 1, 1),
    ( 2, '2',    2, 2, 1, 2),
    ( 3, '3',    4, 2, 2, 1),
    ( 4, '4',    8, 3, 1, 3),
    ( 5, '5',   16, 3, 2, 2),
    ( 6, '6',   32, 3, 3, 1),
    ( 7, '7',   64, 4, 1, 4),
    ( 8, '8',  128, 4, 2, 3),
    ( 9, '9',  256, 4, 3, 2),
    (10, '10', 512, 4, 4, 1);

字符串
生成参考分割数据：

-- Table to hold base set of split cases
CREATE TABLE SplitConditions (
    PinsUp VARCHAR(100),   -- All (both) of these pins are up
    PinsDown VARCHAR(100), -- Any of these pins are down
    PinsUpBitMask INT,
    PinsDownBitMask INT
);

INSERT SplitConditions
SELECT PU.PinsUp,  PD.PinsDown, PU.PinsUpBitMask,PD.PinsDownBitMask
FROM Pins P1
JOIN Pins P2
    ON P2.PinNumber > P1.PinNumber,
LATERAL (
    SELECT
        CONCAT(P1.PinName, ',', P2.PinName) AS PinsUp,
        P1.BitMask + P2.BitMask AS PinsUpBitMask
) PU,
LATERAL (
    SELECT
        GROUP_CONCAT(P3.PinName ORDER BY P3.PinNumber, ',') AS PinsDown,
        SUM(P3.BitMask) AS PinsDownBitMask
    FROM Pins P3
    WHERE P3.PinNumber NOT IN (P1.PinNumber, P2.PinNumber)
    AND (
        ( -- Pins along X axis to the common leading pin
            P3.XCoord = LEAST(P1.XCoord, P2.XCoord)
            AND P3.YCoord >= LEAST(P1.YCoord, P2.YCoord) 
            AND P3.YCoord < GREATEST(P1.YCoord, P2.YCoord)
        )
        OR ( -- Pins along Y axis to the common leading pin
            P3.YCoord = LEAST(P1.YCoord, P2.YCoord)
            AND P3.XCoord >= LEAST(P1.XCoord, P2.XCoord) 
            AND P3.XCoord < GREATEST(P1.XCoord, P2.XCoord)
        )
        OR ( -- Pins between on the same row
            P1.RowNum = P2.RowNum
            AND P3.PinNumber BETWEEN P1.PinNumber + 1 AND P2.PinNumber - 1
       )
    )
) PD
WHERE P1.PinNumber >= 2
AND PD.PinsDownBitMask > 0
ORDER BY P1.PinNumber, P2.PinNumber;

型
通过将命中管脚列表转换为位掩码，然后扫描所有上行管脚匹配和所有下行管脚匹配的任何行的参考数据，计算结果。

SELECT TD.*, S.IsSplit
FROM TestData TD,
LATERAL (
    -- Map pinsHit to bitsets
    SELECT COALESCE(SUM(P.BitMask), 0) AS PinsDownBitMask
    FROM Pins P
    WHERE CONCAT(',', TD.pinsHit, ',') LIKE CONCAT('%,', P.PinName, ',%')
) PD,
LATERAL (
    -- PinsUpBitMask is inverse of PinsDownBitMask
    SELECT 1023 - PD.PinsDownBitMask AS PinsUpBitMask
) PU,
LATERAL (
    -- Check for any maytches in the split reference table
    SELECT (
            PU.PinsUpBitMask & 1 = 0  -- Head pin is down
            AND EXISTS (
                SELECT *
                FROM SplitConditions SC
                WHERE PU.PinsUpBitMask & SC.PinsUpBitMask = SC.PinsUpBitMask -- All
                AND PD.PinsDownBitMask & SC.PinsDownBitMask > 0 -- Any
            )
        ) AS IsSplit
) S;

型
样品结果：
| 配子体|掷出号码|帧|pins点击次数|是否拆分|
| - -|- -|- -|- -|- -|
| 1| 1| 1|一、二、三、六、七、九、十|真|
| 1| 1| 2|一、二、四、五、六、七、八、九|真|
| 1| 1| 3|一、二、三、五、八、九|真|
| 1| 1| 4| 1、4、5、6、7、8、9、10位|真|
| 1| 1| 5|一、二、三、四、五、八、十|真|
生成所有可能引脚组合的参考表，并计算每个组合的IsSplit值。（请注意，以下部分计算数据仅用于调试演示或可视化目的。）

-- Table to hold every possible pin combination, both as lists and as bit maps
CREATE TABLE PinSet (
    PinsUp VARCHAR(100),
    PinsDown VARCHAR(100),
    PinsUpBitMask INT,
    PinsDownBitMask INT,
    Visual VARCHAR(100),
    IsSplit BIT
);

-- Generate data for all combinations
INSERT INTO PinSet
WITH DIgits AS (
    SELECT 0 AS val
    UNION ALL SELECT 1
    UNION ALL SELECT 2
    UNION ALL SELECT 3
    UNION ALL SELECT 4
    UNION ALL SELECT 5
    UNION ALL SELECT 6
    UNION ALL SELECT 7
    UNION ALL SELECT 8
    UNION ALL SELECT 9
),
CTE_Series_0_to_1023 AS (
  SELECT 1000 * D1.val + 100 * D2.val + 10 * D3.val + D4.val value
  FROM DIgits D1, DIgits D2, DIgits D3, DIgits D4
  ORDER BY D1.val, D2.val, D3.val, D4.val
  LIMIT 1024
)
SELECT
    COALESCE(PU.PinsUp, ''),  COALESCE(PD.PinsDown, '' ),
    M.PinsUpBitMask, M.PinsDownBitMask,
    V.Visual, SPL.IsSplit
FROM CTE_Series_0_to_1023 S,
LATERAL (
    SELECT
        S.value AS PinsUpBitMask,
        1023 - S.value AS PinsDownBitMask
) M,
LATERAL (
    -- Check for any maytches in the split reference table
    SELECT (
            M.PinsUpBitMask & 1 = 0  -- Head pin is down
            AND EXISTS (
                SELECT *
                FROM SplitConditions SC
                WHERE M.PinsUpBitMask & SC.PinsUpBitMask = SC.PinsUpBitMask -- All
                AND M.PinsDownBitMask & SC.PinsDownBitMask > 0 -- Any
            )
        ) AS IsSplit
) SPL,
LATERAL (
    SELECT GROUP_CONCAT(P.PinName ORDER BY P.PinNumber, '-') AS PinsUp
    FROM Pins P
    WHERE S.value & P.BitMask > 0
) PU,
LATERAL (
    SELECT GROUP_CONCAT(P.PinName ORDER BY P.PinNumber, '-') AS PinsDown
    FROM Pins P
    WHERE (1023 - S.value) & P.BitMask > 0
) PD,
LATERAL (
    SELECT GROUP_CONCAT(PV.PinVisual ORDER BY P.PinNumber, ' ') AS Visual1
    FROM Pins P,
    LATERAL (
        SELECT CASE WHEN S.value & P.BitMask > 0
            THEN P.PinName ELSE '.' END AS PinVisual
    ) PV
) V1,
LATERAL (
    SELECT CONCAT(
        SUBSTRING(V1.Visual1, 13, 99), '\n'
        ' ', SUBSTRING(V1.Visual1, 7, 5), '\n'
        '  ', SUBSTRING(V1.Visual1, 3, 3), '\n'
        '   ', SUBSTRING(V1.Visual1, 1, 1), '\n'
        ) AS Visual
) V;

型
拆分检查现在只是一个查找：

SELECT TD.*, PS.IsSplit
FROM TestData TD
LEFT JOIN PinSet PS
    ON PS.PinsDown = TD.pinsHit

型
一个有趣的统计数据是，如果你排除了头钉站立的情况，剩下的512个钉组合中只有10%（51）不被认为是分裂。然而值得注意的是，绝大多数分裂组合（如4 - 5 - 6 - 7 - 8 - 9 - 10）将几乎不可能实现是一个真正的游戏。