Power Query Combinaison de lignes en arbres à branches variables et à noeuds fixes

[ritux]

Bonjour,

Je débute en powerquery bloque sur une fonction. Je possède une table à 2 colonnes Casino et Jeton.

Casino	Jeton
1	20
1	30
2	10
2	30
2	60

J'ai ajouté sur Power Query une liste Gain de 0 à 2 (via {0..2}) correspondant aux nombre de jetons qu'on peut gagner.

Je souhaiterais combiner et développer chaque Gain des Jeton de chaque Casino. Le résultat se présenterait comme ceci :

Casino	Jeton	Gain	Combinaison
1​	20​	0​	0-0
1​	30​	0​	0-0
1​	20​	0​	0-1
1​	30​	1​	0-1
1​	20​	0​	0-2
1​	30​	2​	0-2
1​	20​	1​	1-1
1​	30​	1​	1-1
1​	20​	1​	1-2
1​	30​	2​	1-2
1​	20​	2​	2-0
1​	30​	0​	2-0
1​	20​	2​	2-1
1​	30​	1​	2-1
1​	20​	2​	2-2
1​	30​	2​	2-2
2​	10​	0​	0-0-0
2​	30​	0​	0-0-0
2​	60​	0​	0-0-0
2​	10​	0​	0-0-1
2​	30​	0​	0-0-1
2​	60​	1​	0-0-1
2​	10​	0​	0-0-2
2​	30​	0​	0-0-2
2​	60​	2​	0-0-2
2​	10​	0​	0-0-3
2​	30​	0​	0-0-3
2​	60​	3​	0-0-3
2​	10​	1​	1-0-0
2​	30​	0​	1-0-0
2​	60​	0​	1-0-0
…	…	…	…

Finalement c'est comme un développement en arbre, où chaque noeud correspond au numéro de gain, et où chaque branche correspond à un Jeton. Je suis bloqué sur la fonction, je crois juste que ça a avoir avec la notion de tuple.

Si l'un d'entre vous a une piste, ça m'aiderait beaucoup

 

[ritux]

Je progresse mais j'ai encore besoin d'aide.
J'ai trouvé une fonction qui développe toutes les combinaisons possibles.
Si j'ai n=2 lignes A et B, la fonction développe les (n^n)-1=(2^2)-1=3 possibilités soit A;B;AB

let
    /*Define a list function. This is usually done in a separate query.*/
    fn_Subsets = (L as list) as list =>
    let
        N = List.Count(L),
        Subsets =
            List.Transform(
                {0..Number.Power(2, N)-1},
                (i) => List.Transform(
                            {0..N-1},
                            (j) => if Number.Mod(Number.IntegerDivide(i, Number.Power(2, j)), 2) = 1
                                    then L{j}
                                    else null
                        )
            )
    in
        Subsets,

    /*Define sample dataset. Replace with your own data.*/
    Source = Table.FromRows(Json.Document(Binary.Decompress(Binary.FromText("Rcy7DcAgFEPRXVxTBPIvSQjkMwJ6+68RIyG5uJJP41oRPRwi8zDXebAgnmwVE9vEi+1ibleDXJr7d+C+2Sg+bBJfNosfW2D2Aw==", BinaryEncoding.Base64), Compression.Deflate)), let _t = ((type nullable text) meta [Serialized.Text = true]) in type table [ID = _t, Company = _t, Price = _t]),
    SampleData = Table.TransformColumnTypes(Source,{{"ID", type text}, {"Company", type text}, {"Price", Int64.Type}}),
    #"Dernières lignes supprimées" = Table.RemoveLastN(SampleData,9),
   
    /*Logic applying the subsets function and aggregating the results.*/
    #"Grouped Rows" = Table.Group(#"Dernières lignes supprimées", {"ID"}, {{"SubsetList", each fn_Subsets([Company]), type list}}),
    #"Expanded Count" = Table.ExpandListColumn(#"Grouped Rows", "SubsetList"),
    #"Added Custom" = Table.AddColumn(#"Expanded Count", "Company", each Text.Combine([SubsetList], ","), type text),
    #"Filtered Rows" = Table.SelectRows(#"Added Custom", each ([Company] <> "")),
    #"Expanded SubsetList" = Table.ExpandListColumn(#"Filtered Rows", "SubsetList"),
    #"Merged Queries" = Table.NestedJoin(#"Expanded SubsetList", {"ID", "SubsetList"}, #"Dernières lignes supprimées", {"ID", "Company"}, "Expanded SubsetList", JoinKind.LeftOuter),
    #"Expanded Expanded SubsetList" = Table.ExpandTableColumn(#"Merged Queries", "Expanded SubsetList", {"Price"}, {"Price"}),
    #"Aggregate Rows" = Table.Group(#"Expanded Expanded SubsetList", {"ID", "Company"}, {{"Sum_Price", each List.Sum([Price]), type nullable number}, {"No of Supplier", each Table.RowCount(_), Int64.Type}}),
    #"Sorted Rows" = Table.Sort(#"Aggregate Rows",{{"ID", Order.Ascending}, {"No of Supplier", Order.Ascending}, {"Company", Order.Ascending}})
in
    #"Sorted Rows"

J'aimerais adapter cette fonction afin qu'elle ne fonctionne qu'en couple, en ajoutant x=3 versions de A et B, de 0 à 2 soit x^n=3^2=9 possibilités, soit A0B0;A0B1;A0B2;A1B0;A1B1;A1B2;A2B0;A2B1;A2B2

 

[mromain]

Bonjour sanichor,

Ci-dessous un essai si j’ai bien compris (j’avoue, c’est pas très clair...) :

let
    fnBuildCombinaisons = (listGains as list, nbLevels as number) as list =>
        let
            listLevels = {1 .. nbLevels},
            TableLevels = Table.FromRows({List.Transform(listLevels, each listGains)}, List.Transform(listLevels, Text.From)),
            ExpandLevels = List.Accumulate(listLevels, TableLevels, (state, current) => Table.ExpandListColumn(state, Text.From(current))),
            ChangeTypes = Table.TransformColumns(ExpandLevels, {}, Text.From),
            AddColumnResult = Table.AddColumn(ChangeTypes, "Result", each Text.Combine(Record.ToList(_), "-"))
        in
            AddColumnResult[Result],
    testFnBuildCombinaisons = fnBuildCombinaisons({0 .. 2}, 3),
    
    Source = Table.FromRows(Json.Document(Binary.Decompress(Binary.FromText("i4421DEyiNUBUsYgykjHEEJBeWYGsbEA", BinaryEncoding.Base64), Compression.Deflate)), type table [Casino = text, Jeton = text]),
    CombiParCasino = 
        let
            GroupByCasino = Table.Group(Source, {"Casino"}, {{"Combinaisons", each Table.RowCount(_), Int64.Type}}),
            BuildCombinaisons = Table.TransformColumns(GroupByCasino,{{"Combinaisons", each fnBuildCombinaisons({0..2}, _), type list}}),
            ExpandCombinaisons = Table.ExpandListColumn(BuildCombinaisons, "Combinaisons")
        in
            Table.Buffer(ExpandCombinaisons),
    MergeCombi = Table.NestedJoin(Source, {"Casino"}, CombiParCasino, {"Casino"}, "MergeCombi", JoinKind.LeftOuter),
    DevelopCombinaisons = Table.ExpandTableColumn(MergeCombi, "MergeCombi", {"Combinaisons"}, {"Combinaisons"}),
    SortData = Table.Sort(DevelopCombinaisons,{{"Casino", Order.Ascending}, {"Combinaisons", Order.Ascending}, {"Jeton", Order.Ascending}})
in
    SortData

A+