Welcome toVigges Developer Community-Open, Learning,Share
Welcome To Ask or Share your Answers For Others


0 votes
in Technique[技术] by (71.8m points)

python - Most efficient method of sorting permutations of a list using the minimum number of insertions, removals or transpositions

I have written a function that takes two permutations of a list as arguments, and then attempts to sort one to match the other in the minimum number of moves possible and thus the shortest time.

This question comes in two parts:

Q1 - Is this the most efficient way of solving this problem in Python, or at least an efficient way?

Q2 - Is this just a high level method of implementing the swap item method of permutation? So at a lower level is Python handling the item swapping or is something else happening entirely?

Here is the function:

final_changes = []
def get_list_changes(list1, list2, r=0):
    # Set up the global final_changes list
    global final_changes
    if r == 0:
        final_changes = []
    changes = []
    # First get the index of items in both lists
    for index, (first, second) in enumerate(zip(list1, list2)):
        if first != second:
            old_index = list1.index(second)
            changes.append([index, old_index])

    # Then get the index of the biggest index change
    diff = [abs(change[0] - change[1]) for change in changes]
    index = diff.index(max(diff))
    # Make a copy of the second list and make that change
    updated = list(list2)
    updated.insert(changes[index][1], updated.pop(changes[index][0]))
    if list1 == updated:
        return final_changes
        return get_list_changes(list1, updated, r + 1)

Here is some research I have read regarding calculating permutations:



Number of swaps in a permutation

How to find minimum number of switches to sort a given permutation(let's say 1-10) in ascending order

I have written a short test which takes a list of lists, each with an input list and the number of swap cycles that would be needed to put it in order. It then runs the function on the list and outputs if it's less or more than the swapping method and the number of changes for each. It seems to be split between sometimes needing more operations and sometimes needing less, depending on the number and types of changes.

ORIGINAL = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    [[10, 1, 2, 3, 4, 5, 6, 7, 8, 9], 5],
    [[1, 2, 3, 4, 5, 6, 10, 8, 9, 7], 1],
    [[1, 3, 4, 5, 6, 2, 7, 9, 8, 10], 4],
    [[10, 9, 8, 7, 6, 5, 4, 3, 2, 1], 5]

for lists in INPUT:
    changes = get_list_changes(ORIGINAL, lists[0])
    if len(changes) < lists[1]:
        print('Less changes')
    elif len(changes) == lists[1]:
        print('Equal changes')
        print('More changes')


Less changes
More changes
Less changes
More changes

This is more a general question as to if anyone has used this or a similar method, how efficient it is and what exactly is happening at a lower level. On an intellectual level I'm interested to gather people's opinions and insights on to this propsed solution of solving an old mathematical problem.

Welcome To Ask or Share your Answers For Others

1 Answer

0 votes
by (71.8m points)

Welcome to Vigges Developer Community for programmer and developer-Open, Learning and Share