Jetzt hab ich gemessen – und wurde sehr überrascht: diese List.Generate-Methode ist viel langsamer als die beiden anderen mit Table.Group (von denen meine Variante die schnellere ist). M-Code ist dann wohl doch erheblich lahmer als eingebaute Funktionen …

So, Nachtschicht endet und ich lasse das Thema jetzt auch mal ruhen 😉

Oder doch wieder ohne Gruppierung 🙂
Dafür muss das Gruppierungsmerkmal Kst jetzt wieder sortiert sein.
Diese nachfolgende Lösung ist jetzt möglicher Weise die schnellste Variante? (evtl. geht noch was mit Buffern)
Die List.Generate-Funktion ist noch so eine kürzliche Entdeckung, die meinen Blick auf mögliche Lösungsansätze total verändert hat.

let
Source = Excel.CurrentWorkbook(){[Name=“Tabelle1″]}[Content],
GruppenIndex = Table.FromRecords( List.Generate(
() => [ Zähler = 1, Merkmal = Source[Kst]{0}, i = 1],
each [i] <= Table.RowCount(Source),
each [ Zähler = if [Merkmal]=Source[Kst]{[i]} then [Zähler]+1 else 1 , Merkmal = Source[Kst]{[i]}, i = [i]+1 ],
each Source{[i]-1} & [Zähler = [Zähler]]
) )
in GruppenIndex

Grüß Euch,
vielen Dank Euch beiden! Ich hab‘ richtig viel aus den Beispielen gelernt.
Dabei kam ich noch auf eine sogar kürzere (und vermutlich etwas Ressourcen-sparendere) Variante:

let
Source = Excel.CurrentWorkbook(){[Name=“Tabelle1″]}[Content],
Gruppierung_Kst = Table.Group(Source, {„Kst“}, {{„Alle“, each _, type table [Kst=nullable number, Bereich=nullable number]}}),
Mit_Index = Table.Combine( Table.TransformRows(Gruppierung_Kst, each Table.AddIndexColumn(_[Alle], „Zähler“, 1, 1) ) )
in
Mit_Index

Viele Grüße,
Anna-Maria

Hi Wilfried,

die Antwort auf Deine Frage lautet: Weil mir nicht immer der eleganteste Lösungsweg einfällt 😉 Deine Lösung gefällt mir auch besser. Danke für Deinen Kommentar.

Viele Grüße,
Lars

let
Source = Excel.CurrentWorkbook(){[Name=“Tabelle1″]}[Content],
Gruppierung_Kst = Table.Group(Source, {„Kst“}, {{„Alle“, each _, type table [Kst=nullable number, Bereich=nullable number]}}),
Index_in_Gruppierung = Table.AddColumn(Gruppierung_Kst, „Zähler“, each Table.AddIndexColumn([Alle], „Zähler“, 1, 1)),
Expand_Gruppierung = Table.ExpandTableColumn(Index_in_Gruppierung, „Zähler“, {„Bereich“, „Zähler“}, {„Bereich“, „Zähler.1“}),
Delete_not_needed = Table.RemoveColumns(Expand_Gruppierung,{„Alle“})
in
Delete_not_needed

vielen Dank für diesen wertvollen Tip.
Ich bin maximal begeistert 🙂

Ja, verstehe ich, aber einen Hinweis a la „Achtung, PositionOf kann laaaange dauern und Abhilfe könnte Buffer liefern (als Stichwort für Google 😉 wäre ja ne Möglichkeit

Hallo Basti,

ja, die Buffer halten einen Snapshot der Daten im RAM und greifen nicht immer auf die Basisdaten zurück. Das zu erklären, war für den vorliegenden Artikel ein wenig „too much“ 😉

Danke für den Hinweis und viele Grüße,
Lars

Hallo,
ich habe eine Tabelle mit rund 5000 Zeilen; dementsprechend lange dauert das berechnen der List.PositionOf-Spalte.
Tipp. -> Table.Buffer bzw. List.Buffer nutzen!. Ich habe folgenden Schritt ergänzt

[…]

Index = Table.AddIndexColumn(#“Umbenannte Spalten“, „Index“, 0, 1),
Sort = Table.Buffer(Table.Sort(Index,{{„Index“, Order.Ascending}})),
CustCol = Table.AddColumn(Sort, „Hilf“, each List.PositionOf(Sort[Kst],[Kst])),
CustColB = Table.AddColumn(CustCol, „Zähler“, each [Index]-[Hilf]+1),

[…]

Hallo Katharina,

ja, bei größeren Datenmengen können List-Operationen teilweise sehr lange dauern und sie sind dann natürlich nicht mehr zu empfehlen. Schön, dass Dir dieser Beitrag trotzdem helfen konnte.

Danke für Dein Feedback und viele Grüße aus Hamburg,
Lars