C algoritmo para estacionamento rotativo

Usuário 3301 · 18 de março de 2020

Estou iniciando programação e gostaria de alguns esclarecimentos.

Estou na iniciativa de fazer um algoritmo que tenha um objetivo de estacionamento rotativo, porém estou passando por uma série de problemas e gostaria de ajuda.

O algoritmo deve seguir os seguintes passos:

Armazenar a placa do veículo, tal como a data e horário de entrada.
Quando o veículo sair, deverá realizar a seguinte operação:

- Se o veículo permanecer:

- 0 a 30 minutos: será cobrado o valor de 2,00.

- 30 minutos e 01 segundo até 1 hora: será cobrado o valor de 4,00.

- Após 1 hora, cada 10 minutos passados dentro do estabelecimento deverá ser cobrado 0,10 centavos a mais. Ex.:(1 hora de 10 minutos: 4,10.)

Estou a dias batendo cabeça com este problema e não consigo chegar a um algoritmo que faça isso por completo. Tentei no Python e no VisualG por ser "mais fácil" e agora estou tentando no C++/C/C#, mas ainda estou passando por complicações. Segue o algoritmo abaixo:

Ps.: Não conclui ainda o algoritmo justamente por causa das minhas dúvidas.

Primeira dúvida: como faço para armazenar uma variável e depois fazer o algoritmo encontrar ele depois de um tempo?

Segunda dúvida: como faço para o algoritmo contar o tempo de uma variável a partir do momento na qual ela foi registrada?

Quem puder me ajudar respondendo essas minhas dúvidas, me sentirei muito grato! Estou inciando as aulas agora e já quero me sentir avançado para não ter muitas dificuldades futuramente.

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

main(){
	char EntrSai;
	char Placa;
	char opcao;
	float Valor;
	
	printf("Escolha uma opção: (1) Registrar novo veiculo // (2) Registrar saida do veiculo\n");
	scanf("%c", &opcao);
	if (opcao == "1"){
		printf("Informe a placa do veiculo: \n");
		scanf("%s", &Placa);
	}
}

Aos que são gente boa, que Deus abençoe você e obrigado pelo auxílio!

Luís Roberto C. da Silva · 18 de março de 2020

Em relação a sua dúvida, para armazenar os dados em C deve implementar uma estrutura de dados, ou seja uma struct:

typedef struct{
  int entrada;
  int saida;
  char placa;
  float valor;
} Tcliente;

adicionado 3 minutos depois

Coloque entrada e saída como int porque ao pegar a hora do sistema vem em int.

É uma boa prática não iniciar os nomes das variáveis com letra maiúsculas.

Para instanciar a struc faz o seguinte:

Tclinente clentes[100];

Vai abria um vetor com cem clientes.

E para atribuir os valores faça assim:

clientes[0].placa = "KJR3210";

devair1010 · 18 de março de 2020

@Usuário 3301 para guardar a hora em que o veículo entrou você pega o horário do sistema e guarda em uma variável , se for o windows , pode usar esses comandos que pegam a hora e a data ,

#include <stdio.h>
char data1[9],hora[9],c[3];
int main(){
    _strdate(data1);
    _strtime(hora);
    printf("Data de entrada está em Inglês -> %s\n",data1);
    printf("Hora Minuto e Segundo ----------> %s\n",hora);
    return 0;
}

e depois na hora que o veiculo for sair use outra variável para pegar novamente o horário e subtraia o anterior do atual e terá o tempo que ele ficou no estacionamento ,

arfneto · 18 de março de 2020

Considere um ticket de estacionamento comum e implemente igualzinho.

Veja esse:

É só copiar. Implemente as funções em separado: check-in / check-out . Cobrança. E salve os valores em arquivo, tipo um registro de transações, para poder reconstruir se o programa parar...

Não seria uma ideia nova associar cada carro a um PRISMA e cada prisma uma vaga, certo?

Usuário 3301 · 18 de março de 2020

Fiz usando algumas dicas que recebi aqui e dando umas pesquisadas para compreender melhor cada uma delas.

Porém da alguns erros que não consigo identificar, por exemplo:

Diz que da um erro na linha 26...

Se vocês conseguirem identificar alguns erros, me diga o quais erros foram esse e o que devo fazer para ajeitar e porque deve ser feito isso. Obrigado!

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

typedef struct{
	float valor;
	char placa[10];
	char hora[9];
}Cliente;

Cliente cliente_1;

void menu();
void registrar();
void saida();

main(){
	menu();
	return 0;
	}

void menu(){
	int opcao;
	do
	printf("\n--------------------------------------- menu ----------------------------------------------\n");
	printf("(1) Registrar Veiculo\n");
	printf("(2) Saida de Veiculo\n");
	printf("----------------------------------------- XXXXX ----------------------------------------------\n");
	scanf("%d%*c", &opcao);
	switch(opcao){
		case 1:
			registrar();
			break
		case 2:
			saida();
			break
	}
}

void registrar(){
	printf("--------------------------------------- REGISTROS ----------------------------------------\n");
	printf("Informe a placa do carro que você deseja registrar: \n");
	scanf("%s%s", cliente_1.placa, cliente_1.hora);
	printf("\nVeiculo de placa: %s", cliente_1.placa);
	printf("\nEntrada: %s", cliente_1.hora);
	printf("--------------------------------------- XXXXXXXX- ------------------------------------------\n");
	
}

void saida(){
	printf("\n ------------------------------------------- SAIDA ---------------------------------------- \n");
	printf("Informe a placa do veiculo que deseja registrar a saida: \n");
	scanf("%s", cliente_1.placa);
	printf("\nVeiculo de placa: %s", cliente_1.placa);
	printf("\nSaida: %s", cliente_1.hora);
	printf("")
}

adicionado 3 minutos depois

3 minutos atrás, Usuário 3301 disse:

Fiz usando algumas dicas que recebi aqui e dando umas pesquisadas para compreender melhor cada uma delas.

Porém da alguns erros que não consigo identificar, por exemplo:

Diz que da um erro na linha 26...

Se vocês conseguirem identificar alguns erros, me diga o quais erros foram esse e o que devo fazer para ajeitar e porque deve ser feito isso. Obrigado!


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

typedef struct{
	float valor;
	char placa[10];
	char hora[9];
}Cliente;

Cliente cliente_1;

void menu();
void registrar();
void saida();

main(){
	menu();
	return 0;
	}

void menu(){
	int opcao;
	do
	printf("\n--------------------------------------- menu ----------------------------------------------\n");
	printf("(1) Registrar Veiculo\n");
	printf("(2) Saida de Veiculo\n");
	printf("----------------------------------------- XXXXX ----------------------------------------------\n");
	scanf("%d%*c", &opcao);
	switch(opcao){
		case 1:
			registrar();
			break
		case 2:
			saida();
			break
	}
}

void registrar(){
	printf("--------------------------------------- REGISTROS ----------------------------------------\n");
	printf("Informe a placa do carro que você deseja registrar: \n");
	scanf("%s%s", cliente_1.placa, cliente_1.hora);
	printf("\nVeiculo de placa: %s", cliente_1.placa);
	printf("\nEntrada: %s", cliente_1.hora);
	printf("--------------------------------------- XXXXXXXX- ------------------------------------------\n");
	
}

void saida(){
	printf("\n ------------------------------------------- SAIDA ---------------------------------------- \n");
	printf("Informe a placa do veiculo que deseja registrar a saida: \n");
	scanf("%s", cliente_1.placa);
	printf("\nVeiculo de placa: %s", cliente_1.placa);
	printf("\nSaida: %s", cliente_1.hora);
	printf("")
}

Luís Roberto C. da Silva · 18 de março de 2020

As funções devem ser escritas no início do código, logo após a declaração das structs.

adicionado 0 minutos depois

Em C, a última função escrita deve ser a função mais()

arfneto · 19 de março de 2020

4 horas atrás, Luís Roberto C. da Silva disse:

As funções devem ser escritas no início do código, logo após a declaração das structs.

adicionado 0 minutos depois

Em C, a última função escrita deve ser a função mais()

Não, Luis, não devem. Não creio que seja uma questão só de opinião ou de política de empresa ou academia.

A primeira função deve ser sempre main() e em muitos casos não há sequer outra função no mesmo arquivo. Há várias razões para isso. Vou te explicar algumas:

Quando você vai ler um programa que você recebeu, um programa que você não fez, porque alguém está te pagando para isso ou porque você é voluntário para isso ou porque alguém te pediu muito pra fazer isso, você quer ler main() porque é onde o programa começa. Assim é. Em C++ por exemplo em geral cada classe estará em outro arquivo. Quando você cria uma nova classe um IDE moderno já cria arquvos .h e .cpp para a classe, por exemplo. Em java também é assim.
No início do programa é pra ter apenas #include para os headers e talvez as declarações para a classe local. Se tiver funções escritas no mesmo arquivo se declaram os protótipos para as funções no início do texto, logo antes de main(), e no caso de ter declarado structs nesse arquivo você declara os protótipos imediatamente antes de main() porque quase certamente alguns deles vão declarar parâmetros desses tipos decjarados acima no arquivo.
Quando o código das funções for ficando pronto em geral elas vão sendo passadas para outros arquivos, porque você não quer o trabalho de compilar tudo de novo a toda hora e nem o risco de fazer algo errado e zoar tudo. Esse é um conceito muito importante.
Como sabe há muito material online em C e é fácil ver do que eu estou falando: abra algum projeto desses. Mas considere as razões práticas. main() perdida no meio de dezenas ou centenas de funções enfurece grande parte dos programadores.

Sobre código assim . . .

void registrar()
{
	printf("--------------------------------------- REGISTROS ----------------------------------------\n");
	printf("Informe a placa do carro que você deseja registrar: \n");
	scanf("%s%s", cliente_1.placa, cliente_1.hora);
	printf("\nVeiculo de placa: %s", cliente_1.placa);
	printf("\nEntrada: %s", cliente_1.hora);
	printf("--------------------------------------- XXXXXXXX- ------------------------------------------\n");
}

Nesse mesmo forum postei algo assim hoje

Escreva

    int registrar(char* placa, char* hora);

e retorne 0 se acha que deu certo. Por exemplo.

E assim você pode escrever

int resultado = registrar("ABC-1234", "21/03/20 15:16:17");

Não misture entrada e saída com suas funções. Só vai atrasar sua vida. Pense nisso.

E sobre seu código e o que parece ser norma aqui, entenda a declaração de scanf(): essa rotina não é pra isso, mas já que está usando para ler um único campo do teclado entenda que ela retorna um valor, e USE.

Luís Roberto C. da Silva · 19 de março de 2020

@arfneto disse isso por experiência própria. Quando estava na faculdade fazendo meus códigos o compilador não aceitava quando a função estava depois do main, eu usava Linux. Mas como faz tempo que compilo, pode ter mudado.

Usuário 3301 · 19 de março de 2020

Consegui resolver alguns problemas, por exemplo:

retirei o "do" logo após o void menu()

void menu(){
	int opcao;
	printf("\n--------------------------------------- menu ----------------------------------------------\n");
	printf("(1) Registrar Veiculo\n");
	printf("(2) Saida de Veiculo\n");
	printf("----------------------------------------- XXXXX ----------------------------------------------\n");
	scanf("%d%*c", &opcao);
	switch(opcao){
		case 1:
			registrar();
			break
		case 2:
			saida();
			break
	}
}

rodou perfeitamente, mas ainda estou passando por uns probleminhas.

No momento de tentar aplicar o horário do sistema ao exato momento que o veículo está sendo registrado dar um erro, não sei se foi da maneira que inseri o código. E problema também no armazenamento, no momento de registrar a saída do veículo a hora também não sai, querendo calcular o tempo de estadia que o cliente passou. Queria que o algoritmo guardasse o tempo e a placa do cliente em uma espécie de "pasta" e depois no momento de saída, o algoritmo pegasse a placa e junto o tempo de saída, fizesse o cálculo e me desse o valor. Estou tentando ainda!

arfneto · 19 de março de 2020

1 hora atrás, Luís Roberto C. da Silva disse:

disse isso por experiência própria. Quando estava na faculdade fazendo meus códigos o compilador não aceitava quando a função estava depois do main, eu usava Linux. Mas como faz tempo que compilo, pode ter mudado

Luis, não tem a ver com plataforma. Isso que eu expliquei é válido desde o Unix nos '80. O compilador não aceitava nos tempos da sua faculdade porque provavelmente não te explicaram corretamente que deveria declarar os protótipos antes. Nada mudou até hoje, exceto pela criação de ambientes integrados --- IDE --- e que em projetos grandes não são assim importantes. Nos '80 não haviam esses "terminais". Vou deixar um mini-exemplo no final.

Os programas de estudantes são muito diferentes dos programas que são escritos para resolver algo objetivo. A maior diferença é que um programa de estudante depois de pronto não é mais usado. E um programa comum passa a ser usado só depois de pronto. E em outras máquinas. Sem o fonte, sem IDE...

Mas pensando em um programa grande de estudante, imagine esse programa aqui de estacionamento sendo escrito por grupos de digamos 3 alunos. Eis a lógica disso: conforme seu programa cresce partes dele vão ficando prontas e você não quer ficar compilando tudo toda hora.Nesse programa de estacionamento você pode optar por implementar estruturas de dados: uma fila para os manobristas, uma fila para os carros. Separar a parte de check-in e check-out para ficar mais fácil controlar a performance dos manobristas e a rotatividade do serviço.

Então você vai escrever essas coisas em separado porque são mesmo distintas. E levar a programas em separado com funções main() especializadas para testar cada parte. É muito mais esperto. E permite que mais pessoas trabalhem no sistema ao mesmo tempo em partes separadas.

Então vai acabar com algo como

fila.h
fila.c
check-in.h
check-in.c
check-out.h
check-out.c
estaciona.c

E um monte de programas de teste. E em estaciona.c estará a função main() para o seu programa de estacionamento. E nesse arquivo apenas #include para esses .h todos. Seu programa principal só tem a lógica do estacionamento. Se aparece um problema na fila você vai lá em fila.c e arruma. Ou liga pro cara do seu grupo que fez essa parte e diz pra ele arrumar. E para testar ELE testa com os programas de teste da fila. Não mexe no programa de estacionamento que ele nem tem. E depois que ele arrumar essa parte e te mandar o código você apenas gera o estaciona.exe de novo porque ele sempre vai pegar as últimas versões de cada parte.

Por outro lado, veja um exemplo de um programa simples, em um único arquivo

No início do texto eu já posso ver como são declaradas as funções que estão em main(). Note que os protótipos não tem sequer nomes para as variáveis. Não precisa. Mas eu já começo a ler main() que é o que importa e já posso ver as declarações. É mais esperto.

Antes

Depois

E aqui tem as funções em alguma ordem. Como nenhuma ordem é assim absoluta elas estão em ordem alfabética. Ajuda a achar o código certo? Claro que no mundo moderno você pode em qualquer lugar do projeto --- se estiver usando um IDE --- apertar F12 e ir direto para a definição da função no seu projeto de centenas de arquivos e milhares de linhas. ah o progresso.

adicionado 31 minutos depois

1 hora atrás, Usuário 3301 disse:

No momento de tentar aplicar o horário do sistema ao exato momento que o veículo está sendo registrado dar um erro, não sei se foi da maneira que inseri o código. E problema também no armazenamento, no momento de registrar a saída do veículo a hora também não sai

Acho que não levou mesmo a sério o que eu te expliquei sobre não ler dados e enfiar no meio de seus testes. Seu problema seria bem mais simples se escrevesse a partir de primitivas assim como te mostrei.

Veja esse trecho:

// trecho

    printf("(1) Registrar Veiculo\n");
	printf("(2) Saida de Veiculo\n");
	printf("--------------------------\n");
	scanf("%d%*c", &opcao);
	switch(opcao){
		case 1:
			registrar();
			break
		case 2:
			saida();
			break
	}

Isso é problemático: não misture as coisas.

Imagine que prisma seja o número daquele quadradinho com base magnética que os caras põem nos carros em alguns estacionamentos...

E no programa principal poderia usar

    switch(opcao)
    {
        case REGISTRO:
            // le a placa do carro e arruma a hora certa
            // para emitir o ticket define um prisma para o manobrista 
            // levar o carro
            placa = le-placa();	// usa seja la o que for pra ler a placa
            hora = formata_data_e_hora(); // arruma "dd-mm-aa hh:mm:ss"
            prisma = registrar(placa, hora); // registra o carro vai gerar um ticket
            break;
        case SAIDA:
            // o dono do carro trouxe o ticket: chama uma funcao que identfica o prisma
            prisma = identifica_prima( numero_ticket);
            // com o prisma da a saida do carro	
            saida(prisma);
            break
	}

mas enquanto está escrevendo seu programa já pode usar

    prisma = registrar("ABC-1234", "15/03/20 15:55:00");
    emitir_ticket( prisma );
    saida( prisma );

Entendeu a diferença??? É muito mais simples. Não é sério a cada vez que vai testar o programa abrir um menu na tela e ficar 5 minutos digitando coisas. Não leva a nada.

Citação

Por exemplo um erro no scanf() vai atrapalhar o teste da rotina de registro de carro. Tem sentido?

1 hora atrás, Usuário 3301 disse:

Queria que o algoritmo guardasse o tempo e a placa do cliente em uma espécie de "pasta" e depois no momento de saída, o algoritmo pegasse a placa e junto o tempo de saída, fizesse o cálculo e me desse o valor

Sugiro usar um paradigma como o do ticket que te mostrei antes: crie um registro do carro com aquelas informações e associe a uma identificação . Prisma? Não seria nada original, mas funciona no mundo todo. E grave isso num vetor e no disco. Tipo um arquivo frota.dat e um array

    Prisma carros[Tamanho_do_Patio]; // um registro para cada carro no patio

onde Prisma é um registro como eu expliquei.

Não seria original. Lá estará um registro para cada carro no pátio. Também não é uma ideia original, mas funciona.

Luís Roberto C. da Silva · 19 de março de 2020

52 minutos atrás, arfneto disse:

Luis, não tem a ver com plataforma. Isso que eu expliquei é válido desde o Unix nos '80. O compilador não aceitava nos tempos da sua faculdade porque provavelmente não te explicaram corretamente que deveria declarar os protótipos antes. Nada mudou até hoje, exceto pela criação de ambientes integrados --- IDE --- e que em projetos grandes não são assim importantes. Nos '80 não haviam esses "terminais". Vou deixar um mini-exemplo no final.

Agora entendi. Nunca é tarde pra aprender. Porém estudamos pouco em C, o foco de lá era Java, o que acho um erro focar só em uma linguagem. C foi Introdução a Programação.

arfneto · 19 de março de 2020

11 minutos atrás, Luís Roberto C. da Silva disse:

Agora entendi. Nunca é tarde pra aprender. Porém estudamos pouco em C, o foco de lá era Java, o que acho um erro focar só em uma linguagem. C foi Introdução a Programação

Entendo. Então sabe que em java tem módulos e packages e tem uma infinidade de arquivos e import. A ideia é a mesma: separar unidades de código em arquivos separados. Escrever interfaces que seriam os headers e tal

Luís Roberto C. da Silva · 19 de março de 2020

4 minutos atrás, arfneto disse:

Entendo. Então sabe que em java tem módulos e packages e tem uma infinidade de arquivos e import. A ideia é a mesma: separar unidades de código em arquivos separados. Escrever interfaces que seriam os headers e tal

Sim, sim, disso tudo em sei.