Petit challenge PowerQuery

Hey,

@Zebulon,

L’idée c’est prendre caractère par caractère et tester si il est pareil que le précédent à savoir une lettre de « a » à « z » minuscule, de « A » à « Z » majuscule ou si c’est un chiffre de « 0 » à « 9 ».

On convertit chaque chaîne en texte et la fonction Text.ToList permet d’obtenir la liste de tous les caractères de chaque chaîne.

La fonction List.Accumulate est appropriée pour ce type de cas car son caractère récursif va permettre d’analyser chaque caractère un à un avec le précédent : (s,c).

Donc on part d’une chaîne de texte vide et pour chaque élément de la liste de caractère on va reconstruire la chaîne en y ajoutant une virgule lors de chaque passage de minuscule à majuscule ou chiffre, de majuscule à minuscule ou chiffre, de chiffre à minuscule ou majuscule.

Donc pour récupérer le caractère précédent on utilise la fonction Text.End(s,1) avec s qui est la chaîne de caractère qui se reconstruit au fur et mesure.

Est ce que c’est plus clair ?

@+

Bonjour,

Un peu plus, il faut que je teste cela plus en avant.

En tout cas merci pour le challenge et les explications.

Bonne journée.

Bonjour à tous,

Et hope le petit challenge du dimanche soir

Certes dans les faits on ne voudra jamais faire ça mais ça permet de garder la main

@+

Bonjour à tous !

Et hop ! une rapide petite contribution :

let
    fnTransf = (NomTable as table) as table =>
        let
            Pivot = Table.Pivot(NomTable, List.Sort(List.Distinct(NomTable[Data])), "Data", "Value"),
            ColRenom = Table.RenameColumns(Pivot,{{"Name", Date.ToText(Pivot[Date]{0})}}),
            DemoteHeaders = Table.DemoteHeaders(ColRenom)
        in  Table.RemoveColumns(DemoteHeaders,{"Column1"}),
    Source = Excel.CurrentWorkbook(){[Name="tSource"]}[Content],
    Types = Table.TransformColumnTypes(Source,{{"Date", type date}}),
    GroupBy = Table.Group(Types, {"Date"}, {{"all", each fnTransf(_)}}),
    Combine = Table.Combine( GroupBy[all]),
    ColRenom = Table.RenameColumns(
        Combine,
        let 
            a=Table.ColumnNames(Combine) 
        in List.Transform(a,each {_,"Column"& Text.From(List.PositionOf(a,_)+1)}))

in
    ColRenom

Hello,

Une petite contribution également

let
    Source = Excel.CurrentWorkbook(){[Name="tSource"]}[Content],

    Type = Table.TransformColumnTypes(Source,{{"Date", type date}}),

    Pivot = Table.Pivot(Type, List.Distinct(Type[Data]), "Data", "Value", List.Sum),

    GroupBy = Table.Group(Pivot, {"Date"}, {{"tbl", each [
                a = List.Distinct([Date]) ,
                b = Table.FromRows({
                                    a & 
                                    List.Skip(Table.ColumnNames(_),2)} & 
                                    Table.ToRows(Table.RemoveColumns(_,{"Date"}))
                                  )
                                                        ][b]
                                            }}),

    Combine = Table.Combine(GroupBy[tbl])
in
    Combine

@+

Hello à tous,

Voici un autre petit challenge auquel j'ai participé.

Source LinkedIn encore

Petite précision, il faut que la solution puisse être adaptable dans le sens ou si j'ai des nouvelles références en colonne qui sont ajoutées il faut que ce soit pris automatiquement. Dans l'exemple nous avons 2 colonnes pour chaque groupe de référence mais il pourrait y en avoir plus

@+

Bonjour,

Solution simple, quasi exclusivement avec l'interface :

let
    Source = Excel.CurrentWorkbook(){[Name="tData"]}[Content],
    Décroise = Table.UnpivotOtherColumns(Source, {"Date"}, "Attribut", "Valeur"),
    Transforme = Table.TransformColumns(Décroise, {{"Attribut", each Text.Start(_, 4)&"00", type text}}),
    Pivot = Table.Pivot(Transforme, List.Distinct(Transforme[Attribut]), "Attribut", "Valeur", List.Sum)
in
    Pivot

Mais j'imagine que le but est de faire ça sans Dépivoter/Pivoter à nouveau...
Je vous laisse travailler à une solution plus cool.

A+

Hey,

J'étais arrivé sur la même solution mais du coup je suis parti sur une seconde solution avec l'argument GroupKindLocal histoire de voir plusieurs manières de faire

La voici

let
 Source = Excel.CurrentWorkbook(){[Name="tSource"]}[Content],
 Unpivot = Table.UnpivotOtherColumns(Source, {"Date"}, "Attribut", "Valeur"),
 Sort = Table.Sort(Unpivot,{{"Date", Order.Ascending}, {"Attribut", Order.Ascending}}),
 GroupBy = Table.Group(Sort, {"Date", "Attribut"}, {{"Value", each List.Sum(_[Valeur])}} , GroupKind.Local , (x,y) => Number.From( Text.Start(y[Attribut],4) <> Text.Start(x[Attribut],4))),
 Pivot = Table.Pivot(GroupBy, List.Distinct(GroupBy[Attribut]), "Attribut", "Value", List.Sum)
in
 Pivot

@+

Bonjour à tous !

Une autre approche :

let
    Source = Excel.CurrentWorkbook(){[Name="tData"]}[Content],
    NomsCol = List.Alternate(List.Skip(Table.ColumnNames(Source)),1,1,1),
    Cumul = Table.AddColumn(Source, "Cumul", each Table.FromRows({List.Transform(List.Split(List.Skip(Record.ToList( _)),2), each List.Sum(_))},NomsCol))[[Date],[Cumul]],
    Expand = Table.ExpandTableColumn(Cumul, "Cumul", NomsCol)
in
    Expand

Salut les excelliens

Un petit défi pour vous pour lister l'ensemble des combinaisons qui permettent d'arriver à un certains résultat en fonction d'une liste de nombre

N'hésitez pas avec les propositions

@+

Hello,

Une précision, si ma liste de nombre est 1,2,3,4 voici les différentes possibilités, je ne vais pas retrouver 1-2-3 et 3-2-1 dans ma liste

image

@+

Bonjour à tous 🙂

Si je comprends bien ton raisonnement, tu veux ressortir toutes les combinaisons de 1 parmi 9, 2 parmi 9 .... etc jusqu'à 9 parmi 9, faire la somme de chacune d'entre elles et ne retenir celles dont la somme est égale à la valeur cible soit 207 dans l'exemple.

Et tout ça via Power Query évidement.

klin89

Hello,

Pas sur de comprendre ce que tu sous entends par « parmi 9 » mais l’objectif c’est d’avoir les différents couples permettant d’arriver à 207 en effet. Mais déjà juste avoir l’ensemble des combinaisons possibles d’une liste de valeur serait bien, la logique derrière n’est pas spécialement évidente.
@+

Bonjour BAROUTE,

C'est un challenge que tu proposes et dont tu as la solution ?

Hello,

Je suis proche du but dans la compréhension du modèle mais c'est tordu, et je m'aide des forums...

Quand je l'aurai je vous la transmettrai

@+

Bonjour,

Un essai :

let
    Source = Excel.CurrentWorkbook(){[Name="Tableau1"]}[Content][Numbers],
    N = List.Count(Source),
    AllCombin = 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 Source{j}
                                else null
                    )
        ),
    EnTable = Table.FromList(AllCombin, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
    ListCombin = Table.TransformColumns(EnTable, {"Column1", each Text.Combine(List.Transform(List.Sort(_), Text.From), ","), type text}),
    Filter = Table.SelectRows(ListCombin, each ([Column1] <> "")),
    Duplication = Table.DuplicateColumn(Filter, "Column1", "Column1 - Copier"),
    Replace = Table.ReplaceValue(Duplication,",","+",Replacer.ReplaceText,{"Column1 - Copier"}),
    Evaluate = Table.TransformColumns(Replace,{{"Column1 - Copier", each Expression.Evaluate(_, #shared)}}),
    Filter_Cible = Table.SelectRows(Evaluate, each ([#"Column1 - Copier"] = Target)),
    SupCol = Table.RemoveColumns(Filter_Cible,{"Column1 - Copier"})
in
    SupCol

Hello OOoiste,

Du coup on a récupéré la même chose. Petit question, est ce que tu aurais la logique mathématiques derrière l'étape AllCombin ?

@+

Hello OOoiste,

Du coup on a récupéré la même chose. Petit question, est ce que tu aurais la logique mathématiques derrière l'étape AllCombin ?

@+

Je n'ai pas encore eu le temps d'analyser...

Sinon, après AllCombin, j'ai fait long juste pour pouvoir m'amuser avec Expression.Evaluate
ceci est plus simple :

EnTable = Table.FromList(AllCombin, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
    Sum = Table.AddColumn(EnTable, "Sum", each List.Sum([Column1])),
    ListCombin = Table.TransformColumns(Sum, {"Column1", each Text.Combine(List.Transform(List.Sort(_), Text.From), ","), type text}),
    Filter = Table.SelectRows(ListCombin, each ([Column1] <> "") and ([Sum] = Target)),
    SupCol = Table.RemoveColumns(Filter,{"Sum"})
in
    SupCol

J'avais déjà utilisé la version PQ de Evaluate avec des fonctions ou des types, je n'ai donc pas pu m'empêcher de le faire avec une simple addition.

A+

Hello,

@OOoiste, avec cette ligne ça suffit pour avoir le résultat après ton étape AllCombin

= Table.FromColumns({List.Select(List.Transform( AllCombin , each Text.Combine(List.Transform(_,Text.From),"+")),  (x)=> (try Expression.Evaluate(x) otherwise 0) = Target)})

@+

Bonjour à tous !

Une approche légèrement différente, tout en reprenant le cœur abscons de la requête, qui me semble assez véloce :

let
    Source = Excel.CurrentWorkbook(){[Name="Tableau1"]}[Content][Numbers],
    N = List.Count(Source),
    AllCombin = List.Buffer(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 Source{j}
                                else null
                        )
        )),
    Final = List.Transform(List.Select(AllCombin, each List.Sum(_)=Target), each Text.Combine(List.Transform(List.Sort(_), Text.From),", "))
in
    Final
Rechercher des sujets similaires à "petit challenge powerquery"