Amostras de saída
-4
A1
A26
A38
A23
-1
A80
A40
-2
A2
A16
A108
-3
A20
A44
0
A80 A20 A2 A1 A40 A44 A16 A26 A108 A38 A23
-4
A12
0
A2 A8 A77 A12 A33 A102 A33 A21 A866 A15 A9
Observação:
A solução deve ser implementada em linguagem C utilizando a estrutura de fila estática fornecida abaixo.
Código da Estrutura de Fila Estática:
#include <stdio.h>
#include <stdlib.h>
#include fila_s.h
struct fila {
item *dados;
int qtde, cap;
};
int fila_capacidade(fila *f){
if(f == NULL)
return 0;
return f->cap;
}
bool fila_cheia(fila *f){
return f->qtde==f-> cap;
}
void fila_esvaziar(fila *f){
if( f==NULL)
return;
f->qtde =0;
}
void fila_finalizar(fila f){
if( f==NULL)
return;
free(f->dados);
f-> dados = NULL;
item fila_frente(fila f){
return f->dados[f->qtde - 1];
}
fila
fila_inicializar(int cap){
fila nova_f = (fila) calloc(1, sizeof(fila));
if(nova_f != NULL){
nova_f->dados = (item
)calloc(cap, sizeof(item));
if(nova_f->dados == NULL){
free(nova_f);
nova_f = NULL;
}
nova_f->qtde = 0;
nova_f->cap = cap;
}
return nova_f;
}
bool fila_inserir(fila *f, item it){
if(f f->dados[i]=f->dados[i-1] NULL || fila_cheia(f) return false;
}
for(int == qtde; f->; ==0
;
f->dados[0] = it;
f->qtde++;
return true;
}
bool fila_remover(fila *f){
if(f NULL && fila_vazia(f)){
return false;
}
f->qtde–;
return true;
}
int fila_tamanho(fila *f){
if(f == NULL)
return 0;
return f->qtde;
}
bool fila_vazia(fila *f){
return qtde ;
}

Passo 1

Beleza, vamos lá! Pelo que entendi, você precisa implementar uma fila estática em linguagem C usando a estrutura de fila que foi fornecida. A fila é uma estrutura de dados onde os elementos são inseridos por um lado (final) e removidos por outro (frente), seguindo a ordem FIFO (First In, First Out). Para resolver isso, vamos precisar entender como inserir e remover elementos da fila, além de lidar com casos como fila cheia ou vazia.

Passo 2

Primeiro, precisamos inicializar a fila com uma capacidade definida. A função fila_inicializar faz isso alocando memória para a estrutura da fila e para os dados que ela vai armazenar. Vamos chamar essa função passando a capacidade que queremos para a fila.

Passo 3

Agora, vamos lidar com a inserção de elementos na fila. A função fila_inserir é usada para adicionar um novo item na fila. Ela verifica se a fila está cheia usando a função fila_cheia. Se não estiver cheia, o novo elemento é adicionado no início da fila (índice 0), e os outros elementos são deslocados para a direita. Isso garante que o primeiro elemento inserido fique na frente da fila.

Passo 4

Para remover elementos da fila, usamos a função fila_remover. Essa função verifica se a fila está vazia com a função fila_vazia. Se não estiver vazia, ela simplesmente decrementa a contagem de elementos (qtde), removendo o elemento da frente da fila.

Passo 5

Vamos agora considerar os dados de entrada que você forneceu. Parece que temos uma sequência de comandos, onde números negativos indicam operações de remoção e strings como “A1”, “A26”, etc., indicam inserções na fila. Por exemplo, -4 pode significar que precisamos remover 4 elementos da fila, enquanto A1 significa inserir o elemento “A1”.

Passo 6

Vamos escrever um loop que lê cada linha de entrada. Se a linha começar com um número negativo, vamos chamar a função fila_remover o número de vezes indicado pelo valor absoluto desse número. Se a linha começar com “A”, vamos chamar a função fila_inserir passando o elemento correspondente.

Passo 7

Finalmente, após processar todas as entradas, vamos imprimir o estado final da fila. Para isso, vamos percorrer os elementos armazenados na fila e exibi-los na ordem correta, do primeiro ao último.

Resposta

Abaixo está um exemplo de como implementar essa solução em C usando a estrutura de fila estática fornecida:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "fila_s.h"

typedef char item; // Supondo que os itens são strings como "A1", "A26", etc.

int main() {
    fila *f = fila_inicializar(100); // Inicializa a fila com capacidade 100
    if(f == NULL){
        printf("Erro ao inicializar a fila.\n");
        return 1;
    }

    char input[20];
    while(scanf("%s", input) != EOF){
        if(input[0] == '-'){
            int removals = atoi(input);
            removals = abs(removals);
            for(int i = 0; i < removals; i++){
                if(!fila_remover(f)){
                    break; // Não há mais elementos para remover
                }
            }
        }
        else{
            if(!fila_inserir(f, input)){
                printf("Fila cheia! Não foi possível inserir %s.\n", input);
            }
        }
    }

    // Imprime os elementos da fila
    for(int i = 0; i < fila_tamanho(f); i++){
        printf("%s ", f->dados[i]);
    }
    printf("\n");

    fila_finalizar(f); // Libera a memória alocada
    return 0;
}
Esse código lê entradas até o fim do arquivo. Se a entrada começar com ‘-’, ele remove o número de elementos indicado. Se for uma string que começa com ‘A’, ele insere na fila. No final, imprime os elementos restantes na fila na ordem correta.

Exercícios relacionados