void inserirBicicleta(tipoBicicleta bicicletas[MAX_BICICLETAS], int *pQuantidadeBicicletas)
{
    int estado,cont;

    if(*pQuantidadeBicicletas==MAX_BICICLETAS)
    {
        printf("\nNao pode inserir mais bicicletas.");
    }
    else
    {
        lerString("\nInsira designacao da bicicleta: ", bicicletas[*pQuantidadeBicicletas].idBicicleta, MAX_STRING);
        // bicicletas[*pQuantidadeBicicletas].idBicicleta =(*pQuantidadeBicicletas);
        printf("\nBicicleta[%s]:", bicicletas[*pQuantidadeBicicletas].idBicicleta);
        lerString("\nInsira modelo da bicicleta: ",bicicletas[*pQuantidadeBicicletas].modelBicicleta, MAX_STRING);
        bicicletas[*pQuantidadeBicicletas].localBicicleta=lerInteiro("\nInsira onde se encontra a bicicleta:\n\n0 - Residencias\n1 - Campus1\n2 - Campus2\n3 - Campus5\n",0,3);
        bicicletas[*pQuantidadeBicicletas].distanciaTotal=0.0;
        bicicletas[*pQuantidadeBicicletas].avarias=0;
        bicicletas[*pQuantidadeBicicletas].numEmprestimos=0;
        bicicletas[*pQuantidadeBicicletas].estadoBicicleta=0;
        (*pQuantidadeBicicletas)++;
        do
        {
            estado=lerInteiro("\nInsira estado da bicicleta:\n\n 0 - Disponivel\n2 - Avariada\n",0,2);
            cont++;
            if(estado==1)
            {
                printf("\n1 Nao e uma opcao valida. Insira 0 ou 2.");
                cont++;
                if(cont>=2)
                {
                    printf("\nNao insista, insira um valor valido.");
                }
            }
        }
        while(estado==1);
        if(estado==0)
        {
            bicicletas[(*pQuantidadeBicicletas)-1].estadoBicicleta=0;
        }
        else
        {
            do
            {
                registarAvaria(bicicletas,*pQuantidadeBicicletas);
            }
            while(bicicletas[(*pQuantidadeBicicletas)-1].estadoBicicleta==0);
        }
    }
    printf("\nBicicleta registada com sucesso.");
}
Exemple #2
0
/*
* funcao para inserir os baloes no vetor baloesStruct
* baloes - baloesStruct em vetor
* contador - contadorStruct por referência
*/
void inserirBaloes(baloesStruct baloes[], contadorStruct *contador){
    int numero;
    int novaposicao=contador->nrBaloes;
    if(contador->nrBaloes<MAXIMO_BALOES){
    //numero do balao
    numero = loopPesquisaBalaoinValido(baloes, contador->nrBaloes);
    baloes[novaposicao].numero=numero;
    //designacao
    printf("Insira a designacao do balao:\n");
    lerString(baloes[novaposicao].designacao, MAX_DESIGNACAO);
    baloes[novaposicao].data=loopDataBalao(baloes[novaposicao].data);
    //Lotacao maxima do balao
    printf("Insira a lotacao maxima MAX ate %d\n", LOTACAOMAXIMA);
    baloes[novaposicao].lotacaoMaxima = lerNumero(LOTACAOMINIMA, LOTACAOMAXIMA);
    //posicao do balao
    baloes[novaposicao].localInicio = loopPedirPosicao("Insira a sua posicao A, B ou C:\n");
    baloes[novaposicao].localFinal='\0';
    baloes[novaposicao].bilhetes=NULL;
    baloes[novaposicao].nrBilhetes=0;
    baloes[novaposicao].numeroPessoasTransportadas=0;
    baloes[novaposicao].Totalviagens=0;
    baloes[novaposicao].nrTuristasNobalao=0;
    infoBaloes(baloes[novaposicao]);
    printf("Balao inserido com sucesso!\n");
    contador->nrBaloes++;
    }else{
        printf("O maximo de baloes suportado e: %d\n Nao e possivel inserir mais baloes!", MAXIMO_BALOES);
    }
}
Exemple #3
0
/* Alterar dados do balao
* Variaveis de entrada
*  baloes - baloesStruct em vetor
* contador - contadorStruct por referência
*/
void alterarDadosBalao(baloesStruct baloes[], contadorStruct *contador){
    int opcao, posicao=-1;
    printf("\n\n ALTERACAO DE DADOS NOS BALOES! \n \n");
    posicao = loopPesquisaBalaoValido(baloes, *contador);
    infoBaloes(baloes[posicao]); //mostra a info do balao
    do{
        printf("\n\n\n#############################################################\n");
        printf("#_______________ MENU BALAO -> Alterar Balao %d    _________#\n", baloes[posicao].numero);
        printf("#_______________ 1 - Alterar Tudo                  _________#\n");
        printf("#_______________ 2 - Alterar Designacao            _________#\n");
        printf("#_______________ 3 - Alterar data                  _________#\n");
        printf("#_______________ 4 - Alterar lotacao maxima        _________#\n");
        printf("#_______________ 5 - Alterar posicao inicial       _________#\n");
        printf("#_______________ 0 - Sair                          _________#\n");
        printf("#############################################################\n");
        printf("Escolha uma opcao: ");
        opcao = lerNumero(0,5);
        switch(opcao){
            case 1: //alterar tudo
                //elimina e cria um novo balao
                if(eliminarBaloes(baloes, contador, posicao)==1){
                    inserirBaloes(baloes, contador);
                }
            break;
            case 2: //alterar a designcao
                printf("Insira a nova designacao:\n");
                lerString(baloes[posicao].designacao, MAX_DESIGNACAO);
                infoBaloes(baloes[posicao]);
            break;
            case 3://alterar a data
                baloes[posicao].data=loopDataBalao(baloes[posicao].data);
                infoBaloes(baloes[posicao]);
            break;
            case 4://alterar a lotacao maxima
                printf("Insira a nova lotacao maxima:\n");
                baloes[posicao].lotacaoMaxima = lerNumero(LOTACAOMINIMA, LOTACAOMAXIMA);
                infoBaloes(baloes[posicao]);
            break;
            case 5: //alterar a localizaçao
                baloes[posicao].localInicio = loopPedirPosicao("Insira a sua posicao A, B ou C:\n");
                //baloes[posicao] = pedirPosicaoBalao(baloes[posicao]);
                infoBaloes(baloes[posicao]);
            break;
        }
    }while(opcao!=0);
}
int procuraBicicleta(tipoBicicleta bicicletas[MAX_BICICLETAS],int quantBicicletas)
{
    int i,pos=-1;
    char designacao[MAX_STRING];
    lerString("\nInsira designacao da bicicleta: ", designacao, MAX_STRING);
    for(i=0; i<quantBicicletas; i++)
    {
        //aux=strcmp(designacao,bicicletas[i].idBicicleta);
        if(strcmp(designacao,bicicletas[i].idBicicleta)==0)
        {
            pos=i;
            i=quantBicicletas;
        }

    }

    return pos;
}
void main(){
    // RECEBE E IMPRIME UM INTEIRO
    int var_int = lerInt("Digite um Inteiro: \n",
                         "Erro! Digite somente Inteiros:\n");
    imprimirInt("Inteiro:\n",var_int);

    // RECEBE E IMPRIME UM LONG
    long var_long = lerLong("Digite um Long: \n",
                            "Erro! Digite somente Long:\n");
    imprimirLong("Long:\n",var_long);

    // RECEBE E IMPRIME UM PONTO FLUTUANTE
    // APRESENTA PROBLEMAS DE PRECISÃO
    float var_float = lerFloat("Digite um Float: \n",
                                "Erro! Digite somente Float:\n");
    imprimirFloat("Float:\n", var_float);

    // RECEBE E IMPRIME UM CHAR
    char var_char = lerChar("Digite um Char: \n");
    imprimirChar("Char:\n",var_char);

    // RECEBE E IMPRIME UMA STRING
    char *var_string = lerString("Digite uma String: \n",
                                 255);
    imprimirString("String:\n",var_string);

    // RECEBE E IMPRIME ARRAY DE STRINGS

    char **var_arrayString = lerArrayDeString("Lendo array de strings!\n",
                                              "Digite o conteudo da string:\n",
                                              3,
                                              255);
    imprimirArrayDeStrings("Array de Strings:\n",
                           "",
                           var_arrayString);

    // FUNÇÃO DE TROCA DE LETRAS

    char textToChange[] = "THE QUICK BROWN FOX JIUMPS OVER THE LAZY DOG";
    printf("\nTexto antes: \n%s", textToChange);
    *trocaChar(textToChange, 'O', 'A');
    printf("\nTexto depois: \n%s\n",textToChange);*/

}
Exemple #6
0
int main(){
	//Declaracao de variaveis
	char frase[MAX];

	//Ler a string e imprimir.
	lerString(frase);
	printf("Antes: %s\n",frase);

	//Modificar a string para caixa alta
	toUpperCase(frase);
	printf("Depois(UpperCase): %s\n",frase);

	//Modificar a string para caixa baixa
	toLowerCase(frase);
	printf("Depois(LowerCase): %s\n",frase);
	// Imprime a quantidade de caracteres que contem na frase
	printf("Quantidade de caracteres: %i\n",meustrlen(frase));

} 
void registarAvaria(tipoBicicleta bicicletas[MAX_BICICLETAS], int quantBicicletas)
{
    int pos;
    tipoAvaria avarias;
    printf("\nRegisto de avaria:");
    pos=procuraBicicleta(bicicletas,quantBicicletas);
    if(pos==-1)
    {
        printf("\nBicicleta nao existe.");
    }
    else
    {
        bicicletas[pos].estadoBicicleta=2;
        bicicletas[pos].avarias++;
        strcpy(avarias.idBicicleta,bicicletas[pos].idBicicleta);
        avarias.distanciaTotal=bicicletas[pos].distanciaTotal;
        printf("\nInsira data e hora da avaria: ");
        avarias.dataAvaria=lerData();
        avarias.horaAvaria=lerHora();
        lerString("\nInsira a descricao da avaria: ", avarias.descricao,MAX_STRING);
        gravarAvariasLog(avarias);
    }
}
Exemple #8
0
int main(int argc, char** argv) {
    
    ListaDeVetores lP;
    int op = 10;

    while (op!=0) {
        imprimeMenu();
        scanf("%d",&op);
        switch(op)
        {
            case 1:
                try
                {
                    lP.adiciona(lerString());
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 2:
                try
                {
                    lP.adicionaNoInicio(lerString());
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 3:
                try
                {
                    lP.adicionaNaPosicao(lerString(),lerInt());
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            
            case 4:
                try
                {
                    lP.adicionaEmOrdem(lerString());
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 5:
                try
                {
                    char *aux = lP.retira();
                    printf("%s foi retirado da lista.\n\n",aux);
                    delete(aux);
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 6:
                try
                {
                    char *aux = lP.retiraDoInicio();
                    printf("%s foi retirado da lista.\n\n",aux);
                    delete(aux);
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 7:
                try
                {
                    char *aux = lP.retiraDaPosicao(lerInt());
                    printf("%s foi retirado da lista.\n\n",aux);
                    delete(aux);
                }catch(int exc)
                {
                    except(exc);
                }
                break;
             case 8:
                try
                {
                    char *aux = lP.retiraEspecifico(lerString());
                    printf("%s foi retirado da lista.\n\n",aux);
                    delete(aux);
                }catch(int exc)
                {
                    except(exc);
                }
                break;
             case 9:
                try
                {
                    imprimirLista(&lP);
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 0:
               printf("Hasta La Vista Baby!\n");
            	break;
            default:
                printf("Sinto muito, opção inválida.\n");
                break;
        }
    }
    return 0;
}
Exemple #9
0
int main(int argc, char const *argv[])
{
    FILE *fp = fopen("googlebot.txt", "r");
    LISTA *lista = criar_lista();
    int oper, codigo, relevancia, i;
    char *palavra, *nomeSite, *link;

    leArquivo(fp, lista);

    fclose(fp);

	if(fp != NULL){
        do{
            printf("1 - Inserir site\n2 - Inserir palavra chave\n3 - Remover um site\n4 - Atualizar relevancia\n");
            printf("5 - Mostrar lista\n6 - Busca por palavra chave\n7 - Sugestoes de sites\n8 - Sair\n\n");
            scanf("%d", &oper);
            switch(oper){
                case 1:
                //Inserir um novo site na lista
                    do{
                        printf("Codigo: ");
                        scanf("%d", &codigo);
                        if(codigo < 0 || codigo > 9999)
                            printf("Codigo invalido. Digite um valor entre 0 e 9999\n");
                    }while(codigo < 0 || codigo > 9999);

                    getchar();
                    printf("Nome Site: ");
                    nomeSite = lerString();
                    if(strlen(nomeSite) > TAM-1)
                        nomeSite[TAM-1] = '\0';

                    do{
                        printf("Relevancia: ");
                        scanf("%d", &relevancia);
                        if(relevancia < 0 || relevancia > 1000)
                            printf("Relevancia invalido. Digite um valor entre 0 e 1000\n");
                    }while(relevancia < 0 || relevancia > 1000);

                    getchar();
                    printf("Link: ");
                    link = lerString();
                    if(strlen(link) > N-1)
                        link[N-1] = '\0';

                    if(!insere_site( lista, criar_no(criar_item(codigo, nomeSite, relevancia, link)))){
                        printf("Erro ao inserir site!\n");
                    }

                    free(link);
                    free(nomeSite);
                    break;
                case 2:
                //Inserir palavra chave
                    do{
                        printf("Codigo: ");
                        scanf("%d", &codigo);
                        if(codigo < 0 || codigo > 9999)
                            printf("Codigo invalido. Digite um valor entre 0 e 9999\n");
                    }while(codigo < 0 || codigo > 9999);

                    getchar();
                    printf("Palavra chave: ");
                    palavra = lerString();
                    if(strlen(palavra) > TAM-1)
                        palavra[TAM-1] = '\0';

                    for(i=0; i < strlen(palavra); i++){
                        palavra[i] = ctolower(palavra[i]);
                    }

                    if(!insere_chave(lista, codigo, palavra)){
                        printf("Erro ao inserir palavra chave!\n");
                    }
                    free(palavra);
                    break;
                case 3:
                //Remover um site
                    do{
                        printf("Codigo: ");
                        scanf("%d", &codigo);
                        if(codigo < 0 || codigo > 9999)
                            printf("Codigo invalido. Digite um valor entre 0 e 9999\n");
                    }while(codigo < 0 || codigo > 9999);

                    if(!remove_site(lista, codigo)){
                        printf("Erro ao remover site!\n");
                    }
                    break;
                case 4:
                //Atualizar relevancia
                    do{
                        printf("Codigo: ");
                        scanf("%d", &codigo);
                        if(codigo < 0 || codigo > 9999)
                            printf("Codigo invalido. Digite um valor entre 0 e 9999\n");
                    }while(codigo < 0 || codigo > 9999);

                    do{
                        printf("Relevancia: ");
                        scanf("%d", &relevancia);
                        if(relevancia < 0 || relevancia > 1000)
                            printf("Relevancia invalido. Digite um valor entre 0 e 1000\n");
                    }while(relevancia < 0 || relevancia > 1000);

                    atualiza_relevancia(lista, codigo, relevancia);
                    break;
                case 5:
                //Mostrar a lista
                    imprime_lista(lista);
                    break;
                case 6:
                //Busca por palavra chave
                    getchar();
                    printf("Palavra chave: ");
                    palavra = lerString();
                    if(strlen(palavra) > TAM-1)
                        palavra[TAM-1] = '\0';

                    for(i=0; i < strlen(palavra); i++){
                        palavra[i] = ctolower(palavra[i]);
                    }

                    busca_palavra(lista, palavra);
                    free(palavra);
                    break;
                case 7:
                //Sugestao do site
                    getchar();
                    printf("Palavra chave: ");
                    palavra = lerString();
                    if(strlen(palavra) > TAM-1)
                        palavra[TAM-1] = '\0';

                    for(i=0; i < strlen(palavra); i++){
                        palavra[i] = ctolower(palavra[i]);
                    }

                    sugestao_site(lista, palavra);
                    free(palavra);
                    break;
                default: break;
            }
        }while(oper != 8);

        finaliza_lista(&lista);
	} else {
    	printf("Could not open googlebot.txt\n");
    }

	return 0;
}
Exemple #10
0
//compra bilhetes e adiciona automaticamente na sua lista de espera
void comprarBilhetes(contadorStruct *contador, listaEsperaStruct lista[]){
    int nrPessoas=0, i=0;
    bilhetesStruct bilhetesTemp;
    bilhetesStruct *bilhetesAUX;
    float totalBilheteIndividual =0;
    //pede o numero de pessoas ao utilizador para verificar se o bilhete +e idividual ou de grupo
    printf("Insira o numero de pessoas: ");
    nrPessoas = lerNumero(1, LOTACAOMAXIMA);
        bilhetesTemp.nrPessoas = nrPessoas;
        bilhetesTemp.preco=0;
        contador->pListaEspera +=nrPessoas;
        //pede a origem e o destino do balao
        bilhetesTemp.origem = loopPedirPosicao("Insira a sua posicao?\n");
        bilhetesTemp.destino = loopPedirPosicao("Insira o destino?\n");
        //bilhete em grupo
        if(nrPessoas>1){
            printf("Insira o nome do grupo: ");
            lerString(bilhetesTemp.nome, MAX_NOME);
            bilhetesTemp.grupo = GRUPO;
            for(i=0; i<nrPessoas; i++){
                bilhetesTemp.preco += contador->preco;
            }
            bilhetesTemp.preco = totalaPagar(bilhetesTemp.preco*nrViagens(bilhetesTemp.origem, bilhetesTemp.destino), DESCONTO); //preco*nr de viagens
            //mostra o total do preco dos bilhetes
            printf("Total de todos os bilhetes: %.2f\n", bilhetesTemp.preco);
            contador->receita+=bilhetesTemp.preco;
            //preco individual
            totalBilheteIndividual = totalaPagar(contador->preco*nrViagens(bilhetesTemp.origem, bilhetesTemp.destino), DESCONTO);
            //mostra o total do preco por pessoa
            printf("Preco por pessoa: %.2f\n", totalBilheteIndividual);
        }else{
            //bilhete individual
            bilhetesTemp.grupo = SEM_GRUPO;
            bilhetesTemp.preco = totalaPagar(contador->preco*nrViagens(bilhetesTemp.origem, bilhetesTemp.destino), SEM_DESCONTO);
            contador->receita+=bilhetesTemp.preco;
            printf("Total a pagar e: %.2f\n", bilhetesTemp.preco);
        }
        switch(bilhetesTemp.origem){
            case 'A':
                lista[POS_A].nrBilhetes+=1;
                contador->destinoA+=1;
                bilhetesAUX = realloc(lista[POS_A].bilhetes,lista[POS_A].nrBilhetes*sizeof(bilhetesStruct));
                if(bilhetesAUX!=NULL)
                {
                    lista[POS_A].bilhetes = bilhetesAUX;
                    lista[POS_A].bilhetes[lista[POS_A].nrBilhetes-1] = bilhetesTemp;
                }else{
                    printf("Ocorreu um erro na memoria");
                }
            break;
            case 'B':
                lista[POS_B].nrBilhetes+=1;
                contador->destinoB+=1;
                bilhetesAUX = realloc(lista[POS_B].bilhetes,lista[POS_B].nrBilhetes*sizeof(bilhetesStruct));
                if(bilhetesAUX!=NULL)
                {
                    lista[POS_B].bilhetes = bilhetesAUX;
                    lista[POS_B].bilhetes[lista[POS_B].nrBilhetes-1] = bilhetesTemp;
                }else{
                    printf("Ocorreu um erro na memoria");
                }
            break;
            case 'C':
                lista[POS_C].nrBilhetes+=1;
                contador->destinoC+=1;
                bilhetesAUX = realloc(lista[POS_C].bilhetes,lista[POS_C].nrBilhetes*sizeof(bilhetesStruct));
                if(bilhetesAUX!=NULL)
                {
                    lista[POS_C].bilhetes = bilhetesAUX;
                    lista[POS_C].bilhetes[lista[POS_C].nrBilhetes-1] = bilhetesTemp;
                }else{
                    printf("Ocorreu um erro na memoria");
                }
            break;
        }
}