This is a front-end for the Online Encyclopedia of Integer Sequences, made by Christian Perfect. The idea is to provide OEIS entries in non-ancient HTML, and then to think about how they're presented visually. The source code is on GitHub.
At length 8 there are 7 polygons, consisting of the 2, 1, 4 resp. rotations of: ._. .___. .___. | | | . | | ._| | | |___| |_| |_| Let p(k,n) be the number of 2k-cycles in the n X n grid graph for n >= k-1. p(k,n) are quadratic polynomials in n, with the first few given by: p(1,n) = 0, p(2,n) = 1 - 2*n + n^2, p(3,n) = 4 - 6*n + 2*n^2, p(4,n) = 26 - 28*n + 7*n^2, p(5,n) = 164 - 140*n + 28*n^2, p(6,n) = 1046 - 740*n + 124*n^2, p(7,n) = 6672 - 4056*n + 588*n^2, p(8,n) = 42790 - 22904*n + 2938*n^2, p(9,n) = 275888 - 132344*n + 15268*n^2, ... The quadratic coefficients give a(n), so the first few are 0, 1, 2, 7, 28, 124, .... - _Eric W. Weisstein_, Apr 05 2018
a(1) to a(6) = 0 as no closed-loop is possible.
a(7) = 8 as there is one path which forms a closed loop which can be walked in 8 different ways on a 2D square lattice. The path is:
.
5
*---.---.---.---.---*
| |
. .
| |
. . 4
| |
6 . .
| | 3
. *---.---.---*
| |
. . 2
| |
*---.---.---.---.---.---.---X---*
7 1
.
See the attached link for text images of the closed loops for other n values.
def A001413(n): # For illustration; becomes slow for n >= 5. if not hasattr(A:=A001413, 'terms'): A.terms=[]; A.paths=((0,0,0),), while n > len(A.terms): for L in (0,1): new = []; cycles = 0 for path in A.paths: end = path[-1] for i in (0,1,2): for s in (1,-1): t = tuple(end[j]if j!=i else end[j]+s for j in (0,1,2)) if t not in path: new.append(path+(t,)) elif L and t==path[0]: cycles += 1 A.paths = new A.terms.append(cycles) return A.terms[n-1] if n > 1 else 0 # M. F. Hasler, Jun 17 2025
For n = 2, total steps = 4, there are 8 different paths with an area of 1. These are the 8 possible ways to walk the polygon:
+---+
| |
+---+
.
For n = 3, total steps = 6, there are 24 different paths with an area of 2. These are the 24 possible ways to walk the polygon:
+---+---+
| |
+---+---+
.
For n = 4, total steps = 8, there are 96 different paths with an area of 3 and 16 different paths with an area of 4. These are the possible ways to walk the polygons:
+---+ +---+---+
| | | |
+ +---+ + +
| | | |
+---+---+ for area = 3 +---+---+ for area = 4
.
For n = 5, total steps = 10, there are 360 different paths with an area of 4, 160 paths with an area of 5 and 40 different paths with an area of 6. These are the possible ways to walk the polygons:
+---+---+---+---+ +---+ +---+ +---+---+
| | | | | | | |
+---+---+---+---+ + +---+---+ +---+ +---+ +---+ +---+
| | | | | |
+---+---+---+ +---+---+---+ +---+---+ for area = 4
.
+---+---+ +---+---+---+
| | | |
+ +---+ + +
| | | |
+---+---+---+ for area = 5 +---+---+---+ for area = 6
.
Table begins:
0;
8;
24;
96,16;
360,160,40;
1320,960,528,144,24;
4872,4704,3752,2016,840,224,56;
18112,21632,20992,15424,9920,4832,2176,704,192,32;
67248,96192,107712,93312,75096,50112,31104,16416,7848,3168,1080,288,72;
249480,415040,526400,514480,468680,373280,281280,189920,120400,69120,36560,17040,7480,2720,880,240,40;
Row sums = A010566.
a(1) to a(6) = 0 as no closed loop paths are possible. a(7) = 16128. Given the first step has length 1 and is to the right, with the next non-right step being upward, there are 84 different loops. Each of these can be walked in at least 2 ways, with the single perfect square having 48 different possible walks. Each of these in turn can be started with a first step of length 1 to n, and each of these can then be walked in 8 different ways on a 2D square grid. This gives a total number of 7-step paths of 16128. This should be compared with A334720 where for n=7 only 8 paths are possible. See the attached link text file for more details of n=7.
def A010567(n): # For illustration - becomes slow for n > 5 if not hasattr(A:=A010567, 'terms'): A.terms=[6]; O=0,; A.paths=[(O*3, (1,)+O*2, t+O)for t in((2,0),(1,1))] while n > len(A.terms): for L in (0,1): new = []; cycles = 0 for path in A.paths: end = path[-1] for i in (0,1,2): for s in (1,-1): t = tuple(end[j]if j!=i else end[j]+s for j in (0,1,2)) if t not in path: new.append(path+(t,)) elif L and t==path[0]: cycles += 24 if path[2][1] else 6 A.paths = new A.terms.append(cycles) return A.terms[n-1] # M. F. Hasler, Jun 17 2025
def A010568(n): # For illustration - becomes slow for n > 5 if not hasattr(A:=A010568, 'r'): A.terms = [8]; O = 0,; I = O*4, (1,*O*3) A.paths = (*I, (2,*O*3)), (*I, (1,1,0,0)) while n > len(A.terms): for L in (0, 1): new=[]; cycles = 0; O=(0,)*4; I = 0,1,2,3 for path in A.paths: end = path[-1]; weight = 48 if path[2][1] else 8 for i in I: for s in (1, -1): t = tuple(end[j]if j!=i else end[j]+s for j in I) if t not in path: new.append(path+(t,)) elif L and t==O: cycles += weight A.paths = new A.terms.append(cycles) return A.terms[n-1] # M. F. Hasler, Jun 17 2025
a(1) = 8. The single walk of length 4 is:
.
+---+
| |
+---+
.
This can be taken in 8 different ways on a square lattice, giving a total 1*8 = 8.
a(2) = 0 as there is no closed-loop path consisting of 8 steps.
a(3) = 24. There is one walk, ignoring reflection and rotations, with a length of 12. The walk is:
.
+---+
| |
+---+ +---+
| |
+---+ +---+
| |
+---+
.
This can be walked in 3 different ways if the first steps are right and then upward. This path can be then taken in 8 ways on a square lattice, giving a total number of 3*8 = 24.
a(4) = 64. There is one walk, with indistinct reflections and rotations, with a length of 16. The walk is:
.
+---+
| |
+---+ +---+
| |
+---+ +---+
| |
+---+ +---+
| |
+---+
.
This can be walked in 8 different ways if the first steps are right and then upward. This path can be then taken in 8 ways on a square lattice, giving a total number of 8*8 = 64.
.
a(5) = 360. There are four walks, with indistinct reflections and rotations, with a length of 20. The walks, and the different ways they can be taken, are:
.
+---+ +---+
| | | |
+---+ +---+ +---+ +---+
| | | |
+---+ +---+ +---+ +---+
| | | |
+---+ +---+ +---+ +---+
| | | |
+---+ +---+ +---+ +---+
| | x 10 | | x 20
+---+ +---+
+---+ +---+
| | | |
+---+ +---+ +---+ +---+
| | | |
+---+ +---+ +---+ +---+
| | | |
+---+ +---+ +---+ +---+
| | | |
+---+ +---+ +---+ +---+
| | x 5 | | x 10
+---+ +---+
.
Each of these can be walked in 8 different ways on a square lattice, giving a total number of 8*(10+20+5+10) = 360.
See the attached text file for images of the closed-loops for n=1 to n=11.
Comments