Tukukkk

I've been coding a program that solves a maths problem with specific conditions.

In this maths problem, there are seven slots. At the beginning, the first three slots are occupied by the numbers 1, 2 and 3. There is an empty slot in the middle. The next three are numbers 4, 5 and 6. Seven slots altogether.

The goal of the problem is for the 1 2 and 3 to switch places with the 4 5 and 6. Only one number can be moved at a time. It can move over another number into an empty slot (the zero) or move sideways switching with an empty slot.

Below is a visualisation of the start:

1 2 3 0 4 5 6

The desired outcome is shown below:

4 5 6 0 1 2 3

Keep in mind that it does not have to be in this order, as long as 4 5 6 is on one side and 1 2 3 is on the other with 0 in the middle.

The program that we are creating uses itertools for a list of permutations. Then, based on the position of the zero, finds a permutation that suits the next move.

What I need is for specific combinations to be extracted (output) from this list, based on the position of zeroes within the combinations. Below is the code so far.

import time

import itertools



nonStop = True

answerList = [1, 2, 3, 0, 4, 5, 6]



combinations = itertools.permutations([1, 2, 3, 0, 4, 5, 6])



while nonStop == True:

    for value in combinations:

        i = 0

        print(value)

        i += 1

        time.sleep(2)

Thanks in advance. Any help would be greatly appreciated!

Here is some high-level advice on your program. I'll assume that on each move the zero will swap places with a number that is one or two slots distance from the zero. I'll also assume that you want to find the smallest number of moves that takes you from the initial list to a "desired outcome" and that the printout is to show all the positions from the starting position to the desired outcome.

If you know graph theory (also called network theory) you could easily solve your problem by performing a breadth-first search from your starting position to any desired position. The nodes in your graph are the 5,040 possible permutations, and two nodes have an edge between them if you can go from one position to the other in one move.

If you don't know graph theory, you can use this following approach. You can use two overall data structures: a queue (such as collections.deque) and a dictionary. Put the initial position into the queue. Also put it as a key in the dictionary with the value None.

Then run a loop. In each run through the loop, remove one position from the queue. There will be at most four possible moves from this position: swap the zero with the item 2 left, 1 left, 1 right, or 2 right of the zero. (If the zero is at or near an end, the possible moves will be fewer.) For each of those moves, if the resulting position is not already in the dictionary, add it to the queue and the dictionary. The dictionary entry's value is the position you just took from the queue. If the resulting position is already in the dictionary, do nothing.

Now check if the resulting position is a "desired result". If not, continue the loop. If it is, use the dictionary to save all the moves from your desired result back to the initial position. Then print those positions in the desired order, and you are done--break the loop.

Note three things about this approach. First, if any sequence of moves reaches a desired result, this approach will print one of the shortest sequences. Second, not all permutations of the original position are generated. Permutations are generated one at a time until a desired result is reached--there is no need for more. Third, no printing is done until all the moves are done and the good moves have been picked out. This is because most moves will not prove to be useful, so we wait until we know which the useful ones are.

If you want more information, show some more work of your own. But before that, tell me if I understood the rules of your problem correctly.