Sudoku on a Mobius Strip

Question

Well we've done sudoku on keyboards, so the next step is obviously putting a Sudoku on a Mobius strip... of course...

I present, the world's very first MOBIUS SUDOKU:

---

Now this sudoku is going to be a bit different, because how you solve it, is up to you... You can build it, create an excel diagram, make a 3D model, solve on paper etc. Whatever works for you, feel free to go for it! As long as the answer shows an understandable solution path, then the method of solving is up to you.

Here is a link to a printable PDF version via google drive, assembly instructions included - PRINTABLE VERSION

(I highly recommend printing and building one to help with your solve)

---

Google Sheets version

(The left most square backs onto the right most square, and the middle squares back onto each other. The ends are then attached as indicated.)

RULES:

• Normal sudoku rules apply for rows and boxes - boxes are split into groups of 3 indicated by the thicker lines.
• Columns ‘wrap around’ over the edge of the mobius strip – 6 cells per column as a result, normal sudoku rules apply on these 6 cells.
• No number will ever be orthogonally adjacent to itself, including across the thicker borders separating the sets of 3 boxes.
• There are 18 total boxes, and as a result 18 total middle cells. There are 2 of each number, 1-9, in the middle cells.

---

Please provide a solution path in your answer! How you portray the solution is up to you, feel free to be as creative as you want, just please add some explanation of key points etc. I won’t necessarily accept the first answer, but the answer that best does this :)

Enjoy!!!

---

_{This puzzle has been translated into a CodeGolf challenge by @Taco タコス.}

Answer 1

First, build a spreadsheet. This has links surrounding it so that I can see where things will be relative to each other.

Then

we start with 9s (since that's the commonest number in the grid)

Then 3s and 4s:

Then more hunting in promising areas (2 missing) and their derivatives:

Another area came out pretty well:

Tricksy around the paper step. U6:U7 must contain a 4, so I11 can't be a 4:

I'm sure you all caught my earlier deliberate error with the 57:

Then we use the fact that there are already 2 central 7s to disambiguate the central 67:

Which helps get the whole row out:

Now 6s are relatively abundant on the grid, so we search and find a 6 that resolves. Near that are a few more answers (using the fact that there were already 2 middle 5s to get the highlighted 8:

We're able to continue on this, using the fact that there are already 2 middle 7s. This gives us a middle 1, which allows us to resolve another 3:

More sudoku tricks. Here that the 2s in the right block resolve the highlighted 12:

Only 4 and 9 can be in the middle (they're the only ones with 1 middle square), so:

More sudoko-ing:

And with a few more steps (including the no adjacent sameness over the border) and we're done!:

Answer 2

I thought I'd try my hand at writing a program for Mobius sudoku. I used the Z3 SMT solver (Python wrapper) for this. There isn't much of a "solution path" to describe: most of the constraints translate fairly directly, even the wrapping around of the columns. The main difficulty was

constraining the middle cells such that each number 1-9 appeared exactly twice. The z3.AtMost and z3.AtLeast methods don't work on symbolic expressions, so you can't say, e.g., exactly ("at most and at least") 2 of the middle cells should equal 1. I resorted to enforcing terms like sum(middle_cells) == sum(one_through_nine_twice), sum(middle_cells_squared) == sum(one_through_nine_twice_squared), and so on for increasing exponents. I think Z3 had some issues with the values getting too large, as it would return Unsatisfiable if I included terms with powers greater than 11. This worked to get the solution to this instance, and 11 terms is likely enough for how constrained the numbers here are, but I imagine there's a cleverer way to do this. EDIT - See @FliegendeWurst's better constraint for this in the comments

The other constraint which required some care was:

"No number will ever be orthogonally adjacent to itself, including across the thicker borders separating the sets of 3 boxes." I.e. if you go left/right/up/down 1 cell from a number, you won't find the same number. The column constraint already takes care of up/down; we really only need to check left/right at the borders between groups of blocks (since the row constraints already take care of this within block groups), but it doesn't hurt to check left/right distinctness everywhere. Checking right-distinctness suffices (left-distinctness would just duplicate the constraints), but we have to make sure to include the connections between the two strips (which are flipped vertically).

Here's the Python code:

 import numpy as np
 from z3 import And, Distinct, Int, Solver

 strip1_vals = [
     [4, 0, 1, 0, 5, 3, 7, 0, 2, 0, 8, 1, 0, 9, 7, 0, 0, 2, 6, 0, 2, 8, 0, 9, 0, 3, 0],
     [0, 7, 0, 4, 0, 0, 6, 0, 0, 6, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 9, 0, 2, 0, 6, 0, 4],
     [9, 0, 0, 0, 2, 0, 0, 1, 8, 2, 0, 3, 0, 0, 6, 0, 1, 4, 0, 7, 0, 0, 0, 3, 0, 0, 2],
 ]
 strip2_vals = [
     [1, 0, 4, 0, 0, 5, 0, 3, 7, 1, 9, 0, 0, 0, 4, 0, 0, 8, 5, 0, 0, 9, 0, 0, 4, 3, 0],
     [0, 6, 0, 0, 0, 9, 8, 0, 0, 0, 0, 8, 3, 0, 0, 4, 5, 0, 0, 8, 0, 0, 0, 3, 0, 0, 7],
     [3, 7, 0, 1, 4, 0, 0, 9, 0, 3, 0, 5, 1, 0, 8, 9, 0, 0, 4, 0, 9, 6, 0, 2, 0, 0, 1],
 ]

 strip1 = np.array(
     [[Int(f"s0r{row}c{col}") for col in range(27)] for row in range(3)]
 )
 strip2 = np.array(
     [[Int(f"s1r{row}c{col}") for col in range(27)] for row in range(3)]
 )
 # 3x3 squares
 blocks = [*np.split(strip1, 9, axis=1), *np.split(strip2, 9, axis=1)]
 block_groups = [*np.split(strip1, 3, axis=1), *np.split(strip2, 3, axis=1)]
 cols = np.concatenate([np.fliplr(strip1), strip2]).T
 # connect the two strips together, add the start of strip1 at the end
 # so the constraint wraps around
 rows = np.concatenate(
     (strip1, np.flipud(np.fliplr(strip2)), strip1[:, :1]), axis=1
 ).T
 centers = [block[1, 1] for block in blocks]
 mid_vals = [*range(1, 10), *range(1, 10)]

 constraints = {
     "one_through_nine": [
         And((1 <= c), (c <= 9)) for c in [*strip1.flat, *strip2.flat]
     ],
     "boxes_distinct": [Distinct(*block.flat) for block in blocks],
     "rows_distinct": [
         Distinct(*row)
         for block_group in block_groups for row in block_group
     ],
     "cols_distinct": [Distinct(*col) for col in cols],
     "right_distinct" : [
         Distinct(*left_right)
         for row in rows for left_right in zip(row[:-1], row[1:])
     ],
     "middle_cells": [
         sum(c ** i for c in centers) == sum(c ** i for c in mid_vals)
         for i in range(1, 11)
     ],
     "filled_entries": [
         *[
             strip1[i, j] == strip1_vals[i][j]
             for i in range(len(strip1))
             for j in range(len(strip1[0]))
             if strip1_vals[i][j] != 0
         ],
         *[
             strip2[i, j] == strip2_vals[i][j]
             for i in range(len(strip2))
             for j in range(len(strip2[0]))
             if strip2_vals[i][j] != 0
         ],
     ],
 }

 solver = Solver()
 for cs in constraints.values():
     solver.add(*cs)
 solver.check()
 assignment = solver.model()
 strip1_sol = np.array(
     [
         [assignment.evaluate(entry).as_long() for entry in row]
         for row in strip1
     ]
 )
 strip2_sol = np.array(
     [
         [assignment.evaluate(entry).as_long() for entry in row]
         for row in strip2
     ]
 )

 for row in strip1_sol:
     print("||", end=" ")
     for i, c in enumerate(row):
         print(c, end=" ")
         if i % 9 == 8:
             print("||", end=" ")
         elif i % 3 == 2:
             print("|", end=" ")
     print()

 print()
 for row in strip2_sol:
     print("||", end=" ")
     for i, c in enumerate(row):
         print(c, end=" ")
         if i % 9 == 8:
             print("||", end=" ")
         elif i % 3 == 2:
             print("|", end=" ")
     print()
 

And the final solution: