let
  data  = Excel.CurrentWorkbook(){[ Name = "Список" ]}[Content],
  typed = Table.TransformColumnTypes ( data, { { "Список", type text } } ),
  group = Table.Group ( typed, "Список", { { "tbl", ( t ) => t, type table } }, GroupKind.Local, ( s, c ) => Number.From ( c = "Продукт" ) )
in
  group

let
  data = Csv.Document (
    File.Contents ( "C:\Users\kovalev.i\Downloads\TRENDN17\TRENDN17.csv" ),
    [ Delimiter = ",", Columns = 6, Encoding = 1251, QuoteStyle = QuoteStyle.None ]
  ),
  promHeads = Table.PromoteHeaders ( data, [ PromoteAllScalars = true ] ),
  typed = Table.TransformColumnTypes (
    promHeads,
    {
      { "Trend 1 Time", type datetime },
      { "Trend 2 Time", type datetime },
      { "Trend 3 Time", type datetime },
      { "Trend 1 ValueY", type number },
      { "Trend 2 ValueY", type number },
      { "Trend 3 ValueY", type number }
    }
  ),
  addInd = Table.AddColumn ( typed, "process ind", each [Trend 1 ValueY] <> 0 or [Trend 2 ValueY] <> 0 or [Trend 3 ValueY] <> 0, type logical ),
  group = Table.Group (
    addInd,
    { "process ind" },
    {
      { "Дата", ( t ) => Date.From ( List.Min ( t[Trend 1 Time] ) ), type date },
      { "Trend 1 start", ( t ) => Time.From ( List.Min ( Table.SelectRows ( t, ( r ) => r[Trend 1 ValueY] <> 0 )[Trend 1 Time] ) ), type time },
      { "Trend 1 end", ( t ) => Time.From ( List.Max ( Table.SelectRows ( t, ( r ) => r[Trend 1 ValueY] <> 0 )[Trend 1 Time] ) ), type time },
      { "Trend 2 start", ( t ) => Time.From ( List.Min ( Table.SelectRows ( t, ( r ) => r[Trend 2 ValueY] <> 0 )[Trend 2 Time] ) ), type time },
      { "Trend 2 end", ( t ) => Time.From ( List.Max ( Table.SelectRows ( t, ( r ) => r[Trend 2 ValueY] <> 0 )[Trend 2 Time] ) ), type time },
      { "Trend 3 start", ( t ) => Time.From ( List.Min ( Table.SelectRows ( t, ( r ) => r[Trend 3 ValueY] <> 0 )[Trend 3 Time] ) ), type time },
      { "Trend 3 end", ( t ) => Time.From ( List.Max ( Table.SelectRows ( t, ( r ) => r[Trend 3 ValueY] <> 0 )[Trend 3 Time] ) ), type time }
    },
    GroupKind.Local
  ),
  filter = Table.SelectRows ( group, each ( [process ind] = true ) ),
  delInd = Table.RemoveColumns ( filter, { "process ind" } )
in
  delInd

let
  data    = Excel.CurrentWorkbook(){[ Name = "Исходник" ]}[Content],
  step    = Excel.CurrentWorkbook(){[ Name = "tParam" ]}[Content]{0}[Шаг],
  addClmn = Table.AddColumn ( data, "Расчет с шагом", each [Число] + step, type number )
in
  addClmn

let
  data = Excel.CurrentWorkbook(){[ Name = "data" ]}[Content],
  transform = Table.TransformColumns (
    data,
    {
      {
        "Получатель счета",
        ( x ) =>
          if Text.Remove ( Text.AfterDelimiter ( x, " ", { 0, RelativePosition.FromEnd } ), { "0" .. "9" } ) = "/" then
            Text.BeforeDelimiter ( x, " ", { 0, RelativePosition.FromEnd } )
          else
            x,
        type text
      }
    }
  )
in
  transform

in
    try #"Строки с примененным фильтром" otherwise #table ( {}, {} )

let
  src = Excel.CurrentWorkbook(){[ Name = "пример" ]}[Content],
  dataClmns = List.Buffer ( List.RemoveItems ( Table.ColumnNames ( src ), { "Склад", "Код", "Статья" } ) ),
  typed = Table.TransformColumnTypes (
    src,
    { { "Склад", type text }, { "Код", type text }, { "Статья", type text } } & List.Transform ( dataClmns, ( x ) => { x, type number } )
  ),
  transformLst = List.Buffer ( List.Transform ( dataClmns, ( x ) => { x, ( y ) => y * 1000 } ) ),
  transform = Table.FromRecords (
    Table.TransformRows ( typed, ( r ) => if Text.StartsWith ( r[Код], "1" ) then r else Record.TransformFields ( r, transformLst ) ),
    Value.Type ( typed )
  )
in
  transform

let
  table = Table.FromRows (
    { { "a", 1, 2 }, { "a", 2, 3 }, { "b", 3, 4 }, { "b", 5, 6 }, { "b", 6, 7 } },
    type table [ Номенклатура = text, clmn1 = Int64.Type, clmn2 = Int64.Type ]
  ),
  group = Table.Group (
    table,
    { "Номенклатура" },
    {
      {
        "tbl",
        ( t ) =>
          [
            remove  = Table.RemoveColumns ( t, { "Номенклатура" } ),
            toClmns = Table.ToColumns ( remove ) & { { t[Номенклатура]{0} } },
            toTbl   = Table.FromColumns ( toClmns, Table.ColumnNames ( remove ) & { "Номенклатура" } ),
            reorder = Table.ReorderColumns ( toTbl, Table.ColumnNames ( t ) )
          ][reorder],
        Value.Type ( table )
      }
    },
    GroupKind.Local
  ),
  combine = Table.Combine ( group[tbl] )
in
  combine

let
  lastDate = #date ( 2022, 06, 30 ),
  data = Excel.CurrentWorkbook(){[ Name = "Таблица1" ]}[Content],
  typed = Table.TransformColumnTypes ( data, { { "Дата", type date }, { "Остаток, кор.", type number }, { "Уходимость в день, кор.", type number } } ),
  addGen = Table.AddColumn (
    typed,
    "recs",
    ( r ) =>
      List.Generate (
        () =>  [
          left   = r[#"Остаток, кор."] - r[#"Уходимость в день, кор."],
          order  = if left < r[#"Уходимость в день, кор."] then 10 else null,
          record = Record.Combine ( { r, [ Разместить заказ = order, Остаток на конец = left ] } ),
          res    = Record.RenameFields ( record, { { "Остаток, кор.", "Остаток на начало" }, { "Уходимость в день, кор.", "Уходимость в день" } } )
        ],
        each [res][Дата] <= lastDate,
        each [
          prevOrder = List.Max ( { 0, [res][Разместить заказ] } ),
          left = [res][Остаток на конец] + prevOrder - [res][Уходимость в день],
          order = if left < [res][Уходимость в день] then 10 else null,
          res = Record.TransformFields (
            [res],
            {
              { "Дата", ( x ) => Date.AddDays ( x, 1 ) },
              { "Остаток на начало", ( x ) => [res][Остаток на конец] + prevOrder },
              { "Разместить заказ", ( x ) => order },
              { "Остаток на конец", ( x ) => left }
            }
          )
        ],
        each [res]
      )
  ),
  combine = Table.FromRecords ( List.Combine ( addGen[recs] ) )
in
  combine

let
  data = Excel.CurrentWorkbook(){[ Name = "data" ]}[Content],
  group = Table.Group (
    data,
    { "Транзакция" },
    {
      {
        "tbl",
        ( t ) =>
          [
            rowsCondition = List.Count ( List.Select ( t[Сумма], ( x ) => x <> 0 ) ) = 3,
            feeCondition = List.Count ( List.Select ( t[Тип], ( x ) => x = "сбор" ) ) = 1,
            cur1 = Table.SelectRows ( t, ( r ) => r[Сумма] < 0 )[Валюта]{0},
            cur2 = Table.SelectRows ( t, ( r ) => r[Сумма] > 0 and r[Тип] <> "сбор" )[Валюта]{0},
            result = Table.AddColumn (
              t,
              "Валютная пара",
              ( r ) =>
                if rowsCondition and feeCondition then
                  if r[Сумма] > 0 and r[Тип] <> "сбор" then cur1 else if r[Сумма] < 0 then cur2 else null
                else
                  null,
              type text
            )
          ][result]
      }
    }
  ),
  combine = Table.Combine ( group[tbl] )
in
  combine

( table as table, columns as list ) =>
  let
    clmns        = Table.SelectColumns ( table, columns ),
    dates        = List.Buffer ( List.RemoveMatchingItems ( List.Combine ( Table.ToColumns ( clmns ) ), { "" } ) ),
    secondNumber = List.Transform ( dates, ( x ) => Number.From ( Text.SplitAny ( x, Text.Remove ( x, { "0" .. "9" } ) ){1} ) ),
    local        = if List.Max ( secondNumber ) > 12 then "en-US" else "ru-RU"
  in
    local

let
  files = Folder.Files ( "C:\Users\kovalev.i\Downloads\Dates\Sources" ),
  getData = Table.TransformColumns (
    files[[Content]],
    {
      {
        "Content",
        ( file ) =>
          [
            csv = Csv.Document ( file, [ Delimiter = ",", Encoding = 1251, QuoteStyle = QuoteStyle.None ] ),
            skip = Table.Skip ( csv, 1 ),
            promHeads = Table.PromoteHeaders ( skip, [ PromoteAllScalars = true ] ),
            local = f_DateLocal ( promHeads, { "AUGDT", "ZFBDT" } ),
            transform = Table.TransformColumns (
              promHeads,
              List.Transform ( { "AUGDT", "ZFBDT" }, ( x ) => { x } & { ( y ) => Date.From ( y, local ) } & { type date } )
                & List.Transform (
                  { "DMBTR", "WRBTR" },
                  ( x ) =>  { x }
                    & {
                      ( y ) => try Number.From ( y ) otherwise try Number.FromText ( y, "en-US" ) otherwise Number.From ( Text.Remove ( y, { "." } ) )
                    }
                    & { type number }
                )
            )
          ][transform]
      }
    }
  ),
  combine = Table.Combine ( getData[Content] )
in
  combine

let
  text      = Table.FirstValue ( Excel.CurrentWorkbook(){[ Name = "nomenclature" ]}[Content] ),
  split     = Text.SplitAny ( text, "()" ),
  alternate = List.Alternate ( split, 1, 1 ),
  select    = List.Select ( alternate, ( x ) => Text.Length ( x ) = 10 ),
  toTable   = Table.FromColumns ( { select }, type table [ #"СК-МТР" = text ] )
in
  toTable

let
  VCs       = Excel.CurrentWorkbook(){[ Name = "vendor_code" ]}[Content],
  VCsLst    = List.Buffer ( List.Sort ( Table.ToColumns ( VCs ){0}, ( x ) => - Text.Length ( x ) ) ),
  products  = Excel.CurrentWorkbook(){[ Name = "product" ]}[Content],
  transform = List.Transform ( Table.ToColumns ( products ){0}, ( x ) => List.Select ( VCsLst, ( vc ) => Text.Contains ( x, vc ) ){0}? ),
  result    = Table.FromColumns ( { transform }, type table [ Артикул = text ] )
in
  result

  #"Добавлен пользовательский объект1" = Table.AddColumn (
    #"Сгруппированные строки", 
    "tbl2", 
    each Table.AddIndexColumn ( Table.Sort ( [tbl], { { "Время2", Order.Ascending } } ), "Место", 1, 1, Int64.Type )
  ) 

  #"Сгруппированные строки" = Table.Group (
    #"Сортированные строки", 
    { "Номер заезда ПФ" }, 
    { { "tbl", ( t ) => Table.AddIndexColumn ( Table.Sort ( t, { { "Время2", Order.Ascending } } ), "Место", 1, 1, Int64.Type ), type table } }
  )

let
  data      = Excel.CurrentWorkbook(){[ Name = "input" ]}[Content],
  toRows    = Table.ToRows ( data ),
  transform = List.Transform ( toRows, ( x ) => List.Repeat ( { x{0} }, x{1} ) ),
  toTable   = Table.FromColumns ( { List.Combine ( transform ) }, { Table.ColumnNames ( data ){0} } )
in
  toTable

Среднее 2 :=
CALCULATE (
    AVERAGEX (
        SUMMARIZE ( 'Таблица'; 'Таблица'[YM]; 'Таблица'[Отдел]; [Подразделение] );
        [Внесено]
    );
    ALL ( 'Таблица'[Отдел]; 'Таблица'[Подразделение] )
)