void main()
{
char opcion;
fh = fopen(fich, "rb");
if (fh == NULL)
{
puts("El archivo va a ser creado");
creacion();
}
else
fh = NULL;
do
{
puts("1. Compra ");
puts("2. Venta ");
puts("3. Consulta ");
puts("0. Salir");
do {
printf("> Elige una opción: ");
scanf("%c%*c", &opcion);
} while( opcion < '0' || opcion > '3' );
switch(opcion)
{
case '1':
compra(); break;
case '2':
venta(); break;
case '3':
consulta(); break;
}
} while(opcion != '0');
if (fh != NULL) fclose(fh);
}
bool dbLocal::personas_agregar_muchas(QString datos)
{
QSqlQuery consulta(*baseDatos);
datos.truncate( datos.length() - 1 );
consulta.prepare( "INSERT OR IGNORE INTO temporal "
"VALUES " + datos + ";");
return consulta.exec();
}
_Bool inserir(int chave, char *nome, int idade, char tipo_colisao) {
FILE *f;
Registro reg;
bool result;
int r, hash;
result = consulta(chave, tipo_colisao);
if (result) {
return false;
}
else {
switch (tipo_colisao) {
case 'l':
f = fopen("files/lisch.dat", "r+b");
break;
case 'e':
f = fopen("files/eisch.dat", "r+b");
break;
}
fseek(f, TAMANHO_ARQUIVO*sizeof(Registro), SEEK_SET);
fread(&r, sizeof(int), 1, f);
if (r == -1) {
return true;
}
else {
hash = hashing(chave);
fseek(f, hash*sizeof(Registro), SEEK_SET);
fread(®, sizeof(Registro), 1, f);
if (reg.marcador) {
fclose(f);
switch (tipo_colisao) {
case 'l':
lisch(chave, nome, idade, hash, r);
break;
case 'e':
eisch(chave, nome, idade, hash, r);
break;
}
}
else {
reg.chave = chave;
strcpy(reg.nome, nome);
reg.idade = idade;
reg.prox = -1;
reg.marcador = true;
fseek(f, hash*sizeof(Registro), SEEK_SET);
fwrite(®, sizeof(Registro), 1, f);
fclose(f);
}
return true;
}
}
}
void dbLocal::consolidar_temporal()
{
QSqlQuery consulta(*baseDatos);
consulta.exec("INSERT OR IGNORE INTO 'alumnos' "
"(rut,nombre,apellidoP,apellidoM,curso)"
"SELECT run_alumno,nombre_alumno,ape_paterno_alumno,ape_materno_alumno,"
"glosa_grado||' '||letra_curso "
"FROM temporal ORDER BY run_alumno");
consulta.exec("DELETE FROM temporal");
}
int insere (Listaint*l,int x){
Nolistaint *p;
if((consulta(l,x))||(!(p=(Nolistaint*)malloc(sizeof(Nolistaint)))))
return 0;
p->chave=x;
p->prox=*l;
p->ant=NULL;
if(*l)
p->prox->ant=p;
*l=p;
printf("insercao sucessfull\n");
return 1;
}
void moveParaFim(ListaInt *l, int x){
ListaInt *q, *p;
if(consulta(l, x))
for (p=*l, q=NULL;(p) && (p->chave != x); q=p, p=p->prox);
if(!q)
*l = p-> prox;
else
q->prox = p->prox;
q->chave = x;
q->prox = *l;
*l=q;
free(p);
free(q);
}
::Ice::DispatchStatus
UC3M::CineTicketService::___consulta(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
__checkMode(::Ice::Normal, __current.mode);
::IceInternal::BasicStream* __is = __inS.startReadParams();
::Ice::Int horaSesion;
__is->read(horaSesion);
__inS.endReadParams();
::UC3M::consultasesion __ret = consulta(horaSesion, __current);
::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
__os->write(__ret);
__inS.__endWriteParams(true);
return ::Ice::DispatchOK;
}
void parser(char *expr)
{
struct Pilha pilha;
int x, a, nProd, i, *producao;
int pos = 0;
inicializa(&pilha);
insere(&pilha, FIM);
insere(&pilha, EXPR);
if ((a = lex(expr, &pos)) == ERRO)
erro("Erro lexico", expr, pos);
do
{
x = consulta(&pilha);
if (!(x&NTER))
{
if (x == a)
{
remover (&pilha);
if ((a = lex(expr, &pos)) == ERRO)
erro("Erro lexico", expr, pos);
}
else{
erro("Erro sintatico2",expr, pos);
}
}
if (x&NTER)
{
nProd = STAB[(x&NNTER)-1][(a>>8)-3];
if (nProd)
{
remover (&pilha);
producao = PROD[nProd];
for (i = producao[0]; i > 0; i--){
insere (&pilha, producao[i]);
}
}
else
erro ("Erro sintatico1", expr, pos);
}
} while (x != FIM);
}
int remover (int indiceRemover, Aeroporto *l){
Aeroporto *garagemRmv, *auxiliar, *k;
ListaAviao *aviaoRm;
int resposta;
resposta = consulta (indiceRemover, l);
if (resposta != 0){
garagemRmv = l;
auxiliar = NULL;
while (garagemRmv->prox != NULL) {
if (garagemRmv->prox->garagem == resposta){
auxiliar = garagemRmv->prox;
if (auxiliar->garagem == 1){ //Primeiro elemento da lista
l->prox = auxiliar->prox;
aviaoRm = auxiliar->aviao;
} else if(auxiliar->garagem !=1) { //Demais elementos
garagemRmv->prox=auxiliar->prox;
aviaoRm=auxiliar->aviao;
}
for (k = auxiliar->prox; k != NULL; k = k->prox)
k->garagem = k->garagem-1;
for (k = l->prox; k != NULL; k = k->prox){
if(k->aviao->posicao > aviaoRm->posicao)
k->aviao->posicao = k->aviao->posicao-1;
}
free(aviaoRm);
free(auxiliar);
qtdAviao --;
capacidade ++;
printf ("\nAviao Removido!!!!!!!\n");
return 1;
}else {
auxiliar = garagemRmv->prox;
garagemRmv = garagemRmv->prox;
}
}
}
return 0;
}
int main(){
return consulta();
}
void main(){
propiedad casas[N];
alta(casas);
consulta(casas);
system("pause");
}
_Bool remover(int chave, char tipo_colisao) {
FILE *f;
Registro reg_linkador, reg_buraco, reg, reg1, reg2, reg3;
int i, hash, buraco, caso, substituto = -1, provisorio, linkador, linkado;
bool result = false;
if (consulta(chave, tipo_colisao)) {
switch (tipo_colisao) {
case 'l':
f = fopen("files/lisch.dat", "r+b");
break;
case 'e':
f = fopen("files/eisch.dat", "r+b");
break;
}
hash = hashing(chave);
buraco = hash;
fseek(f, buraco*sizeof(Registro), SEEK_SET);
fread(®, sizeof(Registro), 1, f);
if (reg.chave == chave)
result = true;
// acha o registro pra remover
while ((!result)&&(reg.prox != -1)) {
buraco = reg.prox;
fseek(f, buraco*sizeof(Registro), SEEK_SET);
fread(®, sizeof(Registro), 1, f);
if (reg.chave == chave)
result = true;
}
while (buraco != -1) {
// sei que a posição q tenho q remover esta sendo apontada pela var buraco
fseek(f, buraco*sizeof(Registro), SEEK_SET);
fread(®, sizeof(Registro), 1, f);
strcpy(reg.nome, "aqui");
substituto = -1;
// anunciando qual registro tenho q substituir
// variavel substituto informa qual registro subsittuirá
result = false;
fseek(f, buraco*sizeof(Registro), SEEK_SET);
fread(®1, sizeof(Registro), 1, f);
while ((!result)&&(reg1.prox != -1)) {
fseek(f, reg1.prox*sizeof(Registro), SEEK_SET);
provisorio = reg1.prox;
fread(®1, sizeof(Registro), 1, f);
if (hashing(reg1.chave) == buraco) {
result = true;
substituto = provisorio;
}
}
if (substituto == -1) {
// fazer a linkagem
caso = buraco;
i=0;
result = false;
while ((i<TAMANHO_ARQUIVO)&&(!result)) {
fseek(f, i*sizeof(Registro), SEEK_SET);
fread(®_linkador, sizeof(Registro), 1, f);
if (reg_linkador.prox == buraco) {
linkador = i;
result = true;
}
i++;
}
if (result) {
fseek(f, buraco*sizeof(Registro), SEEK_SET);
fread(®_buraco, sizeof(Registro), 1, f);
if (reg_buraco.prox != -1) {
linkado = reg_buraco.prox;
fseek(f, linkador*sizeof(Registro), SEEK_SET);
fread(®_linkador, sizeof(Registro), 1, f);
reg_linkador.prox = linkado;
fseek(f, linkador*sizeof(Registro), SEEK_SET);
fwrite(®_linkador, sizeof(Registro), 1, f);
}
else {
fseek(f, linkador*sizeof(Registro), SEEK_SET);
fread(®_linkador, sizeof(Registro), 1, f);
reg_linkador.prox = -1;
fwrite(®_linkador, sizeof(Registro), 1, f);
}
}
fclose(f);
reinicializar(buraco-1, tipo_colisao);
buraco = -1;
}
else {
fseek(f, buraco*sizeof(Registro), SEEK_SET);
fread(®2, sizeof(Registro), 1, f);
fseek(f, substituto*sizeof(Registro), SEEK_SET);
fread(®3, sizeof(Registro), 1, f);
reg2.chave = reg3.chave;
strcpy(reg2.nome, reg3.nome);
reg2.idade = reg3.idade;
fseek(f, buraco*sizeof(Registro), SEEK_SET);
fwrite(®2, sizeof(Registro), 1, f);
buraco = substituto;
}
}
}
else {
fclose(f);
return false;
}
reposicionar(tipo_colisao);
return true;
}
/*!
* \brief consultarChave Imprime o resultado da consulta
*
* Consulta uma chave na arvore e retorna a possibilidade de sua existência
*
* \param a Arvore binaria
* \param x Inteiro a ser pesquisado
*/
void consultarChave(ArvoreInt *a, int x){
if(consulta(a, x))
printf("existe no com chave: %d\n", x);
else
printf("nao existe no com chave: %d\n", x);
}
int main(){
int control[1000][5]; // 1000 filas es el maximo
int registros = 0;
bool salirDelMenu = false;
int id,op,op2,columna;
while(!salirDelMenu){
mostrarOpcionesMenu();
scanf("%i",&op);
switch(op) {
case 1:
alta(control,registros);
registros++;
break;
case 2:
printf("Que enfermera quieres consultar: ");
scanf("%d",&id);
consulta(control,registros,id);
break;
case 3:
printf("Que enfermera quieres modificar: ");
scanf("%d",&id);
modificar(control, registros, id);
break;
case 4:
printf("Reportes posibles:\n");
printf("1.- Orden Ascendente\n");
printf("2.- Orden Descendente\n");
printf("3.- Todas las enfermeras\n");
printf("Tipo de reporte elegido: ");
scanf("%d",&op2);
printf("\n");
switch(op2){
case 1:
printf("Reporte ascendente por indicador:\n");
printf("1.- ID\n");
printf("2.- Edad\n");
printf("3.- Pacientes\n");
printf("4.- Horario\n");
printf("5.- Piso\n");
printf("Indicador elegido: ");
scanf("%d",&columna);
printf("\n");
if(columna > 0 && columna <= 5){
ordenAscendente(control,registros,columna-1);
} else
printf("Opcion no valida\n");
break;
case 2:
printf("Reporte descendente por indicador:\n");
printf("1.- ID\n");
printf("2.- Edad\n");
printf("3.- Pacientes\n");
printf("4.- Horario\n");
printf("5.- Piso\n");
printf("Indicador elegido: ");
scanf("%d",&columna);
printf("\n");
if(columna > 0 && columna <= 5){
ordenDescendente(control,registros,columna-1);
} else
printf("Opcion no valida\n");
break;
case 3:
imprimirTodaLaMatriz(control,registros);
break;
default:
printf("Opcion no valida\n");
}
break;
case 5:
printf("GRACIAS POR USAR NUESTRO SISTEMA\n");
salirDelMenu = true;
break;
default:
printf("Opcion no valida\n");
}
}
return 0;
}
int main()
{
char op[1];
listaEnc *l;
int a,b,c,antigo,novo;
inicializa(&l);
for(;;)
{
system("CLS");
printf("Programa Lista Encadeada!\n\n");
printf("I - Insercao\n");
printf("R - Remocao\n");
printf("A - Alteracao\n");
printf("C - Consulta\n");
printf("P - Impressao\n");
printf("S - Sair\n\n");
gets(op);
switch(toupper(op[0])){
case 'I':
{
system("CLS");
printf("\nDigite o Elemento a Inserir: ");
scanf("%d", &a);
a = insere(a);
if(a)
{
printf("\nElemento Inserido com Sucesso!\n");
imprime();
getchar();
}
else
{
printf("\nElemento ja existe!\n");
imprime();
getchar();
}
}break;
case 'R':
{
system("CLS");
if(i == NULL)
{
printf("\nLista Vazia!");
getchar();
}
else
{
printf("\nDigite o Elemento a Remover: ");
scanf("%d", &a);
remover(a);
}
}break;
case 'A':
{
system("CLS");
printf("\nEscreva o valor a ser alterado\n");
scanf("%d", &antigo);
printf("\nEscreva o novo valor ser escrito\n");
scanf("%d", &novo);
altera(&l,antigo,novo);
imprime();
getchar();
}break;
case 'P':
{
system("CLS");
imprime();
}break;
case 'C':
{
system("CLS");
printf("Qual o valor a ser procurado?\n");
scanf("%d", &b);
c = consulta(b);
if (c)
{
system("CLS");
printf("Valor presente na lista\n");
imprime();
getchar();
}
else
{
system("CLS");
printf("Valor nao encontrado\n");
imprime();
getchar();
}
}break;
case 'S':
{
exit(0);
}break;
}
}
return (0);
}
int main() {
FILE *f;
Registro reg;
char tipo_colisao, opcao, nome[20];
int r, chave, idade, result;
bool fechado = false;
float media_acesso;
scanf(" %c", &tipo_colisao);
switch (tipo_colisao) {
case 'l':
f = fopen("files/lisch.dat", "r+b");
if (f == NULL) {
f = fopen("files/lisch.dat", "w+b");
fclose(f);
popular('l');
fechado = true;
}
if (!fechado)
fclose(f);
break;
case 'e':
f = fopen("files/eisch.dat", "r+b");
if (f == NULL) {
f = fopen("files/eisch.dat", "w+b");
fclose(f);
popular('e');
fechado = true;
}
if (!fechado)
fclose(f);
break;
}
scanf(" %c", &opcao);
while (opcao != 'e') {
switch (opcao) {
case 'i':
// Fluxo para inserção
scanf(" %d ", &chave);
gets(nome);
scanf(" %d", &idade);
result = inserir(chave, nome, idade, tipo_colisao);
if (!result) {
printf("chave ja existente: %d\n", chave);
}
break;
case 'c':
// Fluxo para consulta
scanf(" %d", &chave);
result = consulta(chave, tipo_colisao);
if (result) {
imprime_chave(chave, tipo_colisao);
}
else {
printf("chave nao encontrada: %d\n", chave);
}
break;
case 'p':
// Fluxo para impressão do arquivo
imprimir(tipo_colisao);
break;
case 'm':
// Fluxo para média de acesso
media_acesso = media(tipo_colisao);
printf("%.1f\n", media_acesso);
break;
case 'r':
// Fluxo para remoção
scanf(" %d", &chave);
result = remover(chave, tipo_colisao);
if (!result) {
printf("chave nao encontrada: %d\n", chave);
}
break;
}
scanf(" %c", &opcao);
}
return 0;
}
//aqui recebe uma string e são tratados todos os chars para o proposito do programa
int calcular(char g_char[], pilha *p){
if( isEnter(g_char[0]) || !isEmpty(p)){
int i = 0;
while(g_char[i] != '\0'){
//insere o estado dos calculos
if(!isClear(g_char[i]) && !isConsulta(g_char[i])){
if(isEmpty(p))
printf("- ");
consulta_inversa(p);
printf("\n");
}
//se for numero insere na pilha
if(isNum(g_char[i])){
insertNum(p, g_char[i] - 48);
//se o char anterior tbm for numero faz calculo para fazer dos 2 um numero
if(isNum(g_char[i-1] )|| isEnter(g_char[i-1]))
faz_calculo(p);
else{
clear_calc(p);
if(!RUN_CODES){
exibeHeader();
printf("\nErro! Voce deve usar necessariamente \'E\' para informar a entrada de um numero\n");
}
}
i++;
continue;
}
//se for um E insere 0 na pilha
if(isEnter(g_char[i])){
insertNum(p, 0);
i++;
continue;
}
//se for '-' faz uma subtração
if(g_char[i] == '-'){
faz_sub(p);
i++;
continue;
}
//se for '+' faz uma adição
if(g_char[i] == '+'){
faz_soma(p);
i++;
continue;
}
//se for '/' faz uma divisão
if(g_char[i] == '/'){
faz_div(p);
i++;
continue;
}
//se for '*' faz uma multiplicação
if(g_char[i] == '*'){
faz_mult(p);
i++;
continue;
}
//se for '^' faz uma potencia
if(g_char[i] == '^'){
faz_pow(p);
i++;
continue;
}
//se for '!' faz um fatorial
if(g_char[i] == '!'){
faz_fatorial(p);
i++;
continue;
}
//se for C limpa a pilha
if(isClear(g_char[i])){
clear_calc(p);
if(!RUN_CODES){
exibeHeader();
printf("\nPilha Vazia\n");
}
i++;
continue;
}
//se for V faz uma consulta na pilha
if(isConsulta(g_char[i]) && strlen(g_char) == 1){
if(!RUN_CODES)
consulta(p);
i++;
}
}
if(!isConsulta(g_char[i-1]))
//consulta que exibe a pilha ao contrario
consulta_inversa(p);
if(!RUN_CODES)
printf("\n");
return 0;
}else{
//se o char indice 0 for V exibe a consulta
if(isConsulta(g_char[0]))
if(!RUN_CODES)
consulta(p);
else{
//se o char indice 0 for C limpa a pilha
if(isClear(g_char[0]))
clear_calc(p);
else
return 1;
}
}
}
int main(void)
{
AGENDA * pAgenda;
int iEntradas, op;
iEntradas=0;
pAgenda = (AGENDA *) malloc(sizeof(AGENDA)); /* alocando espaco para a posicao 0
do vetor */
if( pAgenda == NULL )
{
printf("\nErro de alocacao de memoria.");
exit(1);
}
do
{
fflush(stdin);
printf("\n1 - Inclusao");
printf("\n2 - Alteracao");
printf("\n3 - Consulta");
printf("\n4 - Excluir");
printf("\n5 - Pesquisar");
printf("\n9 - Sair");
printf("\nEntre com uma opcao -> ");
scanf("%d", &op);
if( op == 1 )
{
/* farei aqui para ilustrar algumas formas de manipular ponteiros */
fflush(stdin);
/* alocacao de ponteiros em funcoes requer trabalhar com ponteiros
para ponteiros */
aloca(&pAgenda, &iEntradas);
printf("*** Inclusao ***");
printf("\nEntre com o Nome:");
/* forma 1 - endereco ponteiro inicial + x posicoes na memoria
quando se trabalhar com o endereco, deve-se usar -> */
gets((pAgenda+iEntradas)->nome);
fflush(stdin);
printf("Entre com o email:");
/* forma 2 - endereco ponteiro inicial + x posicoes na memoria
quando se trabalhar com ponteiro (conte?do do endereco ou *),
deve-se usar o . (ponto) */
gets((*(pAgenda+iEntradas)).email);
fflush(stdin);
printf("Entre com o telefone:");
/* forma 3 - trabalhando como vetor */
scanf("%d", &pAgenda[iEntradas].telefone);
fflush(stdin);
iEntradas++;
}
else if( op == 2)
{
alterar(pAgenda, iEntradas);
}
else if( op == 3 )
{
/* se o vetor de estruturas vai ser somente lido
nao eh preciso passar ponteiro para ponteiro */
ordena(pAgenda, iEntradas);
consulta(pAgenda, iEntradas);
}
else if( op == 4)
{
ordena(pAgenda, iEntradas);
excluir(&pAgenda, &iEntradas);
}
else if( op == 5)
{
ordena(pAgenda, iEntradas);
pesquisar(pAgenda,iEntradas);
}
} while(op!=9);
}
