【问题标题】:Calculating permutations with SQL使用 SQL 计算排列
【发布时间】:2021-06-09 02:30:48
【问题描述】:

在标准 SQL 中,我想生成包含唯一集合的所有各种排列。例如,如何根据乐队成员及其角色列表生成独特的乐队阵容。每个阵容必须包含每个角色一次

所以,鉴于此:

role   |name
-------|--------
singer |dave
singer |sammy
guitar |eddie
bass   |anthony
bass   |wolfgang
drummer|alex

结果将是四个可能的阵容:

role   |name    |lineup
-------|--------|-------
singer |dave    |1
singer |dave    |2
singer |sammy   |3
singer |sammy   |4
guitar |eddie   |1
guitar |eddie   |2
guitar |eddie   |3
guitar |eddie   |4
bass   |anthony |1
bass   |anthony |3
bass   |wolfgang|2
bass   |wolfgang|4
drummer|alex    |1
drummer|alex    |2
drummer|alex    |3
drummer|alex    |4

实际用例要求角色列灵活。所以,我们可以包括keyboard、voilin 的球员,然后阵容就会扮演这个角色。

我正在使用 SQLite 测试解决方案,使用交叉连接并用尽想法。似乎是一个常见的调度问题。有什么想法吗?

澄清一下,结果将有所有可能的组合。所以如果你对上面的结果运行这个 SQLite 查询:

select distinct group_concat(name) combination from result group by lineup

你会得到四个唯一的记录

combination
-------------------------
dave,eddie,wolfgang,alex
dave,eddie,anthony,alex
sammy,eddie,wolfgang,alex
sammy,eddie,anthony,alex

【问题讨论】:

    标签: sql sqlite


    【解决方案1】:

    下面的 SQL 行实现了您想要的输出。只需在 SQL 环境中进行一点编码

    Declare @resultTable Table
    (
      role nvarchar(100),
      name nvarchar(100)
    )
    
    
    -- Keep track of @temp1 record processing
    Declare @role varchar(100)
    Declare @name varchar(100)
    Declare @loopCounter INT = 1
    
    While((Select Count(*) From roleTable)>= @loopCounter)
    Begin
    
      DECLARE @counter INT = 0;
      
    
      Set @role = (SELECT Top 1 role FROM (SELECT ROW_NUMBER() OVER(ORDER BY role desc) AS RoNum , role FROM roleTable) AS tbl WHERE @loopCounter = RoNum)
    
      Set @name = (SELECT Top 1 name FROM (SELECT ROW_NUMBER() OVER(ORDER BY role desc) AS RoNum , name FROM roleTable) AS tbl WHERE @loopCounter = RoNum)
    
      DECLARE @recordCount INT = (Select Count(*) From roleTable where role = @role)
    
    
      if(@recordCount = 1)
      begin
        
        while(@counter < 4)
          begin
            insert into @resultTable values(@role,@name)
             SET @counter = @counter + 1;
          end
      end
      else if(@recordCount = 2)
      begin
        while(@counter < 2)
          begin
            insert into @resultTable values(@role,@name)
             SET @counter = @counter + 1;
          end
      end
      else if(@recordCount = 3)
      begin
        while(@counter < 1)
          begin
            insert into @resultTable values(@role,@name)
             SET @counter = @counter + 1;
          end
      end
      else if(@recordCount = 4)
      begin
        insert into @resultTable values(@role,@name)
      end
    
      
    
      set @loopCounter = @loopCounter + 1
    
     
    End
    
    ;WITH newTable AS (
    SELECT 
    t.role,
    t.name, 
    ROW_NUMBER() OVER (
                       PARTITION BY t.role 
                       ORDER BY role
                       ) AS [lineup]
    FROM @resultTable t)
    select * from newTable
    order by role desc
    

    输出:

    【讨论】:

    • 狼帮呢?他应该在 #2 和 #4 阵容中演奏贝司
    • 我的基于角色的数据库有两个值,“bass”和“bass”。我刚刚输入了正确的输出。
    • 我修改了代码。这段代码可以正常工作。
    • wolfgang 不和戴夫一起演奏贝司
    • (贝斯 |anthony bass |wolfgang)和(歌手 |dave 歌手 |sammy)
    【解决方案2】:

    您可以使用递归 CTE 来构建组合。首先,您需要计算任何角色应存在于完整输出中的次数。这是在prod 和p CTE 中完成的。然后,要构建实际的组合输出列表,您需要从p CTE 中获取值,并将原始输入表(在我下面的代码中命名为lineup)中的记录中的每个唯一角色计数偏移为来自的值p:

    with recursive s as (select row_number() over (order by (select 1)) r, role, count(*) c from lineup group by role),
         l_mod as (select row_number() over (order by (select 1)) r, l.* from lineup l),
         prod(c, v) as (
            select 1, (select s1.c from s s1 where s1.r = 1)
            union all
            select p.c+1, p.v*(select s1.c from s s1 where s1.r = p.c+1) from prod p where p.c < (select count(*) from s)
         ),
         p as (select v from prod order by c desc limit 1),
         new_l(r, role, name, b_c, l_c) as (
            select l.*, 1, (select * from p)/(select s1.c from s s1 where s1.role = l.role) from l_mod l
            union all
            select nl.r, nl.role, nl.name, nl.b_c + 1, nl.l_c from new_l nl where nl.b_c < nl.l_c 
         ),
         final_l as (select row_number() over (order by r) r1, role, name from new_l order by r)
    select l.role, l.name, (select sum(l1.r1 < l.r1 and l1.role = l.role) from final_l l1)+1 from final_l l;
    

    【讨论】:

    • 非常有前途。但是这个解决方案与 meysam 的解决方案有同样的问题。应该生成每个排列。埃迪和亚历克斯在每个阵容中,所以这很简单。两位歌手和两位贝斯手意味着您有 4 种可能的独特组合。 (戴夫和安东尼,戴夫和沃尔夫冈,萨米和安东尼,萨米和沃尔夫冈)。这个逻辑导致只有两个重复的组合。 (戴夫和沃尔夫冈、萨米和安东尼)。
    • @swdev 记录出现的顺序是否重要?情况似乎是这样,因为您似乎将其余的组合一代建立在第一个角色(歌手)上。你能澄清一下吗?另外,您能否阐明四种独特的组合(dave and anthony、dave and wolfgang、sammy and anthony、sammy and wolfgang)如何变成(dave and wolfgang、sammy and anthony)?
    • 我试图在Q中澄清。如果你按阵容分组并组合每个阵容的成员。你可以看看你是否拥有所有的组合。如果您拥有所有记录,则应该是四个唯一记录。
    【解决方案3】:

    Ajax1234 在“您可以使用递归 CTE 构建组合”中是正确的。存储过程也可能有效,但在 SQLite 中不可用。两个答案都没有给我所有独特的组合(也许我没有很好地解释我的问题)。无论如何,这就是我最终使用的并且似乎有效:

    with recursive
    
    -- index the players in each role
    players as
    (
        select
            row_number() over (partition by role order by name) player_num,
            role,
            name
        from t1
    ),
    
    -- index the roles
    roles as
    (
        select row_number() over (order by role) role_num, role, count(*) player_cnt, ln(count(*)) ln_player_cnt
        from players
        group by role
    ),
    
    -- add role_num to players
    players2 AS
    (
        select a.*, role_num
        from players a
        join roles b on a.role=b.role
    ),
    
    -- calculate running permutation count
    --  ex. role#1 has 2 members, running_perm_cnt=2   (2)
    --      role#2 has 1 member,  running_perm_cnt=2   (2 x 1)
    --      role#3 has 5 members, running_perm_cnt=10  (2 x 1 x 5)
    --      role#4 has 3 members, running_perm_cnt=30  (2 x 1 x 5 x 3)
    roles2 as
    (
        select *,
            round(exp(sum(ln_player_cnt) OVER (ROWS UNBOUNDED PRECEDING)),1) running_perm_cnt
        from roles
    ),
    
    -- calculate roles count, permutations count and an
    ttl as (
        select count(*) role_cnt, max(running_perm_cnt) perm_cnt,  max(running_perm_cnt) * count(*) ttl_cnt
        from roles2
    ),
    
    -- use recursive CTE to build the permutations
    perm(n,role_num,player_num,lineup) AS (
    SELECT
        1,
        1,
        1,
        0
    UNION ALL
    SELECT
        n + 1,
        floor(n/perm_cnt)+1,
        (floor(n/(perm_cnt/running_perm_cnt)) % player_cnt) + 1,
        n % perm_cnt
    FROM
        perm, ttl, roles2 c
    WHERE n < ttl_cnt AND c.role_num = floor(n/perm_cnt) + 1
    ),
    
    -- join permutations back to players table so we have names
    select a.*, b.role, b.name
    from perm a
        left outer join players2 b on a.role_num=b.role_num and a.player_num=b.player_num
    

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2014-03-28
      相关资源
      最近更新 更多