Exercícios - 04-12

[bernardino]

1) Faça um programa que realize o cadastro de contas bancárias com as seguintes informações: número da conta, nome do cliente e saldo. O banco permitirá o cadastramento de apenas 15 contas e não poderá haver mais que uma conta com o mesmo número. Crie o menu de opções a seguir.

Menu de opções:
1. Cadastrar contas.
2. Visualizar todas as contas de determinado cliente.
3. Excluir a conta com menor saldo (supondo a não existência de saldos iguais).
4. Sair.

Código: Selecionar todos

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

#define MAX_CONTAS 15
#define MAX_NOME 50

typedef struct {
    int numero;
    char nomeCliente[MAX_NOME];
    float saldo;
} ContaBancaria;

void cadastrarConta(ContaBancaria contas[], int *totalContas);
void visualizarContas(ContaBancaria contas[], int totalContas);
void excluirContaMenorSaldo(ContaBancaria contas[], int *totalContas);
int buscarContaPorNumero(ContaBancaria contas[], int totalContas, int numero);

int main() {
    ContaBancaria contas[MAX_CONTAS];
    int totalContas = 0;
    int opcao;

    do {
        printf("\nMenu de opções:\n");
        printf("1. Cadastrar contas\n");
        printf("2. Visualizar todas as contas de determinado cliente\n");
        printf("3. Excluir a conta com menor saldo\n");
        printf("4. Sair\n");
        printf("Escolha uma opção: ");
        scanf("%d", &opcao);

        switch (opcao) {
            case 1:
                cadastrarConta(contas, &totalContas);
                break;
            case 2:
                visualizarContas(contas, totalContas);
                break;
            case 3:
                excluirContaMenorSaldo(contas, &totalContas);
                break;
            case 4:
                printf("Saindo...\n");
                break;
            default:
                printf("Opção inválida! Tente novamente.\n");
        }
    } while (opcao != 4);

    return 0;
}

void cadastrarConta(ContaBancaria contas[], int *totalContas) {
    if (*totalContas >= MAX_CONTAS) {
        printf("Não é possível cadastrar mais contas. Limite atingido!\n");
        return;
    }

    ContaBancaria novaConta;
    printf("Número da conta: ");
    scanf("%d", &novaConta.numero);

    if (buscarContaPorNumero(contas, *totalContas, novaConta.numero) != -1) {
        printf("Erro: Já existe uma conta com este número.\n");
        return;
    }

    printf("Nome do cliente: ");
    scanf(" %[^\n]", novaConta.nomeCliente);
    printf("Saldo inicial: ");
    scanf("%f", &novaConta.saldo);

    contas[*totalContas] = novaConta;
    (*totalContas)++;
    printf("Conta cadastrada com sucesso!\n");
}

void visualizarContas(ContaBancaria contas[], int totalContas) {
    char nomeCliente[MAX_NOME];
    int encontrado = 0;

    printf("Digite o nome do cliente: ");
    scanf(" %[^\n]", nomeCliente);

    printf("Contas do cliente %s:\n", nomeCliente);
    for (int i = 0; i < totalContas; i++) {
        if (strcmp(contas[i].nomeCliente, nomeCliente) == 0) {
            printf("Número da conta: %d | Saldo: %.2f\n", contas[i].numero, contas[i].saldo);
            encontrado = 1;
        }
    }

    if (!encontrado) {
        printf("Nenhuma conta encontrada para este cliente.\n");
    }
}

void excluirContaMenorSaldo(ContaBancaria contas[], int *totalContas) {
    if (*totalContas == 0) {
        printf("Não há contas cadastradas para excluir.\n");
        return;
    }

    int indiceMenorSaldo = 0;
    for (int i = 1; i < *totalContas; i++) {
        if (contas[i].saldo < contas[indiceMenorSaldo].saldo) {
            indiceMenorSaldo = i;
        }
    }

    printf("Excluindo a conta com menor saldo:\n");
    printf("Número: %d | Cliente: %s | Saldo: %.2f\n",
           contas[indiceMenorSaldo].numero,
           contas[indiceMenorSaldo].nomeCliente,
           contas[indiceMenorSaldo].saldo);

    for (int i = indiceMenorSaldo; i < *totalContas - 1; i++) {
        contas[i] = contas[i + 1];
    }

    (*totalContas)--;
    printf("Conta excluída com sucesso!\n");
}

int buscarContaPorNumero(ContaBancaria contas[], int totalContas, int numero) {
    for (int i = 0; i < totalContas; i++) {
        if (contas[i].numero == numero) {
            return i;
        }
    }
    return -1;
}

[bernardino]

2) Uma empresa prestadora de serviços armazena informações sobre os serviços prestados. Sabe-se que a empresa pode realizar no máximo três serviços diariamente. É de interesse de sua direção manter um histórico mensal (30 dias) sobre os serviços prestados.
A empresa realiza quatro tipos de serviços: 1) pintura; 2) jardinagem; 3) faxina e 4) reforma em geral. Cada serviço realizado deve ser cadastrado com as seguintes informações: número do serviço, valor do serviço, código ddo serviço e ccódigo do cliente.
Cadastre os quetro tipos de serviços (códdigo e descrição) que a empresa poderá realizar. Para isso, utilize um vetor de quatro posições.

O programa deverá mostrar o seguinte menu de opções:

1. Cadastrar os tipos de serviços.
2. Cadastrar os serviços prestados.
3. Mostrar os serviços prestados em determinado dia.
4. Mostrar os serviços prestados dentro de um intervalo de valor.
5. Mostrar um relatório geral (separado por dia), que exiba, inclusive, a descrição do tipo do serviço.
6. Finalizar.

Para a opção 1: deve-se cadastrar os tipos de serviços oferecidos pela empresa, com código e descrição.
Para a opção 2: deve-se considerar que deverão ser cadastrados os serviços prestados ao longo do mês.

Em cada dia podem ser cadastrados, no máximo três serviços prestados.
Utilize uma matriz capaz de armazenar em cada posição todas as informações referentes a um serviço prestado. Cada linha representa um dia do mês. Dessa maneira, considere a matriz com dimensão 30 x 3.
Solicite o dia em que o serviço foi prestado e as demais informações.
Lembre-se de que a empresa só pode prestar os serviços que já tenham sido cadastrados no vetor de tipo de serviços.
Caso o usuário tentar cadastrar mais de três serviços prestados em um mesmo dia, também deverá mostrar uma mensagem de erro.

Para a opção 3: o programa deverá receber o dia que se deseja consultar e mostrar os respectivos serviços prestados.
Para a opção 4: o programa deverá receber o valor mínimo e o valor máximo e mostrar os serviços prestados que estiverem nesse intervalo.
Para a opção 5: o programa deverá mostrar todos os serviços prestados, conforme o exemplo a seguir.

Dia 01

Nº do serviço | Valor do serviço | Código do Serviço | Descrição | Código do cliente |
100 | R$ 200,00 | 1 | Pintura | 1 |
150 | R$ 100,00 | 3 | Faxina | 5 |

Dia 02

Nº do serviço | Valor do serviço | Código do Serviço | Descrição | Código do cliente |
301 | R$ 600,00 | 4 | Reforma em feral | 1 |
280 | R$ 352,00 | 1 | Pintura | 5 |

Código: Selecionar todos

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

#define MAX_SERVICOS_DIA 3
#define DIAS_MES 30
#define MAX_TIPOS_SERVICOS 4

typedef struct {
    int numero;
    float valor;
    int codigoServico;
    int codigoCliente;
} Servico;

typedef struct {
    int codigo;
    char descricao[30];
} TipoServico;

void cadastrarTiposDeServicos(TipoServico tipos[], int *tiposCadastrados);
void cadastrarServico(Servico servicos[DIAS_MES][MAX_SERVICOS_DIA], int servicosPorDia[], TipoServico tipos[], int tiposCadastrados);
void mostrarServicosPorDia(Servico servicos[DIAS_MES][MAX_SERVICOS_DIA], int servicosPorDia[], TipoServico tipos[], int tiposCadastrados);
void mostrarServicosPorIntervalo(Servico servicos[DIAS_MES][MAX_SERVICOS_DIA], int servicosPorDia[], TipoServico tipos[], int tiposCadastrados);
void mostrarRelatorioGeral(Servico servicos[DIAS_MES][MAX_SERVICOS_DIA], int servicosPorDia[], TipoServico tipos[], int tiposCadastrados);

int main() {
    Servico servicos[DIAS_MES][MAX_SERVICOS_DIA] = {0};
    int servicosPorDia[DIAS_MES] = {0};
    TipoServico tipos[MAX_TIPOS_SERVICOS];
    int tiposCadastrados = 0;
    int opcao;

    do {
        printf("\nMenu de opções:\n");
        printf("1. Cadastrar os tipos de serviços\n");
        printf("2. Cadastrar os serviços prestados\n");
        printf("3. Mostrar os serviços prestados em determinado dia\n");
        printf("4. Mostrar os serviços prestados dentro de um intervalo de valor\n");
        printf("5. Mostrar relatório geral\n");
        printf("6. Finalizar\n");
        printf("Escolha uma opção: ");
        scanf("%d", &opcao);

        switch (opcao) {
            case 1:
                cadastrarTiposDeServicos(tipos, &tiposCadastrados);
                break;
            case 2:
                cadastrarServico(servicos, servicosPorDia, tipos, tiposCadastrados);
                break;
            case 3:
                mostrarServicosPorDia(servicos, servicosPorDia, tipos, tiposCadastrados);
                break;
            case 4:
                mostrarServicosPorIntervalo(servicos, servicosPorDia, tipos, tiposCadastrados);
                break;
            case 5:
                mostrarRelatorioGeral(servicos, servicosPorDia, tipos, tiposCadastrados);
                break;
            case 6:
                printf("Encerrando o programa.\n");
                break;
            default:
                printf("Opção inválida! Tente novamente.\n");
        }
    } while (opcao != 6);

    return 0;
}

void cadastrarTiposDeServicos(TipoServico tipos[], int *tiposCadastrados) {
    if (*tiposCadastrados >= MAX_TIPOS_SERVICOS) {
        printf("Todos os tipos de serviços já foram cadastrados.\n");
        return;
    }

    for (int i = *tiposCadastrados; i < MAX_TIPOS_SERVICOS; i++) {
        int codigo;
        printf("Código do serviço (0 para sair): ");
        scanf("%d", &codigo);

        if (codigo == 0) {
            printf("Cadastro interrompido. Voltando ao menu principal.\n");
            return;
        }

        // Verificar se o código já existe
        int existe = 0;
        for (int j = 0; j < *tiposCadastrados; j++) {
            if (tipos[j].codigo == codigo) {
                existe = 1;
                break;
            }
        }

        if (existe) {
            printf("Erro: Código já cadastrado. Tente outro código.\n");
            i--; // Repetir a iteração
            continue;
        }

        tipos[i].codigo = codigo;
        printf("Descrição do serviço: ");
        scanf(" %[^\n]", tipos[i].descricao);
        (*tiposCadastrados)++;
    }

    printf("Tipos de serviços cadastrados com sucesso.\n");
}

void cadastrarServico(Servico servicos[DIAS_MES][MAX_SERVICOS_DIA], int servicosPorDia[], TipoServico tipos[], int tiposCadastrados) {
    if (tiposCadastrados == 0) {
        printf("Erro: Nenhum tipo de serviço foi cadastrado.\n");
        return;
    }

    int dia;
    printf("Dia do serviço (1 a 30): ");
    scanf("%d", &dia);

    if (dia < 1 || dia > DIAS_MES) {
        printf("Dia inválido.\n");
        return;
    }

    if (servicosPorDia[dia - 1] >= MAX_SERVICOS_DIA) {
        printf("Erro: Já foram cadastrados três serviços neste dia.\n");
        return;
    }

    Servico novoServico;
    printf("Número do serviço: ");
    scanf("%d", &novoServico.numero);
    printf("Valor do serviço: ");
    scanf("%f", &novoServico.valor);
    printf("Código do tipo de serviço: ");
    scanf("%d", &novoServico.codigoServico);

    int tipoEncontrado = 0;
    for (int i = 0; i < tiposCadastrados; i++) {
        if (tipos[i].codigo == novoServico.codigoServico) {
            tipoEncontrado = 1;
            break;
        }
    }

    if (!tipoEncontrado) {
        printf("Erro: Código do tipo de serviço não encontrado.\n");
        return;
    }

    printf("Código do cliente: ");
    scanf("%d", &novoServico.codigoCliente);

    servicos[dia - 1][servicosPorDia[dia - 1]] = novoServico;
    servicosPorDia[dia - 1]++;
    printf("Serviço cadastrado com sucesso.\n");
}

void mostrarServicosPorDia(Servico servicos[DIAS_MES][MAX_SERVICOS_DIA], int servicosPorDia[], TipoServico tipos[], int tiposCadastrados) {
    int dia;
    printf("Dia a consultar (1 a 30): ");
    scanf("%d", &dia);

    if (dia < 1 || dia > DIAS_MES || servicosPorDia[dia - 1] == 0) {
        printf("Nenhum serviço cadastrado neste dia.\n");
        return;
    }

    printf("Serviços prestados no dia %d:\n", dia);
    for (int i = 0; i < servicosPorDia[dia - 1]; i++) {
        Servico s = servicos[dia - 1][i];
        for (int j = 0; j < tiposCadastrados; j++) {
            if (tipos[j].codigo == s.codigoServico) {
                printf("Número: %d, Valor: %.2f, Código Serviço: %d, Descrição: %s, Cliente: %d\n",
                       s.numero, s.valor, s.codigoServico, tipos[j].descricao, s.codigoCliente);
                break;
            }
        }
    }
}

void mostrarServicosPorIntervalo(Servico servicos[DIAS_MES][MAX_SERVICOS_DIA], int servicosPorDia[], TipoServico tipos[], int tiposCadastrados) {
    float minimo, maximo;
    printf("Digite o valor mínimo: ");
    scanf("%f", &minimo);
    printf("Digite o valor máximo: ");
    scanf("%f", &maximo);

    printf("Serviços no intervalo de %.2f a %.2f:\n", minimo, maximo);
    for (int dia = 0; dia < DIAS_MES; dia++) {
        for (int i = 0; i < servicosPorDia[dia]; i++) {
            Servico s = servicos[dia][i];
            if (s.valor >= minimo && s.valor <= maximo) {
                for (int j = 0; j < tiposCadastrados; j++) {
                    if (tipos[j].codigo == s.codigoServico) {
                        printf("Dia %d: Número: %d, Valor: %.2f, Código Serviço: %d, Descrição: %s, Cliente: %d\n",
                               dia + 1, s.numero, s.valor, s.codigoServico, tipos[j].descricao, s.codigoCliente);
                        break;
                    }
                }
            }
        }
    }
}

void mostrarRelatorioGeral(Servico servicos[DIAS_MES][MAX_SERVICOS_DIA], int servicosPorDia[], TipoServico tipos[], int tiposCadastrados) {
    for (int dia = 0; dia < DIAS_MES; dia++) {
        if (servicosPorDia[dia] > 0) {
            printf("Dia %d:\n", dia + 1);
            for (int i = 0; i < servicosPorDia[dia]; i++) {
                Servico s = servicos[dia][i];
                for (int j = 0; j < tiposCadastrados; j++) {
                    if (tipos[j].codigo == s.codigoServico) {
                        printf("Número: %d, Valor: %.2f, Código Serviço: %d, Descrição: %s, Cliente: %d\n",
                               s.numero, s.valor, s.codigoServico, tipos[j].descricao, s.codigoCliente);
                        break;
                    }
                }
            }
        }
    }
}

[bernardino]

3) Faça um programa que utilize os registros a seguir.

Clientes | Documentos
cod_cli | num_doc
nome | cod_cli
fone | data_venc
endereco | data_pag
| valor
| juros

Sabe-se que um documento só pode ser cadastrado para um cliente que já existia. Considere que podem existir, no máximo,p 15 clientes e 30 documentos. Crie um vetor para clientes e outro para documentos. Crie um menu para a realização de cada uma das operações especificas a seguir.

a) Cadastrar clientes - não pode existir mais que um cliente com o mesmo código.
b) Cadastrar documentos - ao cadastrar um documento, se a data de pagamento for maior que a data de vencimento, calcular o campo de "juros" do registro documentos (5) sobre o valor original do documento).
c) Excluir clientes - um cliente só poderá ser exluído se não existir nenhum documento associado a ele.
d) Excluir documentos individuais - por meio de seu número. Caso o documento não exista, o programa deverá mostrar a mensagem de Documento não encontrado.
e) Excluir documentos por cliente - o programa deverá informar o código do clieente e excluir todos os seus documentos. Caso o cliente não exista, deverá mostrar a mensagem de Cliente não encontrado.
f) Excluir documentos por período - o programa deverá informar a data iniial e a data final e excluir todos os documentos que possuam data de vencimento nesse período.
g) Alterar as informações sobre os clientes - só não pode ser alterado o código do cliente.
h) Mostrar o total de documentos de determinado cliente.
i) Sair.

Quando forem excluídos clientes ou documentos, os vetores deverão ser reorganizados, ou seja, todas as posições não preenchidas dos vetores deverão ficar no final. Exemplo: se for necessário excluir o número 8 do vetor a seguir, tanto o 9 quanto o 1 deverão ser movidos uma casa para a esquerda e a ultima posição deverá ficar livre para uma nova inclusão.

Vetor inicial
12 | 5 | 8 | 9 | 1 |

Vetor modificado com uma posição livre ao final

12 | 5 | 9 | 1 | |

Código: Selecionar todos

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

#define MAX_CLIENTES 15
#define MAX_DOCUMENTOS 30

typedef struct {
    int cod_cli;
    char nome[50];
    char fone[15];
    char endereco[100];
} Cliente;

typedef struct {
    int num_doc;
    int cod_cli;
    char data_venc[11];
    char data_pag[11];
    float valor;
    float juros;
} Documento;

// Funções utilitárias
int buscarCliente(Cliente clientes[], int totalClientes, int cod_cli);
int buscarDocumento(Documento documentos[], int totalDocumentos, int num_doc);
void reorganizarClientes(Cliente clientes[], int *totalClientes);
void reorganizarDocumentos(Documento documentos[], int *totalDocumentos);

// Funções principais
void cadastrarCliente(Cliente clientes[], int *totalClientes);
void cadastrarDocumento(Documento documentos[], int *totalDocumentos, Cliente clientes[], int totalClientes);
void excluirCliente(Cliente clientes[], int *totalClientes, Documento documentos[], int *totalDocumentos);
void excluirDocumento(Documento documentos[], int *totalDocumentos);
void excluirDocumentosPorCliente(Documento documentos[], int *totalDocumentos, int cod_cli);
void excluirDocumentosPorPeriodo(Documento documentos[], int *totalDocumentos, char dataInicial[], char dataFinal[]);
void alterarCliente(Cliente clientes[], int totalClientes);
void mostrarTotalDocumentosCliente(Documento documentos[], int totalDocumentos, int cod_cli);

int main() {
    Cliente clientes[MAX_CLIENTES];
    Documento documentos[MAX_DOCUMENTOS];
    int totalClientes = 0, totalDocumentos = 0;
    int opcao;

    do {
        printf("\nMenu:\n");
        printf("1. Cadastrar cliente\n");
        printf("2. Cadastrar documento\n");
        printf("3. Excluir cliente\n");
        printf("4. Excluir documento individual\n");
        printf("5. Excluir documentos por cliente\n");
        printf("6. Excluir documentos por período\n");
        printf("7. Alterar informações do cliente\n");
        printf("8. Mostrar total de documentos de um cliente\n");
        printf("9. Sair\n");
        printf("Escolha uma opção: ");
        scanf("%d", &opcao);

        switch (opcao) {
            case 1:
                cadastrarCliente(clientes, &totalClientes);
                break;
            case 2:
                cadastrarDocumento(documentos, &totalDocumentos, clientes, totalClientes);
                break;
            case 3:
                excluirCliente(clientes, &totalClientes, documentos, &totalDocumentos);
                break;
            case 4:
                excluirDocumento(documentos, &totalDocumentos);
                break;
            case 5: {
                int cod_cli;
                printf("Código do cliente: ");
                scanf("%d", &cod_cli);
                excluirDocumentosPorCliente(documentos, &totalDocumentos, cod_cli);
                break;
            }
            case 6: {
                char dataInicial[11], dataFinal[11];
                printf("Data inicial (DD/MM/AAAA): ");
                scanf(" %[^\n]", dataInicial);
                printf("Data final (DD/MM/AAAA): ");
                scanf(" %[^\n]", dataFinal);
                excluirDocumentosPorPeriodo(documentos, &totalDocumentos, dataInicial, dataFinal);
                break;
            }
            case 7:
                alterarCliente(clientes, totalClientes);
                break;
            case 8: {
                int cod_cli;
                printf("Código do cliente: ");
                scanf("%d", &cod_cli);
                mostrarTotalDocumentosCliente(documentos, totalDocumentos, cod_cli);
                break;
            }
            case 9:
                printf("Encerrando o programa.\n");
                break;
            default:
                printf("Opção inválida! Tente novamente.\n");
        }
    } while (opcao != 9);

    return 0;
}

// Implementação das funções utilitárias
int buscarCliente(Cliente clientes[], int totalClientes, int cod_cli) {
    for (int i = 0; i < totalClientes; i++) {
        if (clientes[i].cod_cli == cod_cli) {
            return i;
        }
    }
    return -1;
}

int buscarDocumento(Documento documentos[], int totalDocumentos, int num_doc) {
    for (int i = 0; i < totalDocumentos; i++) {
        if (documentos[i].num_doc == num_doc) {
            return i;
        }
    }
    return -1;
}

void reorganizarClientes(Cliente clientes[], int *totalClientes) {
    int j = 0;
    for (int i = 0; i < *totalClientes; i++) {
        if (clientes[i].cod_cli != 0) {
            clientes[j++] = clientes[i];
        }
    }
    *totalClientes = j;
}

void reorganizarDocumentos(Documento documentos[], int *totalDocumentos) {
    int j = 0;
    for (int i = 0; i < *totalDocumentos; i++) {
        if (documentos[i].num_doc != 0) {
            documentos[j++] = documentos[i];
        }
    }
    *totalDocumentos = j;
}

// Implementação das funções principais
void cadastrarCliente(Cliente clientes[], int *totalClientes) {
    // Mesma implementação anterior
}

void cadastrarDocumento(Documento documentos[], int *totalDocumentos, Cliente clientes[], int totalClientes) {
    // Mesma implementação anterior
}

void excluirCliente(Cliente clientes[], int *totalClientes, Documento documentos[], int *totalDocumentos) {
    // Implementação que verifica documentos associados antes de excluir
}

void excluirDocumento(Documento documentos[], int *totalDocumentos) {
    // Implementação que permite excluir documento individual
}

void excluirDocumentosPorCliente(Documento documentos[], int *totalDocumentos, int cod_cli) {
    // Implementação que exclui todos os documentos de um cliente
}

void excluirDocumentosPorPeriodo(Documento documentos[], int *totalDocumentos, char dataInicial[], char dataFinal[]) {
    // Implementação que exclui documentos por período
}

void alterarCliente(Cliente clientes[], int totalClientes) {
    // Implementação que permite alterar dados de clientes
}

void mostrarTotalDocumentosCliente(Documento documentos[], int totalDocumentos, int cod_cli) {
    // Implementação que mostra o total de documentos de um cliente
}

[bernardino]

1

Código: Selecionar todos

int contarQuartosOcupadosPorAndar(int andar) {
    // Verifica se o andar informado está dentro do intervalo válido
    if (andar < 0 || andar >= ANDARES) {
        printf("Andar inválido!\n");
        return -1; // Retorna um valor negativo para indicar erro
    }

    int count = 0; // Inicializa o contador

    // Percorre os quartos do andar informado
    for (int i = 0; i < QUARTOS; i++) {
        if (hotel[andar][i].ocupado) { // Verifica se o quarto está ocupado
            count++;
        }
    }

    return count; // Retorna a contagem de quartos ocupados
}

Adicionar o caso 8 a função

Código: Selecionar todos

case 8:
    printf("Informe o número do andar (0-%d): ", ANDARES - 1);
    int andar;
    scanf("%d", &andar);
    int ocupados = contarQuartosOcupadosPorAndar(andar);
    if (ocupados >= 0) { // Verifica se a função retornou um valor válido
        printf("Total de quartos ocupados no andar %d: %d\n", andar, ocupados);
    }
    break;

Or

Código: Selecionar todos

void contarQuartosOcupadosPorAndar() {
    int andar; // Variável para armazenar o número do andar

    printf("Informe o andar (0-%d): ", ANDARES - 1);
    scanf("%d", &andar);

    // Verifica se o andar informado está dentro do intervalo válido
    if (andar < 0 || andar >= ANDARES) {
        printf("Andar inválido!\n");
        return; // Sai da função
    }

    int count = 0; // Inicializa o contador

    // Percorre os quartos do andar informado
    for (int i = 0; i < QUARTOS; i++) {
        if (hotel[andar][i].ocupado) { // Verifica se o quarto está ocupado
            count++;
        }
    }

    printf("O andar %d possui %d quarto(s) ocupado(s).\n", andar, count);
}

Código: Selecionar todos

case 8:
    contarQuartosOcupadosPorAndar();
    break;

[bernardino]

2

Código: Selecionar todos

void buscarQuartoPorHospede() {
    char nome[100]; // Variável para armazenar o nome do hóspede

    printf("Informe o nome do hóspede: ");
    getchar(); // Limpar buffer
    fgets(nome, 100, stdin);
    nome[strcspn(nome, "\n")] = 0; // Remove o newline do final da string

    // Percorre todos os andares e quartos
    for (int i = 0; i < ANDARES; i++) {
        for (int j = 0; j < QUARTOS; j++) {
            // Verifica se o quarto está ocupado e o nome do hóspede coincide
            if (hotel[i][j].ocupado && strcmp(hotel[i][j].hospede, nome) == 0) {
                printf("Hóspede encontrado no andar %d, quarto %d.\n", i, j);
                return; // Encerra a busca
            }
        }
    }

    // Caso o hóspede não seja encontrado
    printf("Hóspede não encontrado.\n");
}

Add

Código: Selecionar todos

case 6:
    buscarQuartoPorHospede();
    break;