Challenge

This challenge will have you write a program that takes in two integers n and m and outputs the number non-intersecting loops on the n by m torus made by starting at (0,0) and only taking steps up and to the right. You can think of torus as the grid with wraparound both at the top and the bottom and on the sides.

This is code-golf so fewest bytes wins.

Example

For example, if the input is n=m=5, one valid walk is

(0,0) -> (0,1) -> (0,2) -> (1,2) -> (2,2) -> (2,3) -> (2,4) -> 

(2,0) -> (3,0) -> (4,0) -> (4,1) -> (4,2) -> (4,3) -> 

(0,3) -> (1,3) -> (1,4) -> 

(1,0) -> (1,1) -> (2,1) -> (3,1) -> (3,2) -> (3,3) -> (3,4) -> (4,4) -> 

(0,4) -> (0,0)

as shown in the graphic.

Some example input/outputs

f(1,1) = 2 (up or right)

f(1,2) = 2 (up or right-right)

f(2,2) = 4 (up-up, up-right-up-right, right-right, right-up-right-up)

f(2,3) = 7

f(3,3) = 22

f(2,4) = 13

f(3,4) = 66

f(4,4) = 258

Python 2, 87 bytes

f=lambda m,n,z=0,l=:z==0if z in l else sum(f(m,n,(z+d)%m%(n*1j),l+[z])for d in(1,1j))

Try it online!

The interesting thing here is using a complex number z to store the coordinate of the current position. We can move up by adding 1 and move right by adding 1j. To my surprise, modulo works on complex numbers in a way that lets us handle the wrapping for each dimension separately: doing %m acts on the real part, and %(n*1j) acts on the imaginary part.

JavaScript (ES6), 67 bytes

This shorter version is derived from a Python 3.8 alternate version found by @xnor. However, this works only for $mtimes n<32$ in JS.

Takes input as (m)(n).

m=>n=>(g=(k,l)=>l>>k&1?!k:g((k+m)%(m*n),l|=1<<k)+g(k-~k%m-k%m,l))``

Try it online!

To have it work for any input, we could use BigInts for 73 bytes:

m=>n=>(g=(k,l=k)=>l&(b=1n<<k)?!k:g((k+m)%(m*n),l|=b)+g(k-~k%m-k%m,l))(0n)

Try it online!

JavaScript (ES6),  76 73  72 bytes

Takes input as (m)(n).

m=>n=>(g=(x,y)=>g[x+=y*m]?!x:g(-~x%m,y,g[x]=1)+g(x%m,-~y%n)+--g[x])(0,0)

Try it online!

Commented

m => n => (         // m = width; n = height

  g = (             // g is a recursive function taking:

        x, y        //   the current coordinates (x, y) on the torus

      ) =>          //

    g[              // the surrounding object of g is also used for storage

      x += y * m    // turn x into a key for the current coordinates

    ] ?             // if this cell was already visited:

      !x            //   return 1 if we're back to (0, 0), or 0 otherwise

    :               // else:

      g(            //   first recursive call:

        -~x % m,    //     move to the right

        y,          //     leave y unchanged

        g[x] = 1    //     mark the current cell as visited by setting the flag g[x]

      ) +           //   add the result of

      g(            //   a second recursive call:

        x % m,      //     restore x in [0...m-1]

        -~y % n     //     move up

      ) +           //

      --g[x]        //   clear the flag on the current cell

)(0, 0)             // initial call to g with (x, y) = (0, 0)

Jelly, 28 bytes

ạƝ§=1Ȧ

²‘p/’ŒPÇƇḢÐṂ%⁸QƑƇṪÐṂL

A monadic Link accepting a list, [m,n], which yields the count.

TIO-jt1qe1v9 ...although there is little point, it's way too inefficient.

(I can't even run [2,3] locally with 16GB ram)!

How?

Brute force - creates coordinates of a tiled version big enough then filters the power-set of these points to those paths with neighbours only increasing by one in a single direction, then filters to those starting at a minimal coordinate (i.e. the origin) and, at the same time, removes this start coordinate from each. Then uses modulo arithmetic to wrap back to a torus and filters out any containing duplicate coordinates (i.e. those containing intersections) and, finally, filters to those with minimal ending coordinates (i.e. ending back at the origin) and yields the result's length.

ạƝ§=1Ȧ - Link 1: all neighbours differ by 1 in exactly one direction

 Ɲ     - for neighbours:

ạ      -   absolute difference

  §    - sum each

   =1  - equal to one (vectorises)

     Ȧ - any and all? (falsey if empty or contains a falsey value when flattened)



²‘p/’ŒPÇƇḢÐṂ%⁸QƑƇṪÐṂL - Main Link: list of integers, [m,n]

²                     - square (vectorises) -> [m*m, n*n]

 ‘                    - increment (vectorises) -> [m*m+1, n*n+1]

   /                  - reduce with:

  p                   -   Cartesian product

    ’                 - decrement (vectorises) -> all the coordinates of an m*m by n*n grid

                      -                           including [0, 0] and [m*m, n*n] 

     ŒP               - power-set -> all paths going either up OR right at each step, but not

                      -              necessarily by only 1, and

                      -              necessarily both up and right (e.g. [...[1,3],[5,7],[6,2],...])

        Ƈ             - filter keep those for which:

       Ç              -   call last Link (1) as a monad

                      -              ...now all remaining paths do only go in steps

                      -              of one up or one right

          ÐṂ          - filter keep those minimal under:

         Ḣ            -   head - removes the 1st coordinate from each and yields them for the filter

                      -          ...so only those which started at [0,0] but without it

            %⁸        - modulo by the left argument ([m,n]) (vectorises)

                Ƈ     - filter keep those for which:

               Ƒ      -   is invariant when:

              Q       -     de-duplicated

                      -          ...so no repetitions of torus coordinates (and we already removed

                      -          the first [0,0] which must be present exactly twice)

                  ÐṂ  - filter keep those minimal under:

                 Ṫ    -   tail

                      -          ...so only those which ended at [0,0] 

                    L - length

Haskell, 88 80 bytes

n#m|let(x!y)a|elem(x,y)a=0^(x+y)|b<-(x,y):a=(mod(x+1)n!y)b+(x!mod(y+1)m)b=0!0$

Try it online!

Simple brute force: try all up/right combinations, dropping those which intersect (we keep all positions we've visited in list a) and counting those which eventually hit positition (0,0) again.

The base case of the recursion is when we visit a position a second time (elem(x,y)a). The result is 0^0 = 1 when the position is (0,0) and counts towards the numbers of loops or 0 (0^x, with x non-zero) otherwise and doesn't increase the number of loops.

Edit: -8 bytes thanks to @xnor.

Jelly, 44 bytes

×ƝṪ2*Ḥ_2Rḃ€2ċⱮؽ%³¬ẠƲƇịØ.Ṛ,Ø.¤ZÄZ%€ʋ€³ŒQẠ$€S

Try it online!

Works for 4,4, but has complexity $O({2^m}^n)$ so won’t scale that well.

This works by finding all possible routes of up to $mn$ length, filtering out those that don’t end at 0,0, and then excluding those that pass the same point twice.