Alguns produtos são elaborados utilizando-se para isso uma receita com quantidades fixas de cada ingrediente. Para esse exercício, pede-se:
a. Crie a estrutura Produto. Essa estrutura é composta por um Código (número inteiro somente para controle do sistema), um Nome e uma Unidade. Exemplo de valores para cada campo dessa estrutura: 1, “Farinha de Trigo”, “gramas”.
b. Crie a estrutura Estoque. Essa estrutura é composta por um Produto e uma Quantidade (número do tipo real).
c. Crie um vetor de Estoque para representar o estoque total de sua cozinha. Cada elemento Estoque deve ser inserido na posição do vetor que corresponde ao código de seu Produto;
d. Crie a estrutura Ingrediente. Um ingrediente é composto por um Produto e uma Quantidade (número do tipo real).
e. Crie uma estrutura para representar uma receita. Uma receita é composta por um Nome e um vetor de ingredientes.
f. Crie um vetor de receitas para representar todas as receitas existentes em sua cozinha.
g. Crie uma função que receba uma receita e o estoque total da cozinha. Essa função deve retornar 1 se existir estoque suficiente para a receita ou 0 se o estoque for insuficiente.
h. Crie uma função que receba uma receita e o estoque total da cozinha. Essa função deve subtrair do estoque da cozinha as quantidades dos respectivos itens da receita.
i. Crie uma função principal que permita ao usuário digitar o índice da receita desejada. Se existir estoque suficiente para que a receita seja feita (função criada em (e)), o sistema deve imprimir “Receita liberada!” e deve subtrair o estoque de cada ingrediente do estoque da cozinha (função criada em (f)). Se não houver estoque suficiente para a receita, o sistema deve apresentar a mensagem “Estoque insuficiente!”. O sistema deve continuar solicitando o índice da receita e tratando o estoque até que receba um índice inválido.

Passo 1

Resumindo, o enunciado pede para criar em C estruturas para controlar produtos, estoque e receitas, além de funções que verifiquem se há ingredientes suficientes no estoque e atualizem o estoque após preparar a receita. Vamos usar:
  • Structs para representar Produto, Estoque, Ingrediente e Receita.
  • Vetores estáticos para armazenar o estoque e o conjunto de receitas.
  • Funções para checar disponibilidade e para descontar do estoque.
  • Uma função principal que interaja com o usuário até que ele informe um índice inválido.

Passo 2

Definimos a estrutura Produto com três campos básicos:
typedef struct {
 int codigo; // chave de identificação
 char nome[50]; // nome do produto
 char unidade[20]; // unidade de medida (ex.: "gramas")
} Produto;

Passo 3

Criamos a estrutura Estoque que junta um Produto com uma quantidade disponível:
typedef struct {
 Produto produto; // produto associado
 float quantidade; // quantidade em estoque
} Estoque;

Passo 4

Definimos a estrutura Ingrediente (um produto + quantidade necessária) e a estrutura Receita (nome + vetor de ingredientes):
#define \(MAX_INGREDIENTES\) 10

typedef struct {
 Produto produto; // produto do ingrediente
 float quantidade; // quantidade necessária pela receita
} Ingrediente;

typedef struct {
 char nome[50]; // nome da receita
 Ingrediente ingredientes[\(MAX_INGREDIENTES\)];
 int \(num_ingredientes\); // quantos ingredientes válidos
} Receita;

Passo 5

Declaramos vetores estáticos para o estoque e para as receitas. Suponha limites máximos:
#define \(MAX_PRODUTOS\) 100
#define \(MAX_RECEITAS\) 20

Estoque estoque[\(MAX_PRODUTOS\)];
int \(num_produtos =0\); // conterá quantos produtos fizemos load

Receita receitas[\(MAX_RECEITAS\)];
int \(num_receitas =0\); // conterá quantas receitas cadastramos
Em um trecho de inicialização (antes do loop principal), você preencheria estoque[] e receitas[] manualmente ou lendo de algum lugar.

Passo 6

Implementamos a função que verifica se há estoque suficiente para uma dada receita:
int verificaDisponibilidade(const Receita *r, const Estoque e[], int \(n_prod\)) {
 for (int i \(=0\); i < r->\(num_ingredientes\); i\(++\)) {
 int cod = r->ingredientes[i].produto.codigo;
 float \(qtd_req\) = r->ingredientes[i].quantidade;
 if (cod < 0 || cod >= \(n_prod\)) return 0; // código inválido
 if (e[cod].quantidade < \(qtd_req\)) return 0; // falta no estoque
 }
 return 1; // tem tudo
}

Passo 7

Implementamos a função que desconta do estoque as quantidades usadas na receita:
void atualizarEstoque(const Receita *r, Estoque e[]) {
 for (int i \(=0\); i < r->\(num_ingredientes\); i\(++\)) {
 int cod = r->ingredientes[i].produto.codigo;
 float \(qtd_req\) = r->ingredientes[i].quantidade;
 e[cod].quantidade -= \(qtd_req\);
 }
}

Passo 8

Por fim, a função main faz um loop de leitura do índice da receita desejada, chama as funções acima e imprime a mensagem apropriada até receber um índice inválido:
#include <stdio.h>
#include <string.h>

// (a–g) Já definimos Produto, Estoque, Ingrediente, Receita, vetores e funções acima

int main() {
 // *** Exemplo de inicialização estática ***
 // preencher \(num_produtos\), estoque[0..\(num_produtos\)-1]
 // preencher \(num_receitas\), receitas[0..\(num_receitas\)-1]
 // --------------------------------------------------
 int idx;
 while (1) {
 printf("Digite o índice da receita (0 a %d, valor inválido para sair): ", \(num_receitas\)-1);
 if (scanf("%d", &idx) !\(=1\)) break;
 if (idx < 0 || idx >= \(num_receitas\)) {
 printf("Índice inválido. Encerrando.
");
 break;
 }
 if (verificaDisponibilidade(&receitas[idx], estoque, \(num_produtos\))) {
 printf("Receita liberada!
");
 atualizarEstoque(&receitas[idx], estoque);
 } else {
 printf("Estoque insuficiente!
");
 }
 }
 return 0;
}

Resposta

#include <stdio.h>
#include <string.h>

#define \(MAX_PRODUTOS\) 100
#define \(MAX_RECEITAS\) 20
#define \(MAX_INGREDIENTES\) 10

typedef struct {
 int codigo;
 char nome[50];
 char unidade[20];
} Produto;

typedef struct {
 Produto produto;
 float quantidade;
} Estoque;

typedef struct {
 Produto produto;
 float quantidade;
} Ingrediente;

typedef struct {
 char nome[50];
 Ingrediente ingredientes[\(MAX_INGREDIENTES\)];
 int \(num_ingredientes\);
} Receita;

Estoque estoque[\(MAX_PRODUTOS\)];
int \(num_produtos =0\);

Receita receitas[\(MAX_RECEITAS\)];
int \(num_receitas =0\);

int verificaDisponibilidade(const Receita *r, const Estoque e[], int \(n_prod\)) {
 for (int i \(=0\); i < r->\(num_ingredientes\); i\(++\)) {
 int cod = r->ingredientes[i].produto.codigo;
 float \(qtd_req\) = r->ingredientes[i].quantidade;
 if (cod < 0 || cod >= \(n_prod\)) return 0;
 if (e[cod].quantidade < \(qtd_req\)) return 0;
 }
 return 1;
}

void atualizarEstoque(const Receita *r, Estoque e[]) {
 for (int i \(=0\); i < r->\(num_ingredientes\); i\(++\)) {
 int cod = r->ingredientes[i].produto.codigo;
 float \(qtd_req\) = r->ingredientes[i].quantidade;
 e[cod].quantidade -= \(qtd_req\);
 }
}

int main() {
 // Aqui você inicializaria \(num_produtos\), estoque[],
 // \(num_receitas\) e receitas[] com os dados reais.
 // Exemplo:
 // \(num_produtos =2\);
 // estoque[0] = (Estoque){{0, "Farinha de Trigo", "gramas"}, 1000.0f};
 // estoque[1] = (Estoque){{1, "Açúcar", "gramas"}, 500.0f};
 // \(num_receitas =1\);
 // strcpy(receitas[0].nome, "Bolo Simples");
 // receitas[0].\(num_ingredientes =2\);
 // receitas[0].ingredientes[0] = (Ingrediente){{0, "Farinha de Trigo", "gramas"}, 300.0f};
 // receitas[0].ingredientes[1] = (Ingrediente){{1, "Açúcar", "gramas"}, 100.0f};

 int idx;
 while (1) {
 printf("Digite o índice da receita (0 a %d, valor inválido para sair): ", \(num_receitas\)-1);
 if (scanf("%d", &idx) !\(=1\)) break;
 if (idx < 0 || idx >= \(num_receitas\)) {
 printf("Índice inválido. Encerrando.
");
 break;
 }
 if (verificaDisponibilidade(&receitas[idx], estoque, \(num_produtos\))) {
 printf("Receita liberada!
");
 atualizarEstoque(&receitas[idx], estoque);
 } else {
 printf("Estoque insuficiente!
");
 }
 }
 return 0;
}

Exercícios relacionados