Home/ Questions/Q 8285149
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-08T11:23:16+00:00

TrialPay posted a programming question about a snake cube puzzle on their blog. Recently,

  • 0

TrialPay posted a programming question about a snake cube puzzle on their blog.

Recently, one of our engineers introduced us to the snake cube. A snake cube is a puzzle composed of a chain of cubelets, connected by an elastic band running through each cubelet. Each cubelet can rotate 360° about the elastic band, allowing various structures to be built depending upon the way in which the chain is initially constructed, with the ultimate goal of arranging the cubes in such a way to create a cube.

Example:

enter image description here

This particular arrangement contains 17 groups of cubelets, composed of 8 groups of two cubelets and 9 groups of three cubelets. This arrangement can be expressed in a variety of ways, but for the purposes of this exercise, let ‘0’ denote pieces whose rotation does not change the orientation of the puzzle, or may be considered a “straight” piece, while ‘1’ will denote pieces whose rotation changes the puzzle configuration, or “bend” the snake. Using that schema, the snake puzzle above could be described as 001110110111010111101010100.

Challenge:

Your challenge is to write a program, in any language of your choosing, that takes the cube dimensions (X, Y, Z) and a binary string as input, and outputs ‘1’ (without quotes) if it is possible to solve the puzzle, i.e. construct a proper XYZ cube given the cubelet orientation, and ‘0’ if the current arrangement cannot be solved.

I posted a semi-detailed explanation of the solution, but how do I determine if the program solves the problem? I thought about getting more test cases, but I ran into some problems:

  1. The snake cube example from TrialPay’s blog has the same combination as the picture on Wikipedia’s Snake Cube page and http://www.mathematische-basteleien.de.
  2. It’s very tedious to manually convert an image into a string.

I tried to make a program that would churn out a lot of combinations:

#We should start at the binary representation of 16777216 (00100...), because
#lesser numbers have more than 2 consecutive 0s (000111...)
i = 16777216
solved = []
while i <= 2**27:
    s = str(bin(i))[2:]
    #Add 0s
    if len(s) < 27:
        s = '0'*(27-len(s)) + s
    #Check if there are more than 2 consecutive 0s
    print s
    if s.find("000") != -1:
        if snake_cube_solution(3, 3, 3, s) == 1:
            solved.append(s)
    i += 1

But it just takes forever to finish executing. Is there a better way to verify the program?

Thanks in advance!

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    TL;DR: This isn’t a programming problem, but a mathematical one. You may be better served at math.stackexchange.com.

    Since the cube size and snake length are passed as input, the space of inputs a checker program would need to verify is essentially infinite. Even though checking the solutions’s answer for a single input is reasonable, brute forcing this check across the entire input space is clearly not.

    If your solution fails on certain cases, your checker program can help you find these. However it can’t establish your program’s correctness: if your solution is actually correct the checker will simply run forever and leave you wondering.

    Unfortunately (or not, depending on your tastes), what you are looking for is not a program but a mathematical proof.

    (Proving) Algorithm correctness is itself an entire field of study, and you can spend a long time in it. That said, proof by induction is often applicable (especially for recursive algorithms.)

    Other times, navigating between state configurations can be restated as optimizing a utility function. Proving things about the space being optimized (such as it has only one extrema) can then translate to a proof of program correctness.

    Your state configurations in this second approach could be snake orientations, or they might be some deeper structure. For example, the general strategy underneath solving a Rubik’s cube
    isn’t usually stated on literal cube states, but on expressions of a group of relevant symmetries. This is what I personally expect your solution will eventually play out as.

    EDIT: Years later, I feel I should point out that for a given, fixed cube size and snake length, of course the search space is actually finite. You can write a program to brute-force check all combinations. If you were clever, you could even argue that the times to check a set of cases can be treated as a set of independent random variables. From this you could build a reasonable progress bar to estimate how (very) long your wait would be.

    • 0