Início / coding / Perguntas / 78525363
Accepted
JustLearning
Asked: 2024-05-24 04:09:41 +0800 CST

Algoritmo para frações compostas

  • 772

Tenho um conjunto de N compostos químicos enumerados 1, 2,..., N. Para cada composto, tenho a fração de cada um de seus constituintes, “A”, “B” e assim por diante. Os compostos também podem conter outros compostos, caso em que a fração correspondente é fornecida. Por exemplo, para N = 5, um conjunto de amostra é

mixes = {
    1: {
        "A": 0.32,
        "B": 0.12,
        "C": 0.15,
        2: 0.41
    },
    2: {
        "C": 0.23,
        "D": 0.12,
        "E": 0.51,
        4: 0.14
    },
    3: {
        "A": 0.24,
        "E": 0.76
    },
    4: {
        "B": 0.13,
        "F": 0.01,
        "H": 0.86
    },
    5: {
        "G": 0.1,
        2: 0.4,
        3: 0.5
    }
}

Eu gostaria de um algoritmo que fornecesse a fração líquida de cada constituinte em cada composto, ou seja,

mixes = {
    1: {
        "A": 0.32,
        "B": 0.12 + 0.41 * 0.14 * 0.13,
        "C": 0.15 + 0.41 * 0.23,
        "D": 0.41 * 0.12,
        "E": 0.41 * 0.51,
        "F": 0.41 * 0.14 * 0.01,
        "H": 0.41 * 0.14 * 0.86
    },
    2: {
        "B": 0.14 * 0.13,
        "C": 0.23,
        "D": 0.12,
        "E": 0.51,
        "F": 0.14 * 0.01,
        "H": 0.14 * 0.86
    },
    3: {
        "A": 0.24,
        "E": 0.76
    },
    4: {
        "B": 0.13,
        "F": 0.01,
        "H": 0.86
    },
    5: {
        "A": 0.5 * 0.24,
        "G": 0.1,
        "B": 0.4 * 0.14 * 0.13,
        "C": 0.4 * 0.23,
        "D": 0.4 * 0.12,
        "E": 0.4 * 0.51 + 0.5 * 0.76,
        "F": 0.4 * 0.14 * 0.01,
        "H": 0.4 * 0.14 * 0.86
    }
}

Minha abordagem atual envolve recursão, mas gostaria de saber se existe uma maneira inteligente de fazer isso. Talvez usar uma estrutura de dados semelhante a uma árvore possa ajudar?

EDIT: para simplificar, suponha que não haja relacionamentos cíclicos no conjunto de dados.

python

1 respostas

  1. Best Answer

    Aqui está uma solução recursiva. Observei que as proporções de mistura originais para cada composto somam 1, portanto, há também uma verificação de que os compostos resultantes também somam 1:

    from pprint import pprint
from collections import defaultdict

mixes = {
    1: {
        'A': 0.32,
        'B': 0.12,
        'C': 0.15,
        2: 0.41
    },
    2: {
        'C': 0.23,
        'D': 0.12,
        'E': 0.51,
        4: 0.14
    },
    3: {
        'A': 0.24,
        'E': 0.76
    },
    4: {
        'B': 0.13,
        'F': 0.01,
        'H': 0.86
    },
    5: {
        'G': 0.1,
        2: 0.4,
        3: 0.5
    }
}

def resolve(compound):
    '''Return the components of a compound, recursively adjusted for ratios.
    '''
    for component, ratio in mixes[compound].items():
        # If the component is another compound, recursively report its ratios.
        if isinstance(component, int):
            for subcomponent, subratio in resolve(component):
                yield subcomponent, subratio * ratio
        else:
            yield component, ratio

# A dictionary of dictionaries with default 0.0 float values.
result = defaultdict(lambda: defaultdict(float))

# Resolve each compound and add up component ratios
for compound in mixes:
    for component, ratio in resolve(compound):
        result[compound][component] += ratio

pprint(result, width=1)

# Checking ratios of result compounds add up to 1
for compound, components in result.items():
    print(compound, sum(component for component in components.values()))

    Saída:

    defaultdict(<function <lambda> at 0x00000214CD56FB00>,
            {1: defaultdict(<class 'float'>,
                            {'A': 0.32,
                             'B': 0.127462,
                             'C': 0.2443,
                             'D': 0.049199999999999994,
                             'E': 0.20909999999999998,
                             'F': 0.0005740000000000001,
                             'H': 0.049364}),
             2: defaultdict(<class 'float'>,
                            {'B': 0.0182,
                             'C': 0.23,
                             'D': 0.12,
                             'E': 0.51,
                             'F': 0.0014000000000000002,
                             'H': 0.12040000000000001}),
             3: defaultdict(<class 'float'>,
                            {'A': 0.24,
                             'E': 0.76}),
             4: defaultdict(<class 'float'>,
                            {'B': 0.13,
                             'F': 0.01,
                             'H': 0.86}),
             5: defaultdict(<class 'float'>,
                            {'A': 0.12,
                             'B': 0.007280000000000001,
                             'C': 0.09200000000000001,
                             'D': 0.048,
                             'E': 0.5840000000000001,
                             'F': 0.0005600000000000001,
                             'G': 0.1,
                             'H': 0.04816000000000001})})
1 1.0
2 1.0
3 1.0
4 1.0
5 1.0
    • 1

relate perguntas