ZFX + Developia

Code: Alles auswählen

Liste[0] = [0, 4, 5]
Liste[1] = [4, 5]
Liste[2] = [0]
Liste[3]= [5, 9]

Code: Alles auswählen

[4@0, 5@1, 0@2, 9@3] oder [5@0, 4@1, 0@2, 9@3]

Code: Alles auswählen

from typing import List, Tuple, Dict

Alternatives: List[List[int]] = [ [4, 5],
                                  [4, 5, 7, 0],
                                  [0],
                                  [4, 7, 9],
                                  [4, 7, 8],
                                  [0, 6],
                                  [6, 5, 4, 7, 8]]

Solution: List[Tuple[int, int]] = []


def buildDict(inp: List[List[int]]) -> Dict[int, List[Tuple[int, int]]]:
    retval = {}
    for i in range(len(inp)):
        for j in range(len(inp[i])):
            if inp[i][j] in retval:
                retval[inp[i][j]].append( (i, j) )
            else:
                retval[inp[i][j]] = [ (i, j) ]
    return retval


def removeValue(inp: List[List[int]], value) -> List[List[int]]:
    for i in range(len(inp)):
        inp[i] = [e for e in inp[i] if e != value]
    return inp


def findForcedSolutions(inp: List[List[int]]):
    i = 0
    while i < len(inp):
        if len(inp[i]) == 1:
            print("Found forced solution: Entry \"" + str(inp[i][0]) + "\" in List", i)
            Solution.append( (i, inp[i][0]) )
            inp = removeValue(inp, inp[i][0])
            i = 0
        else:
            i = i + 1
    return inp


def findUniqueSolutions(inp: List[List[int]]):
    rebuildDict = True
    while rebuildDict:
        rebuildDict = False
        dictionary = buildDict(inp)
        for key in dictionary:
            if len(dictionary[key]) == 1:
                ListIndex = dictionary[key][0][0]
                EntryIndex = dictionary[key][0][1]
                value = inp[ListIndex][EntryIndex]
                print("Found unique solution: Entry \"" + str(value) + "\" in List", ListIndex)
                Solution.append( (ListIndex, value) )
                inp[ListIndex] = []
                rebuildDict = True
                break
    return inp

def getSmallestImpactValue(inp: List[List[int]]):
    dictionary = buildDict(inp)
    if len(dictionary) == 0:
        return -1
    fom = {}
    # fom = "sum of length of all alterative-arrays that contain a certain value"
    # Example [ [0, 1, 2], [0, 4, 5], [1, 2] ]
    #  -> gives fom=3+3=6 for value 0,
    #  ->       fom=3+2=5 for value 1
    #           fom=3 for value 4
    # Finding the value that generates the smallest figure of merit
    # will solve for values with the least alternatives 'alternatives destroyed'
    # first
    for key in dictionary:
        fom[key] = sum([len(inp[k[0]]) for k in dictionary[key]])
    return sorted(fom.items(), key=lambda x: x[1])[0][0]


def solveForSmallesListContaining(inp: List[List[int]], val: int):
    smallestListIndex = len(inp)
    smallestListLength = 10000
    for i in range(len(inp)):
        if val in inp[i]:
            if len(inp) < smallestListLength:
                smallestListLength = len(inp)
                smallestListIndex = i
    print("Disambiguate solution: Entry \"" + str(val) + "\" in List", smallestListIndex)
    Solution.append( (smallestListIndex, val))
    inp[smallestListIndex] = []
    inp = removeValue(inp, val)
    return inp


def collapse(inp: List[List[int]]):
    inp = findUniqueSolutions(inp)
    while True:
        inp = findForcedSolutions(inp)
        largestImpactValue = getSmallestImpactValue(inp)
        if largestImpactValue < 0:
            break
        inp = solveForSmallesListContaining(inp, largestImpactValue)


collapse(Alternatives.copy())
if len(Solution) == len(Alternatives):
    print("\nSolution:")
else:
    print("\nWARNING: Partial solution:")
for s in sorted(Solution, key=lambda s:s[0]):
    print("From List " + str(s[0]) + ": \"" + str(s[1]) + "\" from ", Alternatives[s[0]])

valuesTaken = [s[0] for s in Solution]

print("")
if len(valuesTaken) == len(dict.fromkeys(valuesTaken)):
    print("=> Values are unique :-)")
else:
    print("=> noooohohoho :-(")

Code: Alles auswählen

Found unique solution: Entry "9" in List 3
Found forced solution: Entry "0" in List 2
Found forced solution: Entry "6" in List 5
Disambiguate solution: Entry "8" in List 4
Disambiguate solution: Entry "7" in List 1
Disambiguate solution: Entry "4" in List 0
Found forced solution: Entry "5" in List 6

Solution:
From List 0: "4" from  [4, 5]
From List 1: "7" from  [4, 5, 7, 0]
From List 2: "0" from  [0]
From List 3: "9" from  [4, 7, 9]
From List 4: "8" from  [4, 7, 8]
From List 5: "6" from  [0, 6]
From List 6: "5" from  [6, 5, 4, 7, 8]

=> Values are unique :-)

Code: Alles auswählen

using DMAConnectionManager = DMAConnectionManagerTemplate<RegisterPeriphery<DMADirection::RX, SPI0>,
                                                          RegisterPeriphery<DMADirection::TX, SPI0>,
                                                          RegisterPeriphery<DMADirection::RX, SPI1>,
                                                          RegisterPeriphery<DMADirection::TX, SPI1>,
                                                          RegisterPeriphery<DMADirection::RX, SPI2>,
                                                          RegisterPeriphery<DMADirection::TX, SPI2> >;
                                                          
using SPI0_DMAChannelRX = DMAConnectionManager::RXDMAChannelFor<SPI0>;
...