I have a Python script which ends up creating a 2D array based on user input. Therefore, the length of the 2D array is unknown and the length of the individual arrays within the 2D array are also unknown until the user has input the information. I would like to sort the individual array pieces based on a value associated with them. An example of a possible output that needs to be sorted is below:

Basically, each individual array is a failure symptom followed by the a list of possible components, each having a "score" associated with them that is the likelihood that this component is causing the failure. My goal is to reorder the array with the components along with their scores in descending order based on the score, i.e., the component and score need to be moved together. The problem I have is like I said, I do not know the length of anything until user input is given. There could be only 1 failure symptom input, or there could be 9. The failure symptom could contain only 1 component, or maybe 12. I know it will take nested for loops and if statements, but I haven't been able to figure it out based on all the possible scenarios. Some possible scenarios I have thought of:

1. The array is already in order (move to the next failure symptom)
2. The first component is correct, but the ones after may not be. Or the first two are correct, but the ones after may not be, etc...
3. The array is completely backwards in order
4. The array only contains 1 component, therefore there is no need to sort
5. The array is in some random order, so some positions for some components may already be in the correct spot while some others aren't

Every time I feel like I am making headway, I think of another scenario which wouldn't hold up. Any help is greatly appreciated!

CodePudding user response：

Some minor mods to the bubble sort link sent by Stevie and it is now working. Note that the array is named 'data'. This link shows the working code: 'Link'

CodePudding user response：

Your problem is a bit special. You don't only want to sort a multidimensional array, which would be rather simple using the default sorting algorithms, you also want to keep the order between the key/value pairs.

The second problem is that the keys are strings with numbers in it. So simple string comparison wouldn't work, because it is compared letter by letter, so "test9" > "test11" would be true (the second 1 wouldn't be even recognized, because 9>1).

The simpliest solution i figured out would be the following:

#get the failure id of one list
def failureId(value):
    return int(value[0].replace("failure",""))

#get the id of one component
def componentId(value):
    return int(value.replace("component",""))

#sort one failure list using bubble sort
def sortFailure(failure):
    #iteraring through the array twice (only the keys, ignoring the values)
    for i in range(1,len(failure), 2):
        for j in range(1,i, 2):

            #comparing the component ids
            if (componentId(failure[j])>componentId(failure[j 2])):

                #swaping keys and values
                failure[j],failure[j 2] = failure[j 2],failure[j]
                failure[j 1],failure[j 3] = failure[j 3],failure[j 1]

#sorting the full list
def sortData(data):
    #sorting the failures using default sort algorithm
    data.sort(key=failureId)
    
    #sorting the single list of failure datas itself
    for failure in data:
        sortFailure(failure)

data = [['failure2', 'component2', 0.15, 'component1', 0.85], ['failure3', 'component1', 0.95], ['failure1','component1',0.05,'component3', 0.8, 'component2', 0.1, 'component4', 0.05]]
print(data)
sortData(data)
print(data)

The first two functions are required to get the numbers(=id) from the strings as mentioned above. The second function uses "bubble sort" to sort the array. It uses steps 2 for the range function, because we want to skipt the values for each component. If the data are in wrong order we are swapping the key & value. In the sortData function we are using the built in sort function for lists to sort the whole list (by failure ids). Then we take each "sublist" and sort them using the other function.