Rotate Grid by Count

let
  Row = 2, 
  z = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  Rotate = Table.FirstN(
    Table.RemoveFirstN(Table.Repeat(z, 2), Number.Mod(Row, Table.RowCount(z))), 
    Table.RowCount(z)
  )
in
  Rotate

let
  Source = Excel.CurrentWorkbook(){[Name = "TableProblem"]}[Content], 
  DemotedHeaders = Table.DemoteHeaders(Source), 
  TableRowCount = Table.RowCount(DemotedHeaders), 
  SourceRow = Excel.CurrentWorkbook(){[Name = "TableRow"]}[Content], 
  DemotedHeadersRow = Table.DemoteHeaders(SourceRow), 
  InitialValue = Number.FromText(DemotedHeadersRow{0}[Column2]), 
  // Reverse rotation supported 
  Value = Number.Sign(InitialValue) * Number.Mod(Number.Abs(InitialValue), TableRowCount), 
  TableToRecords = Table.ToRecords(DemotedHeaders), 
  RotatingRows = List.FirstN(
    List.Skip(TableToRecords & TableToRecords & TableToRecords, TableRowCount - Value), 
    TableRowCount
  ), 
  TableFromRecords = Table.FromRecords(RotatingRows), 
  PromotedHeaders = Table.PromoteHeaders(TableFromRecords, [PromoteAllScalars = true])
in
  PromotedHeaders

let
  Row = 3, 
  Data = Excel.CurrentWorkbook(){[Name = "data"]}[Content], 
  Generate = List.Generate(
    () => [x = 0, y = null], 
    each [x] <= Table.RowCount(Data), 
    each [x = [x] + 1, y = Data{Number.Mod([x] + Row, Table.RowCount(Data))}], 
    each [y]
  ), 
  Return = Table.FromRecords(List.Skip(Generate))
in
  Return

let
  Origen = Excel.CurrentWorkbook(){[Name = "Tabla1"]}[Content], 
  Row = Excel.CurrentWorkbook(){[Name = "Tabla2"]}[Content][Columna2], 
  Index = Table.TransformColumns(
    Table.AddIndexColumn(Origen, "Idx", 0), 
    {"Idx", each Number.Mod(List.Sum({_} & Row), Table.RowCount(Origen))}
  ), 
  Orden = Table.Sort(Index, {{"Idx", Order.Ascending}}), 
  Sol = Table.RemoveColumns(Orden, {"Idx"})
in
  Sol

let
  Linha = 2, 
  Fonte = Table.Distinct(
    Table.RemoveLastN(Table.RemoveFirstN(Table.Repeat(Tabela1, Linha), Linha), Linha)
  )
in
  Fonte

let
  Source = Table.DemoteHeaders(Excel.CurrentWorkbook(){[Name = "Table1"]}[Content]), 
  AddIndex = Table.AddIndexColumn(Source, "Index", 0, 1, Int64.Type), 
  ShiftIndex = Table.Sort(
    Table.AddColumn(AddIndex, "ShiftedIndex", each Number.Mod([Index] + Shift, 4)), 
    {"ShiftedIndex", Order.Ascending}
  ), 
  Clean = Table.RemoveColumns(ShiftIndex, {"Index", "ShiftedIndex"})
in
  Clean

let
  Source = Excel.CurrentWorkbook(){[Name = table_name]}[Content]
in
  Table.RemoveColumns(
    Table.Sort(
      Table.AddColumn(
        Table.AddIndexColumn(Source, "Index", 0, 1, Int64.Type), 
        "Custom", 
        each Number.Mod([Index] + rows, Table.RowCount(Source))
      ), 
      {{"Custom", Order.Ascending}}
    ), 
    {"Index", "Custom"}
  )

let
  Source = Excel.CurrentWorkbook(){[Name = "Data_Range"]}[Content], 
  Rotater = List.Last(Excel.CurrentWorkbook(){[Name = "Rotate_N"]}[Content][Column1]),  //  
  Added_0_Index = Table.AddIndexColumn(Source, "Index", 0, 1, Int64.Type), 
  Rotator_Column = Table.AddColumn(Added_0_Index, "N", each Rotater), 
  ModuloModified = Table.AddColumn(
    Rotator_Column, 
    "Modulo", 
    each 1 + Number.Mod([N] + [Index], Table.RowCount(Source)), 
    type number
  ), 
  SortByModuloModified = Table.Sort(ModuloModified, {{"Modulo", Order.Ascending}}), 
  Solution = Table.RemoveColumns(SortByModuloModified, {"Index", "N", "Modulo"})
in
  Solution

let
 Source = Excel.CurrentWorkbook(){[Name="Table1"]}[Content],
 Row = List.Min(Excel.CurrentWorkbook(){[Name="Table2"]}[Content][Column2]),
 TableRowCount = Table.RowCount(Source),
 Rotation = if Row < TableRowCount then Row else Row - TableRowCount,
 SplitTable = Table.SplitAt(Source, Rotation),
 SplitTable1 = SplitTable{1},
 SplitTable2 = SplitTable{0},
 Append = Table.Combine({SplitTable1, SplitTable2}),
 Type = Table.TransformColumnTypes(Append,List.Transform(Table.ColumnNames(Append), each {_, type text}))
in
 Type
hashtag#powerquery hashtag#powerbi hashtag#excel 
Practise makes you better 😀 thank you Excel BI
                    
                  
          

=LET(z,A4:E7,r,ROWS(z),TAKE(DROP(VSTACK(z,z),MOD(B1,r)),r))

=LET(a,A4:E7,TAKE(DROP(VSTACK(a,a),MOD(B1,ROWS(a))),4))

=LET(a,A4:E7,r,ROWS(a),TAKE(DROP(VSTACK(a,a),MOD(B1,r)),r))

=MAKEARRAY(4,5,LAMBDA(r,c,INDEX(A4:E7,1+MOD(B1+r-1,4),c)))
✅ =INDEX(A4:E7,1+MOD(B1+{0;1;2;3},4),{1,2,3,4,5})
✅ =CHOOSEROWS(A4:E7,1+MOD(B1+{0;1;2;3},4))
✅ =SORTBY(A4:E7,1+MOD(B1+{0;1;2;3},4))

=LET(r,ROWS(A4:A7),
CHOOSEROWS(A4:E7,MOD(SEQUENCE(r,,B1),r)+1))

=LET(a,B1,b,A4:E7,c,MOD(a,ROWS(b)),d,SEQUENCE(ROWS(b)),e,IF(d<=c,d+c,d-c),SORTBY(b,e,1))

=CHOOSEROWS(A4:E7, MOD(SEQUENCE(ROWS(A4:E7)) + B1 - 1, ROWS(A4:E7)) + 1)

=LET(A,A4:E7, MAKEARRAY(ROWS(A),COLUMNS(A), LAMBDA(x,y, INDEX(A,MOD(x+B1-1,4)+1,y) )))

=LET(a, A4:E7, b, ROWS(a), c, SEQUENCE(b), d, MOD(B1, b), CHOOSEROWS(a, c+d-IF(c+d>b, b, 0)))

=LET(_rcal,MOD(B1,4)+SEQUENCE(ROWS(A4:E7)),
_ract,IF(_rcal>ROWS(A4:E7),_rcal-ROWS(A4:E7),_rcal),
CHOOSEROWS(A4:E7,_ract))

=LET(_rownum,B1,_tbl,A4:E7,
_rows,_rownum+SEQUENCE(ROWS(_tbl)),
_col1,SEQUENCE(_rownum+ROWS(_tbl)),
_col2,MOD(SEQUENCE(ROWS(_col1))-1,4)+1,
CHOOSEROWS(_tbl,XLOOKUP(_rows,_col1,_col2)))

=LAMBDA(x,y, CHOOSEROWS(TEXT(x, "#"),
1 + MOD(-1 + y + SEQUENCE(ROWS(x)), ROWS(x)))
)(A4:E7, B1)

=LET(x;COUNTA(A4:A7);y;A4:E7;IF(MOD(B1;x)=0;TAKE(VSTACK(IFERROR(DROP(y;B1);"");TAKE(y;B1));-x);TAKE(VSTACK(IFERROR(DROP(y;MOD(B1;x));"");TAKE(y;MOD(B1;x)));-x)))

=LET(grid, A4:E7, 
rotate, MOD(B1, rows(grid)), 
bottom, QUERY(grid, "Limit "&rotate, 0), 
top, QUERY(grid, "Offset "&rotate, 0), 
IF(rotate=0, grid, {top; bottom})
)

=LET(r,MOD(SEQUENCE(4,1,B1),4),CHOOSEROWS(A4:E7,r+(r>=0)))

=LET(a,A4:E7,b,ROWS(a),c,MOD(B1,b),d,MOD(SEQUENCE(4,,B1),b)+1,INDEX(a,IF(d=0,b,d),SEQUENCE(,COLUMNS(a))))

=LET(d,A4:E7,r,ROWS(d),SORTBY(d,MOD(SEQUENCE(r)-B1-1,r)))

=LET(d,A4:E7,r,ROWS(d),p,MOD(B1,r),IF(p,VSTACK(TAKE(d,p-r),DROP(d,p-r)),d))

=LET(r,B1,m,A4:E7,SI(O(r<0,r>4),m,APILARV(EXCLUIR(m,4-r),EXCLUIR(m,-r)))) 
ENG:
=LET(r,B1,m,A4:E7,IF(OR(r<0,r>4),m,VSTACK(DROP(m,4-r),DROP(m,-r))))

=1 and B1=3 are reversed)

instead the correct sequence is
MOD(SEQUENCE(ROWS(A4:E7),,-B1),ROWS(A4:E7))

=LET(a,A4:E7,INDEX(a,MOD(SEQUENCE(ROWS(a),,-B1),ROWS(a))+1,SEQUENCE(,COLUMNS(a))))