Create Snake Number Grid

let
  Cols = 6, 
  Count = 56, 
  Ans = Table.FromRows(
    List.Transform(
      {0 .. Number.RoundDown(Count / Cols)}, 
      each 
        let
          r = List.Transform(List.Numbers(_ * Cols + 1, Cols), each if _ > Count then null else _)
        in
          if Number.IsEven(_) then r else List.Reverse(r)
    )
  )
in
  Ans

let
  Source = {1 .. Count}, 
  Cols = 6, 
  Count = 56, 
  S = 
    let
      s = List.Transform(
        List.Split(Source, Cols), 
        each _ & List.Repeat({null}, Cols - List.Count(_))
      ), 
      r = List.Transform(
        List.Positions(s), 
        each if Number.IsOdd(_) then List.Reverse(s{_}) else s{_}
      )
    in
      Table.FromRows(r)
in
  S

let
 Source = Excel.CurrentWorkbook(){[Name="Table1"]}[Content][Column1],
 Calc = List.Transform(List.Split({1..Source{1}}, Source{0}), each 
 let
 a = List.Count(_),
 b = if a = Source{0} then _ else _&List.Repeat({null}, Source{0}-List.Count(_))
 in b),
 Sol = Table.FromRows(List.Accumulate({0..List.Count(Calc)-1}, {} , (s,c)=> if Number.IsOdd(c+1) then s & {Calc{c}} else s & {List.Reverse(Calc{c})}))
in
 Sol

query 2

let
 Source = Excel.CurrentWorkbook(){[Name="Table1"]}[Content][Column1],
 Calc = Table.FromRows(List.Transform(List.Split({1..Source{1}}, Source{0}), each 
 let
 a = List.Count(_),
 b = if a = Source{0} then _ else _&List.Repeat({null}, Source{0}-List.Count(_))
 in b)),
 Idx = Table.AddIndexColumn(Calc, "Idx", 1),
 Sol = Table.FromRows(Table.AddColumn(Idx, "New", each 
 let 
 a = List.RemoveLastN(Record.ToList(_),1),
 b = if Number.IsEven(List.Last(Record.ToList(_))) then List.Reverse(a) else a
 in b)[New])
in
 Sol

Sin embargo, ninguno como los de Bo Rydobon o Matthias Friedmann 😬


                    
                  
          

let
  Cols = 6, 
  Count = 56, 
  tab = [
    a = List.Split({1 .. Count}, Cols), 
    b = List.Transform(a, each List.Count(_) < Cols), 
    b1 = List.Transform(a, each List.Count(_)), 
    c = List.Zip({a, b}), 
    d = Table.FromRows(
      List.Transform(
        c, 
        (x) => if x{1} = true then x{0} & List.Repeat({null}, Cols - List.Last(b1)) else x{0}
      )
    )
  ][d], 
  ind = Table.AddIndexColumn(tab, "Índice", 1, 1, Int64.Type), 
  res = Table.FromRows(
    Table.AddColumn(
      ind, 
      "Personalizar", 
      each 
        if Number.IsOdd([Índice]) = true then
          List.RemoveLastN(Record.FieldValues(_), 1)
        else
          List.Reverse(List.RemoveLastN(Record.FieldValues(_), 1))
    )[Personalizar]
  )
in
  res

let
  Cols = 6, 
  Count = 56, 
  List = List.Split(
    List.Transform({1 .. Cols * Number.RoundUp(Count / Cols)}, each if _ > Count then null else _), 
    Cols
  ), 
  Rows = List.Transform(
    List, 
    each if Number.IsOdd(List.PositionOf(List, _)) then List.Reverse(_) else _
  ), 
  Table = Table.FromRows(Rows)
in
  Table

let
  columns = 6, 
  number = 56, 
  list = List.Split({1 .. number}, columns), 
  rows = List.Transform(
    list, 
    each 
      if Number.IsEven(List.PositionOf(list, _)) then
        _ & List.Repeat({""}, columns - List.Count(_))
      else
        List.Repeat({""}, columns - List.Count(_)) & List.Reverse(_)
  )
in
  Table.FromRows(rows)

=LET(x,SEQUENCE(ROUNDUP(B2/B1,0),B1),y,INT((x-1)/B1),z,IF(ISEVEN(y),x,(y+1)*B1-MOD(x-1,B1)),IF(z>B2,"",z))

=LET(c,B1,n,B2,r,SEQUENCE(ROUNDUP(n/c,))-1,m,MOD(r,2),s,r*c+m*c+(1-2*m)*SEQUENCE(,c)+m,IF(s>n,"",s))

=MAKEARRAY(ROUNDUP(B2/B1,),B1,LAMBDA(r,c,LET(n,B1*r+IF(MOD(r,2),c-B1,1-c),IF(n>B2,"",n))))

=LET(V,B2/B1+1,E,SEQUENCE(V,B1)+IF(ISODD(SEQUENCE(V)),,SEQUENCE(,B1,B1-1,-2)),IF(E>B2,"",E))

=LET(S,B1,V,B2,R,SEQUENCE(,S),N,REDUCE(R,SEQUENCE(V/S),LAMBDA(A,D,VSTACK(A,TAKE(A,-1)+IF(ISODD(D),S*2-R*2+1,R*2-1)))),IF(N>V,"",N))

=LET(a,B1,b,B2,c,SEQUENCE(b/a+1),d,DROP(REDUCE("",c,LAMBDA(x,y,VSTACK(x,IF(ISODD(y),SEQUENCE(,a,a*(y-1)+1),SEQUENCE(,a,y*a,-1))))),1),IF(d>b,"",d))

=LET(N,TEXTSPLIT(TEXTJOIN("|",,BYROW(IFNA(WRAPROWS(SEQUENCE(B2),B1),""),LAMBDA(A,TEXTJOIN(",",0,IF(ISEVEN(ROUNDUP(TAKE(A,,1)/B1,0)),SORT(A,,-1,1),A))))),",","|"),IFERROR(--N,N))

=LET(A,REDUCE(SEQUENCE(,B1),SEQUENCE(ROUNDUP(B2/B1,0)-1),LAMBDA(a,v,VSTACK(a,SORT(SEQUENCE(,B1,1+MAX(TAKE(a,-1))),,IF(ISODD(v),-1,1),1)))),IF(A>B2,"",A))

=TEXTSPLIT(CONCAT(LET(a, WRAPROWS(SEQUENCE(B2),B1," "), BYROW(a, LAMBDA(x, IF(ISEVEN((MIN(x) - 1)/B1), TEXTJOIN(",",,x), TEXTJOIN(",",, INDEX(x,,SEQUENCE(B1,,B1,-1))))&"/")))), ",", "/",1)

=LET(
 _tbl, WRAPROWS(SEQUENCE(B2), B1),
 _rows, SEQUENCE(ROWS(_tbl)),
 IFNA(
 MAKEARRAY(
 ROWS(_tbl),
 B1,
 LAMBDA(r, c, INDEX(IF(ISODD(r), INDEX(_tbl, r, ), SORT(INDEX(_tbl, r, ), , -1, 1)), c))
 ),
 ""
 )
)

=LET(a, WRAPROWS(SEQUENCE(B2), B1, ""), r, ROWS(a), 
CHOOSEROWS(
 VSTACK(a, SORT(a, , -1, 1)), 
 MOD(SEQUENCE(r, , 0, 1 + r), 2 * r) + 1)
)

=LET(x,B1,y,MAKEARRAY(CEILING(B2/x,1),x,LAMBDA(r,c,r*x-IF(MOD(r,2),x-c,c-1))),IF(y>B2,"",y))

Or, if you don't mind some empty cells:

=LET(x,B1,y,MAKEARRAY(B2,x,LAMBDA(r,c,r*x-IF(MOD(r,2),x-c,c-1))),IF(y>B2,"",y))

=MAKEARRAY(ROUNDUP(B2/B1,0),B1,LAMBDA(r,c,LET(count,B2,cols,B1,a,IF(ISODD(r),c+cols*(r-1),cols*(r)-(c-1)),IF(a>count,"",a))))

I create an array where Odd and Even rows are treated as is : 
 - Odd rows are counting up, offset by cols*(current_row-1)

=MAKEARRAY(ROUNDUP(B2/B1,0),B1,LAMBDA(x,y,LET(z,IF(ISODD(x),x*B1-B1+y,x*B1+1-y),IF(z>B2,"",z))))

or using REDUCE:
=LET(a,WRAPROWS(SEQUENCE(B2),B1),REDUCE(SEQUENCE(,B1),SEQUENCE(ROWS(a)-1,,2),LAMBDA(x,y,IFERROR(VSTACK(x,SORT(INDEX(a,y,),,-1+(2*ISODD(y)),1)),""))))

=MAKEARRAY(B2/B1+1,B1,LAMBDA(r,c,LET(_,(r-1)*B1+IF(MOD(r,2),c,B1+1-c),IF(_>B2,,_))))

Using MAKEARRAY and denoting with "r "and "c" the current row and the current column respectively, we can generate a regular sequence using (r-1)

=LET(cnt,B2,rws,ROUNDUP(cnt/B1,0),cls,B1,seq,SEQUENCE(rws,cls),
 delt,SEQUENCE(rws,,cls+1,2*cls),
 sortSeq,IF(MOD(seq-1,2*cls)+1>cls,delt-seq,seq),
 IF(sortSeq>cnt,"",sortSeq))

=LET(Cols,B1,Val,B2,most,MAKEARRAY(ROUNDUP(Val/Cols,0),Cols,LAMBDA(R,C,IF(ISODD(R),(R-1)*Cols+C,R*Cols-C+1))),IF(most<=Val,most,""))

=LET(mx,B2,cl,B1,seq,SEQUENCE(ROUNDUP(mx/cl,0),cl,0),col,MOD(seq,cl),rw,INT(seq/cl),vl,IF(MOD(rw,2)=0,seq+1,(rw+1)*cl-col),IF(vl>mx,"",vl))

Recursive Lambda solution...
                    
                  

VBA solution:
Function f_snakeGrid(cols As Integer, count As Integer)
Dim tableau As Variant
Dim ligs As Integer, cpt As Integer, col As Integer
ligs = WorksheetFunction.RoundUp(count / cols, 0)
ReDim tableau(1 To ligs, 1 To cols)
For i = 1 To ligs
 For j = 1 To cols
 cpt = cpt + 1
 col = IIf(i Mod 2 = 0, cols - j + 1, j)
 If Not cpt > count Then
 tableau(i, col) = cpt
 Else
 tableau(i, col) = ""
 End If
 Next j
Next i
f_snakeGrid = tableau
End Function