Nos dan un diccionario de recetas, así como una lista de ingredientes crudos;

recipes = {
'axe': {'stick': 1, 'rock': 1, 'tape': 1},
'double_axe': {'axe': 2, 'tape': 1},
'quadruple_axe': {'double_axe': 2, 'tape': 1, 'rock': 2}
}

raw_ingredients = {'rock', 'stick', 'tape'}

La pregunta es; encuentre programáticamente el número de ingredientes crudos (de cada tipo) utilizados para cada receta. Tenga en cuenta que los ingredientes crudos solo incluyen rock, tape y stick.

Aquí está mi intento de resolver esta pregunta en Python;

def get_ingredients(name, s, l):
s[name]=dict1
#get dictionary for each recipe

k=dict1.keys()
#retrieve the keys
dict2={}
#define empty dictionary to store count of raw ingredients
for i in k:
 #loop over the keys   
    if i in l:
 #if key is a raw ingredient, we will increase the count for that corresponding raw ingredient
        dict2[i]=dict1[i]
    else:
#otherwise call the function recursively
        for j in range(0,dict1[i]):
        get_ingredients(i, s, l)

Aquí name puede ser {axe, double_axe,quadruple_axe}, s es lo mismo que recipes y l es lo mismo que raw_ingredients.

Entiendo completamente que mi código no está completo. Es solo mi primer intento de la pregunta, y estoy tratando de obtener el esqueleto aquí. Aquí están las dos preguntas clave con las que necesito ayuda;

  1. Primero, cómo realizar un seguimiento del recuento de los ingredientes necesarios, por ejemplo quadruple_axe necesita 4 barras en total.
  2. Segundo, ¿cuándo dejamos de recurrir, es decir, cuál es el caso base aquí?

Gracias de antemano por la ayuda

0
jayant 14 feb. 2020 a las 03:09

2 respuestas

La mejor respuesta

Primero, cómo hacer un seguimiento del recuento de los ingredientes necesarios, por ejemplo quadruple_axe necesita 4 palos en total.

Su instinto de usar un diccionario para reunir los recuentos de ingredientes es bueno:

dict2={}
#define empty dictionary to store count of raw ingredients

Pero, por favor, coloque el comentario antes en la línea sobre la que comenta, no después.

Segundo, ¿cuándo dejamos de recurrir, es decir, cuál es el caso base aquí?

Manejas directamente las materias primas, recurres en recetas secundarias. Por lo tanto, la reclusión se detiene naturalmente cuando ha agotado todas las recetas secundarias; no tiene que probarla explícitamente.

Le recomiendo que deje de pensar en términos de dict1 y dict2, así como i, j y k y programe en el idioma del problema. También le sugiero que use un defaultdict para recopilar su lista final de ingredientes crudos, convirtiéndola en un dict genérico al final si siente la necesidad. Pero esto es opcional y simplemente simplifica el código:

from collections import defaultdict

recipes = {
    'axe': {'stick': 1, 'rock': 1, 'tape': 1},
    'double_axe': {'axe': 2, 'tape': 1},
    'quadruple_axe': {'double_axe': 2, 'tape': 1, 'rock': 2}
}

raw_ingredients = {'rock', 'stick', 'tape'}

def count_raw_ingredients(recipe):
    ingredients = defaultdict(int)

    for ingredient, amount in recipes[recipe].items():
        if ingredient in raw_ingredients:
            ingredients[ingredient] += amount
        else:
            for subingredient, subamount in count_raw_ingredients(ingredient).items():
                ingredients[subingredient] += amount * subamount

    return dict(ingredients)

print(count_raw_ingredients('quadruple_axe'))

SALIDA

> python3 test.py
{'stick': 4, 'rock': 6, 'tape': 7}
>
1
cdlane 14 feb. 2020 a las 02:21

Su caso base es cuando el nombre del ingrediente no aparece como una etiqueta de receta. Se repite en los tres tipos axe; se detiene en stick, rock o tape.

Puede realizar un seguimiento pasando un dict de recuentos de ingredientes base. Por ejemplo, una comprobación de "doble hacha" devolverá el resumen computacional para 2 * {'stick': 1, 'rock': 1, 'tape': 1} + {'tape': 1}. Debería poder derivar ese código usted mismo, o buscarlo aquí con algo como "Python agrega valores dos dictos".

0
Prune 14 feb. 2020 a las 00:17