ADS25S1

ESTE EXERCÍCIO SÓ SERÁ AVALIADO PARA ESTUDANTES QUE O FIZEREM EM SALA DURANTE A AULA DO DIA 09/05/25

Imagine que você é o gerente de uma loja de eletrônicos e, devido a alta demanda, precisa gerenciar seu estoque de forma eficiente. Para isso, todos os produtos que estão no estoque são identificados por um código único, para que se possa diferenciar cada um, e uma etiqueta que informa a quantidade desse produto no estoque.

A medida que novos produtos chegam e outros são vendidos é preciso atualizar o estoque e, para isso, cada produto é registrado em uma lista simplesmente encadeada, onde cada nó representa um produto e uma quantidade. 

A cada hora essa lista é atualizada usando uma outra lista, a lista de operações.

A lista de operações contém cada operação realizada com produtos, por exemplo, venda, compra. Cada nó desta é composta por um código do produto, a operação realizada e a quantidade envolvida em tal operação.

A sua tarefa é desenvolver um programa que processe essa lista de operações, atualizando o estoque, e determine a quantidade final de cada produto envolvido nas operações após todas as operações serem realizadas.

Input

A entrada, inicialmente, é composta por um valor inteiro X (0 <= X <= 100) que determina quantas operações serão realizadas. Após isso, serão apresentadas X linhas. cada linha terá um inteiro C, uma string P e outro inteiro Q separados por um espaço em branco. A primeira informação recebida representa o código do produto, C, a segunda, P,  representa a operação e a terceira, Q, a quantidade. Os códigos dos produtos podem ter valores N (1 <= N <= 100). A quantidade dos produtos pode ter valores M (0 <= M <= 1000).

Output

A saída deverá conter uma linha contendo o código de cada produto, seguido da quantidade em estoque do mesmo após a realização de todas as operações. Em casos de o produto não estiver mais em estoque na loja, ou seja, sua quantidade no estoque for menor ou igual a 0, o mesmo não deverá ser impresso. A ordem dessas linhas deve ser a ordem em que os produtos apareceram na lista inicial

Example

Input:
3
10 adicionar 5
1 adicionar 2
10 remover 2

Output:
10 3
1 2

Funções de lista duplamente encadeada:

#include "lista_dupla.h"

Listad *cria_listad()
{

    Listad *L = (Listad *)malloc(sizeof(Listad));
    L->fim = L->ini = NULL;
    return L;
}

Nod *cria_nod(int info)
{
    Nod *novo = (Nod *)malloc(sizeof(Nod));
    novo->ant = novo->prox = NULL;
    novo->info = info;
    return novo;
}

Listad* insere_inicio_listad(Listad *L, int info)
{
    Nod *novo = cria_nod(info);

    if (L == NULL)
    {
        L = cria_listad();
        L->ini = L->fim = novo;
    }
    else
    {
        if (L->ini == NULL)
            L->ini = L->fim = novo;
        else
        {
            novo->prox = L->ini;
            L->ini->ant = novo;
            L->ini = novo;
        }
    }
    return L;
}


Listad* insere_fim_listad(Listad *L, int info)
{
    Nod *novo = cria_nod(info);

    if (L == NULL)
    {
        L = cria_listad();
        L->ini = L->fim = novo;
    }
    else
    {
        if (L->ini == NULL)
            L->ini = L->fim = novo;
        else
        {
            novo->ant = L->fim;
            L->fim->prox = novo;
            L->fim = novo;
        }
    }
    return L;
}

void mostra_listad(Listad *L)
{
    Nod* aux = L->ini;

    while(aux != NULL)
    {
        printf("%d ", aux->info);
        aux = aux->prox;
    }
    printf("\n");

}


Nod* remove_inicio_listad(Listad *L)
{
    Nod* aux = NULL;
    if (L != NULL && L->fim != NULL) //caso haja elemento
    {
        aux = L->ini;
        if (L->ini == L->fim)
        {   
            L->ini = L->fim = NULL;
        }
        else
        {
            L->ini = L->ini->prox;
            L->ini->ant = NULL;
        }
    }
    return aux;
}

Nod* remove_fim_listad(Listad *L)
{
    Nod* aux = NULL;
    if (L != NULL && L->fim != NULL) //caso haja elemento
    {
        aux = L->fim;
        if (L->ini == L->fim)
        {   
            L->ini = L->fim = NULL;
        }
        else
        {
            L->fim = L->fim->ant;
            L->fim->prox = NULL;
        }
    }
    return aux;
}

Funções de lista simplesmente encadeada:

#include "lista.h"

No *cria_no(int valor)
{
    No *novo = malloc(sizeof(No));
    novo->info = valor;
    novo->prox = NULL;
    return novo;
}

No *insere_inicio(No *inicio, int valor)
{
    No *novo = cria_no(valor);
    if (inicio == NULL)
        inicio = novo;
    else
    {
        novo->prox = inicio;
        inicio = novo;
    }
    return inicio;
}

No *insere_fim(No *L, int valor)
{
    No *novo = cria_no(valor);
    No *aux = L;

    if (L == NULL)
        L = novo;
    else
    {
        while (aux->prox != NULL)
            aux = aux->prox;
        aux->prox = novo;
    }
    return L;
}

No *remove_elemento(No **end_L, int elemento)
{
    No *aux, *anterior = NULL, *resposta = NULL;
    if (*end_L != NULL)
    {
        aux = *end_L;
        while (aux != NULL && aux->info != elemento)
        {
            anterior = aux;
            aux = aux->prox;
        }
        if (aux != NULL)
        {
            if (*end_L != aux)
                anterior->prox = aux->prox;
            else
                *end_L = aux->prox;
        }
        resposta = aux;
    }
    return resposta;
}

void mostra_lista(No *L)
{
    while (L != NULL)
    {
        printf("%d ", L->info);
        L = L->prox;
    }
}

No *libera_lista(No *L)
{
    No *aux = L;
    while (aux != NULL)
    {
        L = L->prox;
        free(aux);
        aux = L;
    }
    return NULL;
}

No *busca_elemento(No *L, int elemento)
{
    while (L != NULL && elemento != L->info)
        L = L->prox;
    return L;
}
// chamada: remove_inicio(&L)
No *remove_inicio(No **L)
{
    No *rem = NULL;
    if (*L == NULL)
        return NULL;
    else
    {
        rem = *L;
        *L = (*L)->prox;
        rem->prox = NULL;
        return rem;
    }
}
No *remove_fim(No **L)
{
    No *rem = NULL;
    No *ant;
    if (*L == NULL)
        return NULL;
    else
    {
        rem = *L;
        while (rem->prox != NULL)
        {
            ant = rem;
            rem = rem->prox;
        }
        ant->prox = NULL;
        return rem;
    }
}