= "Q" & Text.From(Date.From("1-" & [Attribute] & Text.From([Year]), "ru-RU"))

let
    Source = Excel.CurrentWorkbook(){[Name="Table1"]}[Content],
    Types = Table.TransformColumnTypes(Source,{{"Time", type time}}),
    Grp = Table.Group(Types, {"ID"}, {{"Maximum", each List.Max([Time]), type time}})
in
    Grp

let
    Source = List.Transform({0..10}, each "Магазин " & Text.From(_)),
    Max = List.Count(Source) - 1,
    Tt = Table.FromRows(List.Transform(List.Random(1000000), each {Number.Round(_, 3) * 10000000, Source{Number.Round(Number.RandomBetween(0, Max), 0)}}), {"Код товара", "Магазин"})
in
   Tt

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

    // Группируем таблицу по коду товара
    Grp = Table.Group
           (
            // На таких объемах данных буферизация - наше все имхо
            Table.Buffer(Source), 
            {"Код товара"}, 
            {
             // Добавляя столбец Data, в ячейках которого будут содержаться таблицы
             // с колонками, соответствующими именам магазинов где есть данный товар 
             // и единственной строкой, содержащей во всех колонках "x".
             {
 
              "Data", 
              each Table.Buffer
                    (
                     // Нестандартное использование Pivot - вместо агрегации данных 
                     // ставим значение "x" во все колонки (имена магазинов, в которых
                     // есть группируемый товар.
                     Table.Pivot(_, List.Distinct([Магазин]), "Магазин", "Код товара", each "x")
                    )
             }
            }
           ),

    // Это получение уникального сортированного списка всех магазинов для использования в качестве 
    // имен колонок в готовой таблице.
    // Я создаю его, преобразовывая столбец Data, каждая ячейка которого является таблицей,
    // в столбец, содержащий список имен колонок таблицы в ячейке. А дальше путем слияния
    // списка списков (мутировавший столбец [Data] я получаю все возможные варианты имен магазинов.
    List = List.Sort
            (
             List.Distinct
              (

               // Как вариант - Вместо List.Combine использовать List.Buffer(Source[Магазин]).   
               // То есть тупо вычислить уникальные комбинации из колонки Магазин исходной таблицы
               // Вполне может быть быстрее..

               List.Combine
                (
                 Table.TransformColumns(Grp, {{"Data", each Table.ColumnNames(_)}})[Data]
                )

              ), 
             Order.Ascending
            ),

    // А дальше просто разворачиваем столбец Data по полному списку магазинов.
    // В тех строках, где встречаются имена колонок, которые есть в в List,
    // выставляется значение "x", которое там хранится. Если нет (то есть товара
    // не было в магазине - то null)
    Expanded = Table.ExpandTableColumn(Grp, "Data", List)

in
    // В итоге получаем результат.
    Expanded

Table.Join(
           table1 as table, 
           key1 as any, 
           table2 as table, 
           key2 as any, 
           optional joinKind as nullable number, 
           optional joinAlgorithm as nullable number, 
           optional keyEqualityComparers as nullable list // <--- Есть подозрение что это список по числу ключевых колонок и сюда можно засобачить самодельный Comparer 
          ) as table

char O,o[];main(l){for(;~l;O||puts(o))O=(O[o]=
~(l=getchar())?4<(4^l>>5)?l:46:0)?-~O&printf("%02x ",l)*5:!O;}

    // Готовые списки чтобы каждый раз руками не забивать.
    Unpf = {"УНПФ"}, RegL = {"регистрация", "ликвидация"},

    // Исходная таблица
    Source = Excel.CurrentWorkbook(){[Name="Table1"]}[Content],

    // Убираем УПНФ из списка заголовков
    List = List.Difference(Table.ColumnNames(Source), Unpf), 

    // И для этого списка столбцов преобразуем колонки в числовое представление дат.
    // установить для колонки тип number в данном случае - бесполезно, не переварит.
    Type = Table.TransformColumns(Source, List.Transform(List, (Item) => {Item, each Number.From(Date.From(_))})),

    // Таблица создается путем группировки по трем основным колонкам (упнф, региистрация, ликвидация)
    // Добавляемые столбцы генерируются путем трансформации половинного списка индексов (так как колонки прием/увольнение идут всегда парами)
    Grp = Table.Group
           (
            Type, 
            Unpf & RegL, 
            List.Transform
             (

              // Список индексов 0.. до половины длины списка доп. колонок
              {0..Number.RoundDown(List.Count(List.Difference(List, RegL)) / 2) - 1}, 

               // В качестве каждого элемента будущего списка будет списочек вида {имя столбца, функция_генерации_значений_столбца}
              (Id) => {
                       // Имя стобца
                       "Диапазон " & Text.From(Id + 1), 
                       // Функция генерации значений
                       each 
                        let
                          // Так как в таблице-аргументе всегда одна строка в данном случае.
                          Row = _{0}
                        in
                          // Нужно для отлова null в исходных данных
                          try
                            // Признак - пересечение списков дат не пустое.
                            not List.IsEmpty
                                 (
                                  List.Intersect
                                   (
                                    {
                                     {Row[регистрация].. Row[ликвидация]}, 
                                      // Обращение к столбцу по его имени через индекс в том 
                                      // самом "половинном" списке индексов.
                                     {Record.Field(Row, List{Id*2})..Record.Field(Row, List{Id*2 + 1})}
                                    }
                                   )
                                 )
                          otherwise null
                      }
             )
           ),
    // Приведение чисел в даты для двух основных столбцов
    CType = Table.TransformColumnTypes(Grp,{{"регистрация", type date}, {"ликвидация", type date}})
in
    CType

   Text.CrLfSymbols = {" ",",",":",";","-","/","*","\","!","?","[","]","{","}","~","'","|"},

   Text.SplitSmart = 
    (
     InputText as nullable text,    // Входной текст
     SegmentMin as number,          // Минимальное число символов, функция не разбивает строку до этого числа символов
     SegmentMax as number           // Максимальное число символов. Если функция не найдет символа для переноса от SegmentMin до SegMentMax, перенос будет произведен по SegmentMax.
    ) as list =>            
       let
        Len = if InputText = null then 0 else Text.Length(InputText),
        Out = if Len > SegmentMax then
         let
          Pos_A = Text.PositionOfAny(Text.Range(InputText, SegmentMin, SegmentMax - SegmentMin), Text.CrLfSymbols, Occurrence.Last),
          Pos_B = if Pos_A < 0 then SegmentMax else SegmentMin + Pos_A + 1,
          Txt_A = Text.Start(InputText, Pos_B),
          Txt_B = Text.End(InputText, Len - Pos_B)
         in List.Combine({{Txt_A}, @Text.SplitSmart(Txt_B, SegmentMin, SegmentMax)}) 
        else
         {InputText}
       in Out,